From a7003b6821c357157d1af394061ccd5b768c3507 Mon Sep 17 00:00:00 2001 From: Lukas Woehrl Date: Mon, 19 Dec 2016 19:15:48 +0100 Subject: [PATCH] code review changes --- gentest/gentest-cpp.js | 22 +-- tests/YGAbsolutePositionTest.cpp | 100 +++++----- tests/YGAlignContentTest.cpp | 86 ++++----- tests/YGAlignItemsTest.cpp | 30 +-- tests/YGAlignSelfTest.cpp | 32 ++-- tests/YGBorderTest.cpp | 24 +-- tests/YGDirtyMarkingTest.cpp | 36 ++-- tests/YGEdgeTest.cpp | 66 +++---- tests/YGFlexDirectionTest.cpp | 56 +++--- tests/YGFlexTest.cpp | 58 +++--- tests/YGFlexWrapTest.cpp | 72 ++++---- tests/YGJustifyContentTest.cpp | 98 +++++----- tests/YGLayoutDefaultValuesTest.cpp | 50 ++--- tests/YGMarginTest.cpp | 64 +++---- tests/YGMinMaxDimensionTest.cpp | 80 ++++---- tests/YGPaddingTest.cpp | 78 ++++---- tests/YGPercentageTest.cpp | 236 ++++++++++++------------ tests/YGRelayoutTest.cpp | 4 +- tests/YGRoundingTest.cpp | 118 ++++++------ yoga/Yoga.c | 273 +++++++++++----------------- yoga/Yoga.h | 14 +- 21 files changed, 768 insertions(+), 829 deletions(-) diff --git a/gentest/gentest-cpp.js b/gentest/gentest-cpp.js index 7ab7e7de..b66eb10a 100644 --- a/gentest/gentest-cpp.js +++ b/gentest/gentest-cpp.js @@ -12,7 +12,7 @@ function toValueCpp(value) { return n + (Number(n) == n && n % 1 !== 0 ? 'f' : ''); } -function toValueCppWithUnitCpp(value) { +function toValueCppCpp(value) { var methodName = ''; if(value.indexOf('px') >= 0){ methodName = 'YGPx'; @@ -164,7 +164,7 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, { }}, YGNodeStyleSetFlexBasis:{value:function(nodeName, value) { - this.push('YGNodeStyleSetFlexBasisWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetFlexBasis(' + nodeName + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetFlexDirection:{value:function(nodeName, value) { @@ -184,7 +184,7 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, { }}, YGNodeStyleSetHeight:{value:function(nodeName, value) { - this.push('YGNodeStyleSetHeightWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetHeight(' + nodeName + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetJustifyContent:{value:function(nodeName, value) { @@ -192,23 +192,23 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, { }}, YGNodeStyleSetMargin:{value:function(nodeName, edge, value) { - this.push('YGNodeStyleSetMarginWithUnit(' + nodeName + ', ' + edge + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetMargin(' + nodeName + ', ' + edge + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetMaxHeight:{value:function(nodeName, value) { - this.push('YGNodeStyleSetMaxHeightWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetMaxHeight(' + nodeName + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetMaxWidth:{value:function(nodeName, value) { - this.push('YGNodeStyleSetMaxWidthWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetMaxWidth(' + nodeName + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetMinHeight:{value:function(nodeName, value) { - this.push('YGNodeStyleSetMinHeightWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetMinHeight(' + nodeName + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetMinWidth:{value:function(nodeName, value) { - this.push('YGNodeStyleSetMinWidthWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetMinWidth(' + nodeName + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetOverflow:{value:function(nodeName, value) { @@ -216,11 +216,11 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, { }}, YGNodeStyleSetPadding:{value:function(nodeName, edge, value) { - this.push('YGNodeStyleSetPaddingWithUnit(' + nodeName + ', ' + edge + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetPadding(' + nodeName + ', ' + edge + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetPosition:{value:function(nodeName, edge, value) { - this.push('YGNodeStyleSetPositionWithUnit(' + nodeName + ', ' + edge + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetPosition(' + nodeName + ', ' + edge + ', ' + toValueCppCpp(value) + ');'); }}, YGNodeStyleSetPositionType:{value:function(nodeName, value) { @@ -228,6 +228,6 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, { }}, YGNodeStyleSetWidth:{value:function(nodeName, value) { - this.push('YGNodeStyleSetWidthWithUnit(' + nodeName + ', ' + toValueCppWithUnitCpp(value) + ');'); + this.push('YGNodeStyleSetWidth(' + nodeName + ', ' + toValueCppCpp(value) + ');'); }}, }); diff --git a/tests/YGAbsolutePositionTest.cpp b/tests/YGAbsolutePositionTest.cpp index 25b842c5..9187c37b 100644 --- a/tests/YGAbsolutePositionTest.cpp +++ b/tests/YGAbsolutePositionTest.cpp @@ -14,15 +14,15 @@ TEST(YogaTest, absolute_layout_width_height_start_top) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeStart, YGPx(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(10)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeStart, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -53,15 +53,15 @@ TEST(YogaTest, absolute_layout_width_height_start_top) { TEST(YogaTest, absolute_layout_width_height_end_bottom) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeEnd, YGPx(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeBottom, YGPx(10)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeEnd, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -92,15 +92,15 @@ TEST(YogaTest, absolute_layout_width_height_end_bottom) { TEST(YogaTest, absolute_layout_start_top_end_bottom) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeStart, YGPx(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeEnd, YGPx(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeStart, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeEnd, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeBottom, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -131,17 +131,17 @@ TEST(YogaTest, absolute_layout_start_top_end_bottom) { TEST(YogaTest, absolute_layout_width_height_start_top_end_bottom) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeStart, YGPx(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeEnd, YGPx(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeBottom, YGPx(10)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeStart, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeEnd, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -174,18 +174,18 @@ TEST(YogaTest, do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hi const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetOverflow(root, YGOverflowHidden); - YGNodeStyleSetWidthWithUnit(root, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root, YGPx(50)); + YGNodeStyleSetWidth(root, YGPx(50)); + YGNodeStyleSetHeight(root, YGPx(50)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeStart, YGPx(0)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(0)); + YGNodeStyleSetPosition(root_child0, YGEdgeStart, YGPx(0)); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(0)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child0_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0_child0, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(100)); + YGNodeStyleSetWidth(root_child0_child0, YGPx(100)); + YGNodeStyleSetHeight(root_child0_child0, YGPx(100)); YGNodeInsertChild(root_child0, root_child0_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -226,35 +226,35 @@ TEST(YogaTest, do_not_clamp_height_of_absolute_node_to_height_of_its_overflow_hi TEST(YogaTest, absolute_layout_within_border) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetMarginWithUnit(root, YGEdgeLeft, YGPx(10)); - YGNodeStyleSetMarginWithUnit(root, YGEdgeTop, YGPx(10)); - YGNodeStyleSetMarginWithUnit(root, YGEdgeRight, YGPx(10)); - YGNodeStyleSetMarginWithUnit(root, YGEdgeBottom, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetMargin(root, YGEdgeLeft, YGPx(10)); + YGNodeStyleSetMargin(root, YGEdgeTop, YGPx(10)); + YGNodeStyleSetMargin(root, YGEdgeRight, YGPx(10)); + YGNodeStyleSetMargin(root, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10)); YGNodeStyleSetBorder(root, YGEdgeLeft, 10); YGNodeStyleSetBorder(root, YGEdgeTop, 10); YGNodeStyleSetBorder(root, YGEdgeRight, 10); YGNodeStyleSetBorder(root, YGEdgeBottom, 10); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeLeft, YGPx(0)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPx(0)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(50)); + YGNodeStyleSetPosition(root_child0, YGEdgeLeft, YGPx(0)); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPx(0)); + YGNodeStyleSetWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(50)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetPositionType(root_child1, YGPositionTypeAbsolute); - YGNodeStyleSetPositionWithUnit(root_child1, YGEdgeRight, YGPx(0)); - YGNodeStyleSetPositionWithUnit(root_child1, YGEdgeBottom, YGPx(0)); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(50)); + YGNodeStyleSetPosition(root_child1, YGEdgeRight, YGPx(0)); + YGNodeStyleSetPosition(root_child1, YGEdgeBottom, YGPx(0)); + YGNodeStyleSetWidth(root_child1, YGPx(50)); + YGNodeStyleSetHeight(root_child1, YGPx(50)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGAlignContentTest.cpp b/tests/YGAlignContentTest.cpp index e836d098..d5e09f93 100644 --- a/tests/YGAlignContentTest.cpp +++ b/tests/YGAlignContentTest.cpp @@ -15,32 +15,32 @@ TEST(YogaTest, align_content_flex_start) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexWrap(root, YGWrapWrap); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(50)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(50)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); const YGNodeRef root_child3 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child3, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child3, YGPx(10)); + YGNodeStyleSetWidth(root_child3, YGPx(50)); + YGNodeStyleSetHeight(root_child3, YGPx(10)); YGNodeInsertChild(root, root_child3, 3); const YGNodeRef root_child4 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child4, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child4, YGPx(10)); + YGNodeStyleSetWidth(root_child4, YGPx(50)); + YGNodeStyleSetHeight(root_child4, YGPx(10)); YGNodeInsertChild(root, root_child4, 4); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -113,32 +113,32 @@ TEST(YogaTest, align_content_flex_end) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignContent(root, YGAlignFlexEnd); YGNodeStyleSetFlexWrap(root, YGWrapWrap); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(50)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(50)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); const YGNodeRef root_child3 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child3, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child3, YGPx(10)); + YGNodeStyleSetWidth(root_child3, YGPx(50)); + YGNodeStyleSetHeight(root_child3, YGPx(10)); YGNodeInsertChild(root, root_child3, 3); const YGNodeRef root_child4 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child4, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child4, YGPx(10)); + YGNodeStyleSetWidth(root_child4, YGPx(50)); + YGNodeStyleSetHeight(root_child4, YGPx(10)); YGNodeInsertChild(root, root_child4, 4); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -211,32 +211,32 @@ TEST(YogaTest, align_content_center) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignContent(root, YGAlignCenter); YGNodeStyleSetFlexWrap(root, YGWrapWrap); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(50)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(50)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); const YGNodeRef root_child3 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child3, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child3, YGPx(10)); + YGNodeStyleSetWidth(root_child3, YGPx(50)); + YGNodeStyleSetHeight(root_child3, YGPx(10)); YGNodeInsertChild(root, root_child3, 3); const YGNodeRef root_child4 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child4, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child4, YGPx(10)); + YGNodeStyleSetWidth(root_child4, YGPx(50)); + YGNodeStyleSetHeight(root_child4, YGPx(10)); YGNodeInsertChild(root, root_child4, 4); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -309,27 +309,27 @@ TEST(YogaTest, align_content_stretch) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignContent(root, YGAlignStretch); YGNodeStyleSetFlexWrap(root, YGWrapWrap); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50)); + YGNodeStyleSetWidth(root_child0, YGPx(50)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50)); + YGNodeStyleSetWidth(root_child1, YGPx(50)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50)); + YGNodeStyleSetWidth(root_child2, YGPx(50)); YGNodeInsertChild(root, root_child2, 2); const YGNodeRef root_child3 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child3, YGPx(50)); + YGNodeStyleSetWidth(root_child3, YGPx(50)); YGNodeInsertChild(root, root_child3, 3); const YGNodeRef root_child4 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child4, YGPx(50)); + YGNodeStyleSetWidth(root_child4, YGPx(50)); YGNodeInsertChild(root, root_child4, 4); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGAlignItemsTest.cpp b/tests/YGAlignItemsTest.cpp index a1a3bcb6..90a7cee6 100644 --- a/tests/YGAlignItemsTest.cpp +++ b/tests/YGAlignItemsTest.cpp @@ -14,11 +14,11 @@ TEST(YogaTest, align_items_stretch) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -50,12 +50,12 @@ TEST(YogaTest, align_items_stretch) { TEST(YogaTest, align_items_center) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignItems(root, YGAlignCenter); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -87,12 +87,12 @@ TEST(YogaTest, align_items_center) { TEST(YogaTest, align_items_flex_start) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignItems(root, YGAlignFlexStart); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -124,12 +124,12 @@ TEST(YogaTest, align_items_flex_start) { TEST(YogaTest, align_items_flex_end) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignItems(root, YGAlignFlexEnd); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGAlignSelfTest.cpp b/tests/YGAlignSelfTest.cpp index 88894aba..6293c725 100644 --- a/tests/YGAlignSelfTest.cpp +++ b/tests/YGAlignSelfTest.cpp @@ -14,13 +14,13 @@ TEST(YogaTest, align_self_center) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetAlignSelf(root_child0, YGAlignCenter); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -51,13 +51,13 @@ TEST(YogaTest, align_self_center) { TEST(YogaTest, align_self_flex_end) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexEnd); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -88,13 +88,13 @@ TEST(YogaTest, align_self_flex_end) { TEST(YogaTest, align_self_flex_start) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexStart); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -126,13 +126,13 @@ TEST(YogaTest, align_self_flex_start) { TEST(YogaTest, align_self_flex_end_override_flex_start) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignItems(root, YGAlignFlexStart); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexEnd); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGBorderTest.cpp b/tests/YGBorderTest.cpp index 306f1c37..3b8743e1 100644 --- a/tests/YGBorderTest.cpp +++ b/tests/YGBorderTest.cpp @@ -43,8 +43,8 @@ TEST(YogaTest, border_container_match_child) { YGNodeStyleSetBorder(root, YGEdgeBottom, 10); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -79,12 +79,12 @@ TEST(YogaTest, border_flex_child) { YGNodeStyleSetBorder(root, YGEdgeTop, 10); YGNodeStyleSetBorder(root, YGEdgeRight, 10); YGNodeStyleSetBorder(root, YGEdgeBottom, 10); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -119,11 +119,11 @@ TEST(YogaTest, border_stretch_child) { YGNodeStyleSetBorder(root, YGEdgeTop, 10); YGNodeStyleSetBorder(root, YGEdgeRight, 10); YGNodeStyleSetBorder(root, YGEdgeBottom, 10); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -159,12 +159,12 @@ TEST(YogaTest, border_center_child) { YGNodeStyleSetBorder(root, YGEdgeStart, 10); YGNodeStyleSetBorder(root, YGEdgeEnd, 20); YGNodeStyleSetBorder(root, YGEdgeBottom, 20); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGDirtyMarkingTest.cpp b/tests/YGDirtyMarkingTest.cpp index 3888966e..e5035835 100644 --- a/tests/YGDirtyMarkingTest.cpp +++ b/tests/YGDirtyMarkingTest.cpp @@ -13,22 +13,22 @@ TEST(YogaTest, dirty_propagation) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignItems(root, YGAlignFlexStart); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidth(root_child0, 50); - YGNodeStyleSetHeight(root_child0, 20); + YGNodeStyleSetWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidth(root_child1, 50); - YGNodeStyleSetHeight(root_child1, 20); + YGNodeStyleSetWidth(root_child1, YGPx(50)); + YGNodeStyleSetHeight(root_child1, YGPx(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); - YGNodeStyleSetWidth(root_child0, 20); + YGNodeStyleSetWidth(root_child0, YGPx(20)); EXPECT_TRUE(YGNodeIsDirty(root_child0)); EXPECT_FALSE(YGNodeIsDirty(root_child1)); @@ -46,22 +46,22 @@ TEST(YogaTest, dirty_propagation) { TEST(YogaTest, dirty_propagation_only_if_prop_changed) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignItems(root, YGAlignFlexStart); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidth(root_child0, 50); - YGNodeStyleSetHeight(root_child0, 20); + YGNodeStyleSetWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidth(root_child1, 50); - YGNodeStyleSetHeight(root_child1, 20); + YGNodeStyleSetWidth(root_child1, YGPx(50)); + YGNodeStyleSetHeight(root_child1, YGPx(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); - YGNodeStyleSetWidth(root_child0, 50); + YGNodeStyleSetWidth(root_child0, YGPx(50)); EXPECT_FALSE(YGNodeIsDirty(root_child0)); EXPECT_FALSE(YGNodeIsDirty(root_child1)); @@ -73,12 +73,12 @@ TEST(YogaTest, dirty_propagation_only_if_prop_changed) { TEST(YogaTest, dirty_node_only_if_children_are_actually_removed) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignItems(root, YGAlignFlexStart); - YGNodeStyleSetWidth(root, 50); - YGNodeStyleSetHeight(root, 50); + YGNodeStyleSetWidth(root, YGPx(50)); + YGNodeStyleSetHeight(root, YGPx(50)); const YGNodeRef child0 = YGNodeNew(); - YGNodeStyleSetWidth(child0, 50); - YGNodeStyleSetHeight(child0, 25); + YGNodeStyleSetWidth(child0, YGPx(50)); + YGNodeStyleSetHeight(child0, YGPx(25)); YGNodeInsertChild(root, child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGEdgeTest.cpp b/tests/YGEdgeTest.cpp index 4122b11b..df6a0a55 100644 --- a/tests/YGEdgeTest.cpp +++ b/tests/YGEdgeTest.cpp @@ -13,14 +13,14 @@ TEST(YogaTest, start_overrides) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMargin(root_child0, YGEdgeStart, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 20); - YGNodeStyleSetMargin(root_child0, YGEdgeRight, 20); + YGNodeStyleSetMargin(root_child0, YGEdgeStart, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(20)); + YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -37,14 +37,14 @@ TEST(YogaTest, start_overrides) { TEST(YogaTest, end_overrides) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMargin(root_child0, YGEdgeEnd, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 20); - YGNodeStyleSetMargin(root_child0, YGEdgeRight, 20); + YGNodeStyleSetMargin(root_child0, YGEdgeEnd, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(20)); + YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -61,13 +61,13 @@ TEST(YogaTest, end_overrides) { TEST(YogaTest, horizontal_overridden) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMargin(root_child0, YGEdgeHorizontal, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 20); + YGNodeStyleSetMargin(root_child0, YGEdgeHorizontal, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -80,13 +80,13 @@ TEST(YogaTest, horizontal_overridden) { TEST(YogaTest, vertical_overridden) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMargin(root_child0, YGEdgeVertical, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeTop, 20); + YGNodeStyleSetMargin(root_child0, YGEdgeVertical, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -99,13 +99,13 @@ TEST(YogaTest, vertical_overridden) { TEST(YogaTest, horizontal_overrides_all) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMargin(root_child0, YGEdgeHorizontal, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeAll, 20); + YGNodeStyleSetMargin(root_child0, YGEdgeHorizontal, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeAll, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -120,13 +120,13 @@ TEST(YogaTest, horizontal_overrides_all) { TEST(YogaTest, vertical_overrides_all) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMargin(root_child0, YGEdgeVertical, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeAll, 20); + YGNodeStyleSetMargin(root_child0, YGEdgeVertical, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeAll, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -141,16 +141,16 @@ TEST(YogaTest, vertical_overrides_all) { TEST(YogaTest, all_overridden) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn); - YGNodeStyleSetWidth(root, 100); - YGNodeStyleSetHeight(root, 100); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeTop, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeRight, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 10); - YGNodeStyleSetMargin(root_child0, YGEdgeAll, 20); + YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeAll, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGFlexDirectionTest.cpp b/tests/YGFlexDirectionTest.cpp index 47168b99..30cb2a4b 100644 --- a/tests/YGFlexDirectionTest.cpp +++ b/tests/YGFlexDirectionTest.cpp @@ -14,18 +14,18 @@ TEST(YogaTest, flex_direction_column_no_height) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -77,18 +77,18 @@ TEST(YogaTest, flex_direction_column_no_height) { TEST(YogaTest, flex_direction_row_no_width) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -139,19 +139,19 @@ TEST(YogaTest, flex_direction_row_no_width) { TEST(YogaTest, flex_direction_column) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -203,19 +203,19 @@ TEST(YogaTest, flex_direction_column) { TEST(YogaTest, flex_direction_row) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -267,19 +267,19 @@ TEST(YogaTest, flex_direction_row) { TEST(YogaTest, flex_direction_column_reverse) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumnReverse); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -331,19 +331,19 @@ TEST(YogaTest, flex_direction_column_reverse) { TEST(YogaTest, flex_direction_row_reverse) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRowReverse); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGFlexTest.cpp b/tests/YGFlexTest.cpp index 60641472..69cf569a 100644 --- a/tests/YGFlexTest.cpp +++ b/tests/YGFlexTest.cpp @@ -14,12 +14,12 @@ TEST(YogaTest, flex_basis_flex_grow_column) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); @@ -65,12 +65,12 @@ TEST(YogaTest, flex_basis_flex_grow_column) { TEST(YogaTest, flex_basis_flex_grow_row) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); @@ -115,16 +115,16 @@ TEST(YogaTest, flex_basis_flex_grow_row) { TEST(YogaTest, flex_basis_flex_shrink_column) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexShrink(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(100)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(100)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPx(50)); + YGNodeStyleSetFlexBasis(root_child1, YGPx(50)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -166,16 +166,16 @@ TEST(YogaTest, flex_basis_flex_shrink_column) { TEST(YogaTest, flex_basis_flex_shrink_row) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexShrink(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(100)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(100)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPx(50)); + YGNodeStyleSetFlexBasis(root_child1, YGPx(50)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -216,22 +216,22 @@ TEST(YogaTest, flex_basis_flex_shrink_row) { TEST(YogaTest, flex_shrink_to_zero) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root, YGPx(75)); + YGNodeStyleSetHeight(root, YGPx(75)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(50)); + YGNodeStyleSetWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(50)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexShrink(root_child1, 1); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(50)); + YGNodeStyleSetWidth(root_child1, YGPx(50)); + YGNodeStyleSetHeight(root_child1, YGPx(50)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(50)); + YGNodeStyleSetWidth(root_child2, YGPx(50)); + YGNodeStyleSetHeight(root_child2, YGPx(50)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -282,23 +282,23 @@ TEST(YogaTest, flex_shrink_to_zero) { TEST(YogaTest, flex_basis_overrides_main_size) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child2, 1); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -349,8 +349,8 @@ TEST(YogaTest, flex_basis_overrides_main_size) { TEST(YogaTest, flex_grow_shrink_at_most) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeInsertChild(root, root_child0, 0); diff --git a/tests/YGFlexWrapTest.cpp b/tests/YGFlexWrapTest.cpp index 093fd2d7..32e86a6e 100644 --- a/tests/YGFlexWrapTest.cpp +++ b/tests/YGFlexWrapTest.cpp @@ -15,26 +15,26 @@ TEST(YogaTest, wrap_column) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexWrap(root, YGWrapWrap); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(30)); + YGNodeStyleSetWidth(root_child0, YGPx(30)); + YGNodeStyleSetHeight(root_child0, YGPx(30)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(30)); + YGNodeStyleSetWidth(root_child1, YGPx(30)); + YGNodeStyleSetHeight(root_child1, YGPx(30)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(30)); + YGNodeStyleSetWidth(root_child2, YGPx(30)); + YGNodeStyleSetHeight(root_child2, YGPx(30)); YGNodeInsertChild(root, root_child2, 2); const YGNodeRef root_child3 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child3, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child3, YGPx(30)); + YGNodeStyleSetWidth(root_child3, YGPx(30)); + YGNodeStyleSetHeight(root_child3, YGPx(30)); YGNodeInsertChild(root, root_child3, 3); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -97,26 +97,26 @@ TEST(YogaTest, wrap_row) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetFlexWrap(root, YGWrapWrap); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(30)); + YGNodeStyleSetWidth(root_child0, YGPx(30)); + YGNodeStyleSetHeight(root_child0, YGPx(30)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(30)); + YGNodeStyleSetWidth(root_child1, YGPx(30)); + YGNodeStyleSetHeight(root_child1, YGPx(30)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(30)); + YGNodeStyleSetWidth(root_child2, YGPx(30)); + YGNodeStyleSetHeight(root_child2, YGPx(30)); YGNodeInsertChild(root, root_child2, 2); const YGNodeRef root_child3 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child3, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child3, YGPx(30)); + YGNodeStyleSetWidth(root_child3, YGPx(30)); + YGNodeStyleSetHeight(root_child3, YGPx(30)); YGNodeInsertChild(root, root_child3, 3); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -180,26 +180,26 @@ TEST(YogaTest, wrap_row_align_items_flex_end) { YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetAlignItems(root, YGAlignFlexEnd); YGNodeStyleSetFlexWrap(root, YGWrapWrap); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(30)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(20)); + YGNodeStyleSetWidth(root_child1, YGPx(30)); + YGNodeStyleSetHeight(root_child1, YGPx(20)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(30)); + YGNodeStyleSetWidth(root_child2, YGPx(30)); + YGNodeStyleSetHeight(root_child2, YGPx(30)); YGNodeInsertChild(root, root_child2, 2); const YGNodeRef root_child3 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child3, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child3, YGPx(30)); + YGNodeStyleSetWidth(root_child3, YGPx(30)); + YGNodeStyleSetHeight(root_child3, YGPx(30)); YGNodeInsertChild(root, root_child3, 3); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -263,26 +263,26 @@ TEST(YogaTest, wrap_row_align_items_center) { YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetAlignItems(root, YGAlignCenter); YGNodeStyleSetFlexWrap(root, YGWrapWrap); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(30)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(20)); + YGNodeStyleSetWidth(root_child1, YGPx(30)); + YGNodeStyleSetHeight(root_child1, YGPx(20)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(30)); + YGNodeStyleSetWidth(root_child2, YGPx(30)); + YGNodeStyleSetHeight(root_child2, YGPx(30)); YGNodeInsertChild(root, root_child2, 2); const YGNodeRef root_child3 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child3, YGPx(30)); - YGNodeStyleSetHeightWithUnit(root_child3, YGPx(30)); + YGNodeStyleSetWidth(root_child3, YGPx(30)); + YGNodeStyleSetHeight(root_child3, YGPx(30)); YGNodeInsertChild(root, root_child3, 3); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGJustifyContentTest.cpp b/tests/YGJustifyContentTest.cpp index 2307d199..260d3914 100644 --- a/tests/YGJustifyContentTest.cpp +++ b/tests/YGJustifyContentTest.cpp @@ -15,19 +15,19 @@ TEST(YogaTest, justify_content_row_flex_start) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -80,19 +80,19 @@ TEST(YogaTest, justify_content_row_flex_end) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -145,19 +145,19 @@ TEST(YogaTest, justify_content_row_center) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetJustifyContent(root, YGJustifyCenter); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -210,19 +210,19 @@ TEST(YogaTest, justify_content_row_space_between) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetJustifyContent(root, YGJustifySpaceBetween); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -275,19 +275,19 @@ TEST(YogaTest, justify_content_row_space_around) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetJustifyContent(root, YGJustifySpaceAround); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetWidth(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetWidth(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -338,18 +338,18 @@ TEST(YogaTest, justify_content_row_space_around) { TEST(YogaTest, justify_content_column_flex_start) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -401,19 +401,19 @@ TEST(YogaTest, justify_content_column_flex_start) { TEST(YogaTest, justify_content_column_flex_end) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -465,19 +465,19 @@ TEST(YogaTest, justify_content_column_flex_end) { TEST(YogaTest, justify_content_column_center) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifyCenter); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -529,19 +529,19 @@ TEST(YogaTest, justify_content_column_center) { TEST(YogaTest, justify_content_column_space_between) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifySpaceBetween); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -593,19 +593,19 @@ TEST(YogaTest, justify_content_column_space_between) { TEST(YogaTest, justify_content_column_space_around) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifySpaceAround); - YGNodeStyleSetWidthWithUnit(root, YGPx(102)); - YGNodeStyleSetHeightWithUnit(root, YGPx(102)); + YGNodeStyleSetWidth(root, YGPx(102)); + YGNodeStyleSetHeight(root, YGPx(102)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGLayoutDefaultValuesTest.cpp b/tests/YGLayoutDefaultValuesTest.cpp index 97d10b7a..67906ac4 100644 --- a/tests/YGLayoutDefaultValuesTest.cpp +++ b/tests/YGLayoutDefaultValuesTest.cpp @@ -27,28 +27,28 @@ TEST(YogaTest, assert_default_values) { ASSERT_EQ(YGOverflowVisible, YGNodeStyleGetOverflow(root)); ASSERT_FLOAT_EQ(0, YGNodeStyleGetFlexGrow(root)); ASSERT_FLOAT_EQ(0, YGNodeStyleGetFlexShrink(root)); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetFlexBasis(root))); + ASSERT_FALSE(YGNodeStyleGetFlexBasis(root).defined); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeLeft))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeTop))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeRight))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeBottom))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeStart))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPosition(root, YGEdgeEnd))); + ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeLeft).defined); + ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeTop).defined); + ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeRight).defined); + ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeBottom).defined); + ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeStart).defined); + ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeEnd).defined); - ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeLeft)); - ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeTop)); - ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeRight)); - ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeBottom)); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMargin(root, YGEdgeStart))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMargin(root, YGEdgeEnd))); + ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeLeft).value); + ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeTop).value); + ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeRight).value); + ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeBottom).value); + ASSERT_FALSE(YGNodeStyleGetMargin(root, YGEdgeStart).defined); + ASSERT_FALSE(YGNodeStyleGetMargin(root, YGEdgeEnd).defined); - ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeLeft)); - ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeTop)); - ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeRight)); - ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeBottom)); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPadding(root, YGEdgeStart))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetPadding(root, YGEdgeEnd))); + ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeLeft).value); + ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeTop).value); + ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeRight).value); + ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeBottom).value); + ASSERT_FALSE(YGNodeStyleGetPadding(root, YGEdgeStart).defined); + ASSERT_FALSE(YGNodeStyleGetPadding(root, YGEdgeEnd).defined); ASSERT_FLOAT_EQ(0, YGNodeStyleGetBorder(root, YGEdgeLeft)); ASSERT_FLOAT_EQ(0, YGNodeStyleGetBorder(root, YGEdgeTop)); @@ -57,12 +57,12 @@ TEST(YogaTest, assert_default_values) { ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetBorder(root, YGEdgeStart))); ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetBorder(root, YGEdgeEnd))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetWidth(root))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetHeight(root))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMinWidth(root))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMinHeight(root))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMaxWidth(root))); - ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetMaxHeight(root))); + ASSERT_FALSE(YGNodeStyleGetWidth(root).defined); + ASSERT_FALSE(YGNodeStyleGetHeight(root).defined); + ASSERT_FALSE(YGNodeStyleGetMinWidth(root).defined); + ASSERT_FALSE(YGNodeStyleGetMinHeight(root).defined); + ASSERT_FALSE(YGNodeStyleGetMaxWidth(root).defined); + ASSERT_FALSE(YGNodeStyleGetMaxHeight(root).defined); ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root)); ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root)); diff --git a/tests/YGMarginTest.cpp b/tests/YGMarginTest.cpp index fb293065..17de3e78 100644 --- a/tests/YGMarginTest.cpp +++ b/tests/YGMarginTest.cpp @@ -15,12 +15,12 @@ TEST(YogaTest, margin_start) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeStart, YGPx(10)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeStart, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -51,12 +51,12 @@ TEST(YogaTest, margin_start) { TEST(YogaTest, margin_top) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -89,12 +89,12 @@ TEST(YogaTest, margin_end) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeEnd, YGPx(10)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeEnd, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -126,12 +126,12 @@ TEST(YogaTest, margin_end) { TEST(YogaTest, margin_bottom) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeBottom, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -163,12 +163,12 @@ TEST(YogaTest, margin_bottom) { TEST(YogaTest, margin_and_flex_row) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeStart, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeStart, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -199,12 +199,12 @@ TEST(YogaTest, margin_and_flex_row) { TEST(YogaTest, margin_and_flex_column) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -236,12 +236,12 @@ TEST(YogaTest, margin_and_flex_column) { TEST(YogaTest, margin_and_stretch_row) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -272,12 +272,12 @@ TEST(YogaTest, margin_and_stretch_row) { TEST(YogaTest, margin_and_stretch_column) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeStart, YGPx(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeStart, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -309,8 +309,8 @@ TEST(YogaTest, margin_and_stretch_column) { TEST(YogaTest, margin_with_sibling_row) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); @@ -358,8 +358,8 @@ TEST(YogaTest, margin_with_sibling_row) { TEST(YogaTest, margin_with_sibling_column) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); diff --git a/tests/YGMinMaxDimensionTest.cpp b/tests/YGMinMaxDimensionTest.cpp index ee6eff52..739f1b7b 100644 --- a/tests/YGMinMaxDimensionTest.cpp +++ b/tests/YGMinMaxDimensionTest.cpp @@ -14,12 +14,12 @@ TEST(YogaTest, max_width) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetMaxWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -51,12 +51,12 @@ TEST(YogaTest, max_width) { TEST(YogaTest, max_height) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetMaxHeightWithUnit(root_child0, YGPx(50)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetMaxHeight(root_child0, YGPx(50)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -87,12 +87,12 @@ TEST(YogaTest, max_height) { TEST(YogaTest, min_height) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMinHeightWithUnit(root_child0, YGPx(60)); + YGNodeStyleSetMinHeight(root_child0, YGPx(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); @@ -138,12 +138,12 @@ TEST(YogaTest, min_height) { TEST(YogaTest, min_width) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMinWidthWithUnit(root_child0, YGPx(60)); + YGNodeStyleSetMinWidth(root_child0, YGPx(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); @@ -189,13 +189,13 @@ TEST(YogaTest, min_width) { TEST(YogaTest, justify_content_min_max) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifyCenter); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetMinHeightWithUnit(root, YGPx(100)); - YGNodeStyleSetMaxHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetMinHeight(root, YGPx(100)); + YGNodeStyleSetMaxHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(60)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(60)); + YGNodeStyleSetWidth(root_child0, YGPx(60)); + YGNodeStyleSetHeight(root_child0, YGPx(60)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -227,13 +227,13 @@ TEST(YogaTest, justify_content_min_max) { TEST(YogaTest, align_items_min_max) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetAlignItems(root, YGAlignCenter); - YGNodeStyleSetMinWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetMaxWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetMinWidth(root, YGPx(100)); + YGNodeStyleSetMaxWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(60)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(60)); + YGNodeStyleSetWidth(root_child0, YGPx(60)); + YGNodeStyleSetHeight(root_child0, YGPx(60)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -265,22 +265,22 @@ TEST(YogaTest, align_items_min_max) { TEST(YogaTest, justify_content_overflow_min_max) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifyCenter); - YGNodeStyleSetMinHeightWithUnit(root, YGPx(100)); - YGNodeStyleSetMaxHeightWithUnit(root, YGPx(110)); + YGNodeStyleSetMinHeight(root, YGPx(100)); + YGNodeStyleSetMaxHeight(root, YGPx(110)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(50)); + YGNodeStyleSetWidth(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(50)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child1, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(50)); + YGNodeStyleSetWidth(root_child1, YGPx(50)); + YGNodeStyleSetHeight(root_child1, YGPx(50)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child2, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(50)); + YGNodeStyleSetWidth(root_child2, YGPx(50)); + YGNodeStyleSetHeight(root_child2, YGPx(50)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -331,17 +331,17 @@ TEST(YogaTest, justify_content_overflow_min_max) { TEST(YogaTest, flex_grow_within_max_width) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexDirection(root_child0, YGFlexDirectionRow); - YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPx(100)); + YGNodeStyleSetMaxWidth(root_child0, YGPx(100)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child0_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0_child0, 1); - YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(20)); + YGNodeStyleSetHeight(root_child0_child0, YGPx(20)); YGNodeInsertChild(root_child0, root_child0_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -382,17 +382,17 @@ TEST(YogaTest, flex_grow_within_max_width) { TEST(YogaTest, flex_grow_within_constrained_max_width) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexDirection(root_child0, YGFlexDirectionRow); - YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPx(300)); + YGNodeStyleSetMaxWidth(root_child0, YGPx(300)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child0_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0_child0, 1); - YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(20)); + YGNodeStyleSetHeight(root_child0_child0, YGPx(20)); YGNodeInsertChild(root_child0, root_child0_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGPaddingTest.cpp b/tests/YGPaddingTest.cpp index 86b58175..9fe33ac0 100644 --- a/tests/YGPaddingTest.cpp +++ b/tests/YGPaddingTest.cpp @@ -14,10 +14,10 @@ TEST(YogaTest, padding_no_size) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10)); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root)); @@ -37,14 +37,14 @@ TEST(YogaTest, padding_no_size) { TEST(YogaTest, padding_container_match_child) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -75,16 +75,16 @@ TEST(YogaTest, padding_container_match_child) { TEST(YogaTest, padding_flex_child) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10)); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -115,15 +115,15 @@ TEST(YogaTest, padding_flex_child) { TEST(YogaTest, padding_stretch_child) { const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeLeft, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeTop, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeRight, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(10)); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetPadding(root, YGEdgeLeft, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeTop, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeRight, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(10)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -156,15 +156,15 @@ TEST(YogaTest, padding_center_child) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifyCenter); YGNodeStyleSetAlignItems(root, YGAlignCenter); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeStart, YGPx(10)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeEnd, YGPx(20)); - YGNodeStyleSetPaddingWithUnit(root, YGEdgeBottom, YGPx(20)); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetPadding(root, YGEdgeStart, YGPx(10)); + YGNodeStyleSetPadding(root, YGEdgeEnd, YGPx(20)); + YGNodeStyleSetPadding(root, YGEdgeBottom, YGPx(20)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -197,16 +197,16 @@ TEST(YogaTest, child_with_padding_align_end) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetJustifyContent(root, YGJustifyFlexEnd); YGNodeStyleSetAlignItems(root, YGAlignFlexEnd); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeLeft, YGPx(20)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeTop, YGPx(20)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeRight, YGPx(20)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeBottom, YGPx(20)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(100)); + YGNodeStyleSetPadding(root_child0, YGEdgeLeft, YGPx(20)); + YGNodeStyleSetPadding(root_child0, YGEdgeTop, YGPx(20)); + YGNodeStyleSetPadding(root_child0, YGEdgeRight, YGPx(20)); + YGNodeStyleSetPadding(root_child0, YGEdgeBottom, YGPx(20)); + YGNodeStyleSetWidth(root_child0, YGPx(100)); + YGNodeStyleSetHeight(root_child0, YGPx(100)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGPercentageTest.cpp b/tests/YGPercentageTest.cpp index a9ecdfaa..9d16db6f 100644 --- a/tests/YGPercentageTest.cpp +++ b/tests/YGPercentageTest.cpp @@ -17,12 +17,12 @@ TEST(YogaTest, percentage_width_height) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0, YGPercent(30)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPercent(30)); + YGNodeStyleSetWidth(root_child0, YGPercent(30)); + YGNodeStyleSetHeight(root_child0, YGPercent(30)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -58,14 +58,14 @@ TEST(YogaTest, percentage_position_left_top) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(400)); - YGNodeStyleSetHeightWithUnit(root, YGPx(400)); + YGNodeStyleSetWidth(root, YGPx(400)); + YGNodeStyleSetHeight(root, YGPx(400)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeLeft, YGPercent(10)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPercent(20)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPercent(45)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPercent(55)); + YGNodeStyleSetPosition(root_child0, YGEdgeLeft, YGPercent(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPercent(20)); + YGNodeStyleSetWidth(root_child0, YGPercent(45)); + YGNodeStyleSetHeight(root_child0, YGPercent(55)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -101,14 +101,14 @@ TEST(YogaTest, percentage_position_bottom_right) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(500)); - YGNodeStyleSetHeightWithUnit(root, YGPx(500)); + YGNodeStyleSetWidth(root, YGPx(500)); + YGNodeStyleSetHeight(root, YGPx(500)); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeRight, YGPercent(20)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeBottom, YGPercent(10)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPercent(55)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPercent(15)); + YGNodeStyleSetPosition(root_child0, YGEdgeRight, YGPercent(20)); + YGNodeStyleSetPosition(root_child0, YGEdgeBottom, YGPercent(10)); + YGNodeStyleSetWidth(root_child0, YGPercent(55)); + YGNodeStyleSetHeight(root_child0, YGPercent(15)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -144,17 +144,17 @@ TEST(YogaTest, percentage_flex_basis) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(50)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(50)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(25)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(25)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -199,17 +199,17 @@ TEST(YogaTest, percentage_flex_basis_cross) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(50)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(50)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(25)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(25)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -254,17 +254,17 @@ TEST(YogaTest, percentage_flex_basis_cross_min_height) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMinHeightWithUnit(root_child0, YGPercent(60)); + YGNodeStyleSetMinHeight(root_child0, YGPercent(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 2); - YGNodeStyleSetMinHeightWithUnit(root_child1, YGPercent(10)); + YGNodeStyleSetMinHeight(root_child1, YGPercent(10)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -310,19 +310,19 @@ TEST(YogaTest, percentage_flex_basis_main_max_height) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10)); - YGNodeStyleSetMaxHeightWithUnit(root_child0, YGPercent(60)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(10)); + YGNodeStyleSetMaxHeight(root_child0, YGPercent(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 4); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(10)); - YGNodeStyleSetMaxHeightWithUnit(root_child1, YGPercent(20)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(10)); + YGNodeStyleSetMaxHeight(root_child1, YGPercent(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -367,19 +367,19 @@ TEST(YogaTest, percentage_flex_basis_cross_max_height) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10)); - YGNodeStyleSetMaxHeightWithUnit(root_child0, YGPercent(60)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(10)); + YGNodeStyleSetMaxHeight(root_child0, YGPercent(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 4); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(10)); - YGNodeStyleSetMaxHeightWithUnit(root_child1, YGPercent(20)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(10)); + YGNodeStyleSetMaxHeight(root_child1, YGPercent(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -425,19 +425,19 @@ TEST(YogaTest, percentage_flex_basis_main_max_width) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(15)); - YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPercent(60)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(15)); + YGNodeStyleSetMaxWidth(root_child0, YGPercent(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 4); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(10)); - YGNodeStyleSetMaxWidthWithUnit(root_child1, YGPercent(20)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(10)); + YGNodeStyleSetMaxWidth(root_child1, YGPercent(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -482,19 +482,19 @@ TEST(YogaTest, percentage_flex_basis_cross_max_width) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10)); - YGNodeStyleSetMaxWidthWithUnit(root_child0, YGPercent(60)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(10)); + YGNodeStyleSetMaxWidth(root_child0, YGPercent(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 4); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(15)); - YGNodeStyleSetMaxWidthWithUnit(root_child1, YGPercent(20)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(15)); + YGNodeStyleSetMaxWidth(root_child1, YGPercent(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -540,19 +540,19 @@ TEST(YogaTest, percentage_flex_basis_main_min_width) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(15)); - YGNodeStyleSetMinWidthWithUnit(root_child0, YGPercent(60)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(15)); + YGNodeStyleSetMinWidth(root_child0, YGPercent(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 4); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(10)); - YGNodeStyleSetMinWidthWithUnit(root_child1, YGPercent(20)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(10)); + YGNodeStyleSetMinWidth(root_child1, YGPercent(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -597,19 +597,19 @@ TEST(YogaTest, percentage_flex_basis_cross_min_width) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10)); - YGNodeStyleSetMinWidthWithUnit(root_child0, YGPercent(60)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(10)); + YGNodeStyleSetMinWidth(root_child0, YGPercent(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 4); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(15)); - YGNodeStyleSetMinWidthWithUnit(root_child1, YGPercent(20)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(15)); + YGNodeStyleSetMinWidth(root_child1, YGPercent(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -654,51 +654,51 @@ TEST(YogaTest, percentage_multiple_nested_with_padding_margin_and_percentage_val YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(200)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(200)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPercent(10)); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeLeft, YGPx(5)); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPx(5)); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeRight, YGPx(5)); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeBottom, YGPx(5)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeLeft, YGPx(3)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeTop, YGPx(3)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeRight, YGPx(3)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeBottom, YGPx(3)); - YGNodeStyleSetMinWidthWithUnit(root_child0, YGPercent(60)); + YGNodeStyleSetFlexBasis(root_child0, YGPercent(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPx(5)); + YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPx(5)); + YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPx(5)); + YGNodeStyleSetMargin(root_child0, YGEdgeBottom, YGPx(5)); + YGNodeStyleSetPadding(root_child0, YGEdgeLeft, YGPx(3)); + YGNodeStyleSetPadding(root_child0, YGEdgeTop, YGPx(3)); + YGNodeStyleSetPadding(root_child0, YGEdgeRight, YGPx(3)); + YGNodeStyleSetPadding(root_child0, YGEdgeBottom, YGPx(3)); + YGNodeStyleSetMinWidth(root_child0, YGPercent(60)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child0_child0 = YGNodeNew(); - YGNodeStyleSetMarginWithUnit(root_child0_child0, YGEdgeLeft, YGPx(5)); - YGNodeStyleSetMarginWithUnit(root_child0_child0, YGEdgeTop, YGPx(5)); - YGNodeStyleSetMarginWithUnit(root_child0_child0, YGEdgeRight, YGPx(5)); - YGNodeStyleSetMarginWithUnit(root_child0_child0, YGEdgeBottom, YGPx(5)); - YGNodeStyleSetPaddingWithUnit(root_child0_child0, YGEdgeLeft, YGPercent(3)); - YGNodeStyleSetPaddingWithUnit(root_child0_child0, YGEdgeTop, YGPercent(3)); - YGNodeStyleSetPaddingWithUnit(root_child0_child0, YGEdgeRight, YGPercent(3)); - YGNodeStyleSetPaddingWithUnit(root_child0_child0, YGEdgeBottom, YGPercent(3)); - YGNodeStyleSetWidthWithUnit(root_child0_child0, YGPercent(50)); + YGNodeStyleSetMargin(root_child0_child0, YGEdgeLeft, YGPx(5)); + YGNodeStyleSetMargin(root_child0_child0, YGEdgeTop, YGPx(5)); + YGNodeStyleSetMargin(root_child0_child0, YGEdgeRight, YGPx(5)); + YGNodeStyleSetMargin(root_child0_child0, YGEdgeBottom, YGPx(5)); + YGNodeStyleSetPadding(root_child0_child0, YGEdgeLeft, YGPercent(3)); + YGNodeStyleSetPadding(root_child0_child0, YGEdgeTop, YGPercent(3)); + YGNodeStyleSetPadding(root_child0_child0, YGEdgeRight, YGPercent(3)); + YGNodeStyleSetPadding(root_child0_child0, YGEdgeBottom, YGPercent(3)); + YGNodeStyleSetWidth(root_child0_child0, YGPercent(50)); YGNodeInsertChild(root_child0, root_child0_child0, 0); const YGNodeRef root_child0_child0_child0 = YGNodeNew(); - YGNodeStyleSetMarginWithUnit(root_child0_child0_child0, YGEdgeLeft, YGPercent(5)); - YGNodeStyleSetMarginWithUnit(root_child0_child0_child0, YGEdgeTop, YGPercent(5)); - YGNodeStyleSetMarginWithUnit(root_child0_child0_child0, YGEdgeRight, YGPercent(5)); - YGNodeStyleSetMarginWithUnit(root_child0_child0_child0, YGEdgeBottom, YGPercent(5)); - YGNodeStyleSetPaddingWithUnit(root_child0_child0_child0, YGEdgeLeft, YGPx(3)); - YGNodeStyleSetPaddingWithUnit(root_child0_child0_child0, YGEdgeTop, YGPx(3)); - YGNodeStyleSetPaddingWithUnit(root_child0_child0_child0, YGEdgeRight, YGPx(3)); - YGNodeStyleSetPaddingWithUnit(root_child0_child0_child0, YGEdgeBottom, YGPx(3)); - YGNodeStyleSetWidthWithUnit(root_child0_child0_child0, YGPercent(45)); + YGNodeStyleSetMargin(root_child0_child0_child0, YGEdgeLeft, YGPercent(5)); + YGNodeStyleSetMargin(root_child0_child0_child0, YGEdgeTop, YGPercent(5)); + YGNodeStyleSetMargin(root_child0_child0_child0, YGEdgeRight, YGPercent(5)); + YGNodeStyleSetMargin(root_child0_child0_child0, YGEdgeBottom, YGPercent(5)); + YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeLeft, YGPx(3)); + YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeTop, YGPx(3)); + YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeRight, YGPx(3)); + YGNodeStyleSetPadding(root_child0_child0_child0, YGEdgeBottom, YGPx(3)); + YGNodeStyleSetWidth(root_child0_child0_child0, YGPercent(45)); YGNodeInsertChild(root_child0_child0, root_child0_child0_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 4); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPercent(15)); - YGNodeStyleSetMinWidthWithUnit(root_child1, YGPercent(20)); + YGNodeStyleSetFlexBasis(root_child1, YGPercent(15)); + YGNodeStyleSetMinWidth(root_child1, YGPercent(20)); YGNodeInsertChild(root, root_child1, 1); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -763,20 +763,20 @@ TEST(YogaTest, percentage_margin_should_calculate_based_only_on_width) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeLeft, YGPercent(10)); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeTop, YGPercent(10)); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeRight, YGPercent(10)); - YGNodeStyleSetMarginWithUnit(root_child0, YGEdgeBottom, YGPercent(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeLeft, YGPercent(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeTop, YGPercent(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeRight, YGPercent(10)); + YGNodeStyleSetMargin(root_child0, YGEdgeBottom, YGPercent(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child0_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0_child0, YGPx(10)); YGNodeInsertChild(root_child0, root_child0_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -821,20 +821,20 @@ TEST(YogaTest, percentage_padding_should_calculate_based_only_on_width) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeLeft, YGPercent(10)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeTop, YGPercent(10)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeRight, YGPercent(10)); - YGNodeStyleSetPaddingWithUnit(root_child0, YGEdgeBottom, YGPercent(10)); + YGNodeStyleSetPadding(root_child0, YGEdgeLeft, YGPercent(10)); + YGNodeStyleSetPadding(root_child0, YGEdgeTop, YGPercent(10)); + YGNodeStyleSetPadding(root_child0, YGEdgeRight, YGPercent(10)); + YGNodeStyleSetPadding(root_child0, YGEdgeBottom, YGPercent(10)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child0_child0 = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root_child0_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(10)); + YGNodeStyleSetWidth(root_child0_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0_child0, YGPx(10)); YGNodeInsertChild(root_child0, root_child0_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -879,15 +879,15 @@ TEST(YogaTest, percentage_absolute_position) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(200)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(200)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeLeft, YGPercent(30)); - YGNodeStyleSetPositionWithUnit(root_child0, YGEdgeTop, YGPercent(10)); - YGNodeStyleSetWidthWithUnit(root_child0, YGPx(10)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(10)); + YGNodeStyleSetPosition(root_child0, YGEdgeLeft, YGPercent(30)); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, YGPercent(10)); + YGNodeStyleSetWidth(root_child0, YGPx(10)); + YGNodeStyleSetHeight(root_child0, YGPx(10)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/tests/YGRelayoutTest.cpp b/tests/YGRelayoutTest.cpp index de298325..b637d17c 100644 --- a/tests/YGRelayoutTest.cpp +++ b/tests/YGRelayoutTest.cpp @@ -16,8 +16,8 @@ TEST(YogaTest, dont_cache_computed_flex_basis_between_layouts) { const YGNodeRef root = YGNodeNew(); const YGNodeRef root_child0 = YGNodeNew(); - YGNodeStyleSetHeight(root_child0, 10); - YGNodeStyleSetFlexBasis(root_child0, 20); + YGNodeStyleSetHeight(root_child0, YGPx(10)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, 100, YGUndefined, YGDirectionLTR); diff --git a/tests/YGRoundingTest.cpp b/tests/YGRoundingTest.cpp index fe2a39be..aaad141c 100644 --- a/tests/YGRoundingTest.cpp +++ b/tests/YGRoundingTest.cpp @@ -17,8 +17,8 @@ TEST(YogaTest, rounding_flex_basis_flex_grow_row_width_of_100) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); @@ -85,8 +85,8 @@ TEST(YogaTest, rounding_flex_basis_flex_grow_row_prime_number_width) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(113)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(113)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); @@ -181,20 +181,20 @@ TEST(YogaTest, rounding_flex_basis_flex_shrink_row) { const YGNodeRef root = YGNodeNew(); YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); - YGNodeStyleSetWidthWithUnit(root, YGPx(101)); - YGNodeStyleSetHeightWithUnit(root, YGPx(100)); + YGNodeStyleSetWidth(root, YGPx(101)); + YGNodeStyleSetHeight(root, YGPx(100)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexShrink(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(100)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(100)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); - YGNodeStyleSetFlexBasisWithUnit(root_child1, YGPx(25)); + YGNodeStyleSetFlexBasis(root_child1, YGPx(25)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); - YGNodeStyleSetFlexBasisWithUnit(root_child2, YGPx(25)); + YGNodeStyleSetFlexBasis(root_child2, YGPx(25)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -249,23 +249,23 @@ TEST(YogaTest, rounding_flex_basis_overrides_main_size) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(113)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(113)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child2, 1); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -320,23 +320,23 @@ TEST(YogaTest, rounding_total_fractial) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(87.4f)); - YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f)); + YGNodeStyleSetWidth(root, YGPx(87.4f)); + YGNodeStyleSetHeight(root, YGPx(113.4f)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 0.7f); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50.3f)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20.3f)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50.3f)); + YGNodeStyleSetHeight(root_child0, YGPx(20.3f)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1.6f); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child2, 1.1f); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10.7f)); + YGNodeStyleSetHeight(root_child2, YGPx(10.7f)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -391,37 +391,37 @@ TEST(YogaTest, rounding_total_fractial_nested) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(87.4f)); - YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f)); + YGNodeStyleSetWidth(root, YGPx(87.4f)); + YGNodeStyleSetHeight(root, YGPx(113.4f)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 0.7f); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50.3f)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20.3f)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50.3f)); + YGNodeStyleSetHeight(root_child0, YGPx(20.3f)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child0_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0_child0, YGPx(0.3f)); - YGNodeStyleSetPositionWithUnit(root_child0_child0, YGEdgeBottom, YGPx(13.3f)); - YGNodeStyleSetHeightWithUnit(root_child0_child0, YGPx(9.9f)); + YGNodeStyleSetFlexBasis(root_child0_child0, YGPx(0.3f)); + YGNodeStyleSetPosition(root_child0_child0, YGEdgeBottom, YGPx(13.3f)); + YGNodeStyleSetHeight(root_child0_child0, YGPx(9.9f)); YGNodeInsertChild(root_child0, root_child0_child0, 0); const YGNodeRef root_child0_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0_child1, 4); - YGNodeStyleSetFlexBasisWithUnit(root_child0_child1, YGPx(0.3f)); - YGNodeStyleSetPositionWithUnit(root_child0_child1, YGEdgeTop, YGPx(13.3f)); - YGNodeStyleSetHeightWithUnit(root_child0_child1, YGPx(1.1f)); + YGNodeStyleSetFlexBasis(root_child0_child1, YGPx(0.3f)); + YGNodeStyleSetPosition(root_child0_child1, YGEdgeTop, YGPx(13.3f)); + YGNodeStyleSetHeight(root_child0_child1, YGPx(1.1f)); YGNodeInsertChild(root_child0, root_child0_child1, 1); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1.6f); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child2, 1.1f); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10.7f)); + YGNodeStyleSetHeight(root_child2, YGPx(10.7f)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -496,23 +496,23 @@ TEST(YogaTest, rounding_fractial_input_1) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(113.4f)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child2, 1); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -567,23 +567,23 @@ TEST(YogaTest, rounding_fractial_input_2) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(113.6f)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(113.6f)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child2, 1); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -638,24 +638,24 @@ TEST(YogaTest, rounding_fractial_input_3) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetPositionWithUnit(root, YGEdgeTop, YGPx(0.3f)); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f)); + YGNodeStyleSetPosition(root, YGEdgeTop, YGPx(0.3f)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(113.4f)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child2, 1); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -710,24 +710,24 @@ TEST(YogaTest, rounding_fractial_input_4) { YGSetExperimentalFeatureEnabled(YGExperimentalFeatureRounding, true); const YGNodeRef root = YGNodeNew(); - YGNodeStyleSetPositionWithUnit(root, YGEdgeTop, YGPx(0.7f)); - YGNodeStyleSetWidthWithUnit(root, YGPx(100)); - YGNodeStyleSetHeightWithUnit(root, YGPx(113.4f)); + YGNodeStyleSetPosition(root, YGEdgeTop, YGPx(0.7f)); + YGNodeStyleSetWidth(root, YGPx(100)); + YGNodeStyleSetHeight(root, YGPx(113.4f)); const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child0, 1); - YGNodeStyleSetFlexBasisWithUnit(root_child0, YGPx(50)); - YGNodeStyleSetHeightWithUnit(root_child0, YGPx(20)); + YGNodeStyleSetFlexBasis(root_child0, YGPx(50)); + YGNodeStyleSetHeight(root_child0, YGPx(20)); YGNodeInsertChild(root, root_child0, 0); const YGNodeRef root_child1 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child1, 1); - YGNodeStyleSetHeightWithUnit(root_child1, YGPx(10)); + YGNodeStyleSetHeight(root_child1, YGPx(10)); YGNodeInsertChild(root, root_child1, 1); const YGNodeRef root_child2 = YGNodeNew(); YGNodeStyleSetFlexGrow(root_child2, 1); - YGNodeStyleSetHeightWithUnit(root_child2, YGPx(10)); + YGNodeStyleSetHeight(root_child2, YGPx(10)); YGNodeInsertChild(root, root_child2, 2); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/yoga/Yoga.c b/yoga/Yoga.c index 6bdd6423..c4bed869 100644 --- a/yoga/Yoga.c +++ b/yoga/Yoga.c @@ -113,6 +113,12 @@ YGCalloc gYGCalloc = &calloc; YGRealloc gYGRealloc = &realloc; YGFree gYGFree = &free; +static YGValue YGValueUndefined = { + .value = YGUndefined, + .defined = false, + .unit = YGUnitPixel +}; + #ifdef ANDROID #include static int YGAndroidLog(YGLogLevel level, const char *format, va_list args) { @@ -161,39 +167,35 @@ static inline YGValue YGComputedEdgeValue(const YGValue edges[YGEdgeCount], const float defaultValue) { YG_ASSERT(edge <= YGEdgeEnd, "Cannot get computed value of multi-edge shorthands"); - if (!YGValueIsUndefined(edges[edge])) { + if (edges[edge].defined) { return edges[edge]; } - if ((edge == YGEdgeTop || edge == YGEdgeBottom) && !YGValueIsUndefined(edges[YGEdgeVertical])) { + if ((edge == YGEdgeTop || edge == YGEdgeBottom) && edges[YGEdgeVertical].defined) { return edges[YGEdgeVertical]; } if ((edge == YGEdgeLeft || edge == YGEdgeRight || edge == YGEdgeStart || edge == YGEdgeEnd) && - !YGValueIsUndefined(edges[YGEdgeHorizontal])) { + edges[YGEdgeHorizontal].defined) { return edges[YGEdgeHorizontal]; } - if (!YGValueIsUndefined(edges[YGEdgeAll])) { + if (edges[YGEdgeAll].defined) { return edges[YGEdgeAll]; } if (edge == YGEdgeStart || edge == YGEdgeEnd) { - YGValue result; - result.value = YGUndefined; - result.defined = false; - result.unit = YGUnitPixel; - return result; + return YGValueUndefined; } - YGValue result; - result.value = defaultValue; - result.defined = (defaultValue < 0 || defaultValue >= 0); /* is faster than a nan function call and enough at this point */ - result.unit = YGUnitPixel; - return result; + YGValue result; + result.value = defaultValue; + result.defined = (defaultValue < 0 || defaultValue >= 0); /* is faster than a nan function call and enough at this point */ + result.unit = YGUnitPixel; + return result; } -static inline float YGValueToFloat(const YGValue unit, const float parentSize) { +static inline float YGValueResolve(const YGValue unit, const float parentSize) { if (unit.unit == YGUnitPixel){ return unit.value; } else { @@ -223,40 +225,20 @@ static void YGNodeInit(const YGNodeRef node) { node->style.overflow = YGOverflowVisible; // Some of the fields default to undefined and not 0 - node->style.dimensions[YGDimensionWidth].value = YGUndefined; - node->style.dimensions[YGDimensionWidth].defined = false; - node->style.dimensions[YGDimensionWidth].unit = YGUnitPixel; - node->style.dimensions[YGDimensionHeight].value = YGUndefined; - node->style.dimensions[YGDimensionHeight].defined = false; - node->style.dimensions[YGDimensionHeight].unit = YGUnitPixel; + node->style.dimensions[YGDimensionWidth] = YGValueUndefined; + node->style.dimensions[YGDimensionHeight] = YGValueUndefined; - node->style.minDimensions[YGDimensionWidth].value = YGUndefined; - node->style.minDimensions[YGDimensionWidth].defined = false; - node->style.minDimensions[YGDimensionWidth].unit = YGUnitPixel; - node->style.minDimensions[YGDimensionHeight].value = YGUndefined; - node->style.minDimensions[YGDimensionHeight].defined = false; - node->style.minDimensions[YGDimensionHeight].unit = YGUnitPixel; + node->style.minDimensions[YGDimensionWidth] = YGValueUndefined; + node->style.minDimensions[YGDimensionHeight] = YGValueUndefined; - node->style.maxDimensions[YGDimensionWidth].value = YGUndefined; - node->style.maxDimensions[YGDimensionWidth].defined = false; - node->style.maxDimensions[YGDimensionWidth].unit = YGUnitPixel; - node->style.maxDimensions[YGDimensionHeight].value = YGUndefined; - node->style.maxDimensions[YGDimensionHeight].defined = false; - node->style.maxDimensions[YGDimensionHeight].unit = YGUnitPixel; + node->style.maxDimensions[YGDimensionWidth] = YGValueUndefined; + node->style.maxDimensions[YGDimensionHeight] = YGValueUndefined; for (YGEdge edge = YGEdgeLeft; edge < YGEdgeCount; edge++) { - node->style.position[edge].value = YGUndefined; - node->style.position[edge].defined = false; - node->style.position[edge].unit = YGUnitPixel; - node->style.margin[edge].value = YGUndefined; - node->style.margin[edge].defined = false; - node->style.margin[edge].unit = YGUnitPixel; - node->style.padding[edge].value = YGUndefined; - node->style.padding[edge].defined = false; - node->style.padding[edge].unit = YGUnitPixel; - node->style.border[edge].value = YGUndefined; - node->style.border[edge].defined = false; - node->style.border[edge].unit = YGUnitPixel; + node->style.position[edge] = YGValueUndefined; + node->style.margin[edge] = YGValueUndefined; + node->style.padding[edge] = YGValueUndefined; + node->style.border[edge] = YGValueUndefined; } node->style.aspectRatio = YGUndefined; @@ -280,19 +262,19 @@ static void YGNodeInit(const YGNodeRef node) { int32_t gNodeInstanceCount = 0; YGValue YGPx(const float value){ - YGValue result; - result.value = value; - result.defined = !YGFloatIsUndefined(value); - result.unit = YGUnitPixel; - return result; + YGValue result; + result.value = value; + result.defined = !YGFloatIsUndefined(value); + result.unit = YGUnitPixel; + return result; } YGValue YGPercent(const float value){ - YGValue result; - result.value = value; - result.defined = !YGFloatIsUndefined(value); - result.unit = YGUnitPercent; - return result; + YGValue result; + result.value = value; + result.defined = !YGFloatIsUndefined(value); + result.unit = YGUnitPercent; + return result; } YGNodeRef YGNodeNew(void) { @@ -429,18 +411,8 @@ inline float YGNodeStyleGetFlexShrink(const YGNodeRef node) { return 0; } -inline float YGNodeStyleGetFlexBasis(const YGNodeRef node) { - if (!YGValueIsUndefined(node->style.flexBasis)) { - return node->style.flexBasis.value; - } - if (!YGFloatIsUndefined(node->style.flex)) { - return node->style.flex > 0 ? 0 : YGUndefined; - } - return YGUndefined; -} - -inline YGValue YGNodeStyleGetFlexBasisWithUnit(const YGNodeRef node) { - if (!YGValueIsUndefined(node->style.flexBasis)) { +inline YGValue YGNodeStyleGetFlexBasis(const YGNodeRef node) { + if (node->style.flexBasis.defined) { return node->style.flexBasis; } if (!YGFloatIsUndefined(node->style.flex)) { @@ -474,21 +446,13 @@ void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) { } #define YG_NODE_STYLE_PROPERTY_SETTER_UNIT_IMPL(type, name, paramName, instanceName) \ - void YGNodeStyleSet##name##WithUnit(const YGNodeRef node, const type paramName) { \ + void YGNodeStyleSet##name##(const YGNodeRef node, const type paramName) { \ if (node->style.instanceName.value != paramName.value || node->style.instanceName.unit != paramName.unit) { \ node->style.instanceName.value = paramName.value; \ node->style.instanceName.defined = !YGFloatIsUndefined(paramName.value); \ node->style.instanceName.unit = paramName.unit; \ YGNodeMarkDirtyInternal(node); \ - } \ - } \ - void YGNodeStyleSet##name(const YGNodeRef node, const float paramName) { \ - if (node->style.instanceName.value != paramName || node->style.instanceName.unit != YGUnitPixel) { \ - node->style.instanceName.value = paramName; \ - node->style.instanceName.defined = !YGFloatIsUndefined(paramName); \ - node->style.instanceName.unit = YGUnitPixel; \ - YGNodeMarkDirtyInternal(node); \ - } \ + } \ } #define YG_NODE_STYLE_PROPERTY_IMPL(type, name, paramName, instanceName) \ @@ -501,39 +465,24 @@ void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) { #define YG_NODE_STYLE_PROPERTY_UNIT_IMPL(type, name, paramName, instanceName) \ YG_NODE_STYLE_PROPERTY_SETTER_UNIT_IMPL(type, name, paramName, instanceName) \ \ - float YGNodeStyleGet##name(const YGNodeRef node) { \ - return node->style.instanceName.value; \ - } \ - type YGNodeStyleGet##name##WithUnit(const YGNodeRef node) { \ + type YGNodeStyleGet##name##(const YGNodeRef node) { \ return node->style.instanceName; \ } #define YG_NODE_STYLE_EDGE_PROPERTY_UNIT_IMPL(type, name, paramName, instanceName, defaultValue) \ - void YGNodeStyleSet##name##WithUnit(const YGNodeRef node, const YGEdge edge, const type paramName) { \ + void YGNodeStyleSet##name##(const YGNodeRef node, const YGEdge edge, const type paramName) { \ if (node->style.instanceName[edge].value != paramName.value || node->style.instanceName[edge].unit != paramName.unit ) { \ node->style.instanceName[edge].value = paramName.value; \ node->style.instanceName[edge].defined = !YGFloatIsUndefined(paramName.value); \ node->style.instanceName[edge].unit = paramName.unit; \ YGNodeMarkDirtyInternal(node); \ - } \ + } \ } \ - \ - void YGNodeStyleSet##name(const YGNodeRef node, const YGEdge edge, const float paramName) { \ - if (node->style.instanceName[edge].value != paramName || node->style.instanceName[edge].unit != YGUnitPixel ) { \ - node->style.instanceName[edge].value = paramName; \ - node->style.instanceName[edge].defined = !YGFloatIsUndefined(paramName); \ - node->style.instanceName[edge].unit = YGUnitPixel; \ - YGNodeMarkDirtyInternal(node); \ - } \ - } \ \ - type YGNodeStyleGet##name##WithUnit(const YGNodeRef node, const YGEdge edge) { \ + type YGNodeStyleGet##name##(const YGNodeRef node, const YGEdge edge) { \ return YGComputedEdgeValue(node->style.instanceName, edge, defaultValue); \ } \ - \ - float YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge) { \ - return YGComputedEdgeValue(node->style.instanceName, edge, defaultValue).value; \ - } + #define YG_NODE_STYLE_EDGE_PROPERTY_IMPL(type, name, paramName, instanceName, defaultValue) \ void YGNodeStyleSet##name(const YGNodeRef node, const YGEdge edge, const float paramName) { \ @@ -612,17 +561,13 @@ inline bool YGFloatIsUndefined(const float value) { return isnan(value); } -inline bool YGValueIsUndefined(const YGValue value) { - return !value.defined; -} - static inline bool YGValueEqual(const YGValue a, const YGValue b) { if (a.unit != b.unit){ return false; } - if (YGValueIsUndefined(a)) { - return YGValueIsUndefined(b); + if (!a.defined) { + return !b.defined; } return fabs(a.value - b.value) < 0.0001; } @@ -653,7 +598,7 @@ static void YGPrintNumberIfNotUndefinedf(const char *str, const float number) { } static void YGPrintNumberIfNotUndefined(const char *str, const YGValue number) { - if (!YGValueIsUndefined(number)) { + if (number.defined) { YGLog(YGLogLevelDebug, "%s: %g%s, ", str, number, number.unit == YGUnitPixel ? "px" : "%"); } } @@ -731,7 +676,7 @@ static void YGNodePrintInternal(const YGNodeRef node, YGPrintNumberIfNotUndefinedf("flexGrow", YGNodeStyleGetFlexGrow(node)); YGPrintNumberIfNotUndefinedf("flexShrink", YGNodeStyleGetFlexShrink(node)); - YGPrintNumberIfNotUndefined("flexBasis", YGNodeStyleGetFlexBasisWithUnit(node)); + YGPrintNumberIfNotUndefined("flexBasis", YGNodeStyleGetFlexBasis(node)); if (node->style.overflow == YGOverflowHidden) { YGLog(YGLogLevelDebug, "overflow: 'hidden', "); @@ -859,41 +804,41 @@ static inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) } static inline float YGNodeLeadingMargin(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) { - if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.margin[YGEdgeStart])) { - return YGValueToFloat(node->style.margin[YGEdgeStart], widthSize); + if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeStart].defined) { + return YGValueResolve(node->style.margin[YGEdgeStart], widthSize); } - return YGValueToFloat(YGComputedEdgeValue(node->style.margin, leading[axis], 0), widthSize); + return YGValueResolve(YGComputedEdgeValue(node->style.margin, leading[axis], 0), widthSize); } static float YGNodeTrailingMargin(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) { - if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.margin[YGEdgeEnd])) { - return YGValueToFloat(node->style.margin[YGEdgeEnd], widthSize); + if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeEnd].defined) { + return YGValueResolve(node->style.margin[YGEdgeEnd], widthSize); } - return YGValueToFloat(YGComputedEdgeValue(node->style.margin, trailing[axis], 0), widthSize); + return YGValueResolve(YGComputedEdgeValue(node->style.margin, trailing[axis], 0), widthSize); } static float YGNodeLeadingPadding(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) { - if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.padding[YGEdgeStart]) && - YGValueToFloat(node->style.padding[YGEdgeStart], widthSize) >= 0) { - return YGValueToFloat(node->style.padding[YGEdgeStart], widthSize); + if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeStart].defined && + YGValueResolve(node->style.padding[YGEdgeStart], widthSize) >= 0) { + return YGValueResolve(node->style.padding[YGEdgeStart], widthSize); } - return fmaxf(YGValueToFloat(YGComputedEdgeValue(node->style.padding, leading[axis], 0), widthSize), 0); + return fmaxf(YGValueResolve(YGComputedEdgeValue(node->style.padding, leading[axis], 0), widthSize), 0); } static float YGNodeTrailingPadding(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) { - if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.padding[YGEdgeEnd]) && - YGValueToFloat(node->style.padding[YGEdgeEnd], widthSize) >= 0) { - return YGValueToFloat(node->style.padding[YGEdgeEnd], widthSize); + if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeEnd].defined && + YGValueResolve(node->style.padding[YGEdgeEnd], widthSize) >= 0) { + return YGValueResolve(node->style.padding[YGEdgeEnd], widthSize); } - return fmaxf(YGValueToFloat(YGComputedEdgeValue(node->style.padding, trailing[axis], 0), widthSize), 0); + return fmaxf(YGValueResolve(YGComputedEdgeValue(node->style.padding, trailing[axis], 0), widthSize), 0); } static float YGNodeLeadingBorder(const YGNodeRef node, const YGFlexDirection axis) { - if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.border[YGEdgeStart]) && + if (YGFlexDirectionIsRow(axis) && node->style.border[YGEdgeStart].defined && node->style.border[YGEdgeStart].value >= 0) { return node->style.border[YGEdgeStart].value; } @@ -902,7 +847,7 @@ static float YGNodeLeadingBorder(const YGNodeRef node, const YGFlexDirection axi } static float YGNodeTrailingBorder(const YGNodeRef node, const YGFlexDirection axis) { - if (YGFlexDirectionIsRow(axis) && !YGValueIsUndefined(node->style.border[YGEdgeEnd]) && + if (YGFlexDirectionIsRow(axis) && node->style.border[YGEdgeEnd].defined && node->style.border[YGEdgeEnd].value >= 0) { return node->style.border[YGEdgeEnd].value; } @@ -974,7 +919,7 @@ static inline float YGNodeDimWithMargin(const YGNodeRef node, const YGFlexDirect static inline bool YGNodeIsStyleDimDefined(const YGNodeRef node, const YGFlexDirection axis) { const YGValue value = node->style.dimensions[dim[axis]]; - return !YGValueIsUndefined(value) && value.value >= 0.0; + return value.defined && value.value >= 0.0; } static inline bool YGNodeIsLayoutDimDefined(const YGNodeRef node, const YGFlexDirection axis) { @@ -984,46 +929,44 @@ static inline bool YGNodeIsLayoutDimDefined(const YGNodeRef node, const YGFlexDi static inline bool YGNodeIsLeadingPosDefined(const YGNodeRef node, const YGFlexDirection axis) { return (YGFlexDirectionIsRow(axis) && - !YGValueIsUndefined( - YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined))) || - !YGValueIsUndefined(YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined)); + YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined).defined) || + YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined).defined; } static inline bool YGNodeIsTrailingPosDefined(const YGNodeRef node, const YGFlexDirection axis) { return (YGFlexDirectionIsRow(axis) && - !YGValueIsUndefined(YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined))) || - !YGValueIsUndefined( - YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined)); + YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined).defined) || + YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined).defined; } static float YGNodeLeadingPosition(const YGNodeRef node, const YGFlexDirection axis, const float axisSize) { if (YGFlexDirectionIsRow(axis)) { const YGValue leadingPosition = YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined); - if (!YGValueIsUndefined(leadingPosition)) { - return YGValueToFloat(leadingPosition, axisSize); + if (leadingPosition.defined) { + return YGValueResolve(leadingPosition, axisSize); } } const YGValue leadingPosition = YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined); - return YGValueIsUndefined(leadingPosition) ? 0 : YGValueToFloat(leadingPosition, axisSize); + return !leadingPosition.defined ? 0 : YGValueResolve(leadingPosition, axisSize); } static float YGNodeTrailingPosition(const YGNodeRef node, const YGFlexDirection axis, const float axisSize) { if (YGFlexDirectionIsRow(axis)) { const YGValue trailingPosition = YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined); - if (!YGValueIsUndefined(trailingPosition)) { - return YGValueToFloat(trailingPosition, axisSize); + if (trailingPosition.defined) { + return YGValueResolve(trailingPosition, axisSize); } } const YGValue trailingPosition = YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined); - return YGValueIsUndefined(trailingPosition) ? 0 : YGValueToFloat(trailingPosition, axisSize); + return !trailingPosition.defined ? 0 : YGValueResolve(trailingPosition, axisSize); } static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node, @@ -1033,11 +976,11 @@ static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node, float max = YGUndefined; if (YGFlexDirectionIsColumn(axis)) { - min = YGValueToFloat(node->style.minDimensions[YGDimensionHeight], axisSize); - max = YGValueToFloat(node->style.maxDimensions[YGDimensionHeight], axisSize); + min = YGValueResolve(node->style.minDimensions[YGDimensionHeight], axisSize); + max = YGValueResolve(node->style.maxDimensions[YGDimensionHeight], axisSize); } else if (YGFlexDirectionIsRow(axis)) { - min = YGValueToFloat(node->style.minDimensions[YGDimensionWidth], axisSize); - max = YGValueToFloat(node->style.maxDimensions[YGDimensionWidth], axisSize); + min = YGValueResolve(node->style.minDimensions[YGDimensionWidth], axisSize); + max = YGValueResolve(node->style.maxDimensions[YGDimensionWidth], axisSize); } float boundValue = value; @@ -1133,23 +1076,23 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node, const bool isRowStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionRow); const bool isColumnStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn); - if (!YGValueIsUndefined(YGNodeStyleGetFlexBasisWithUnit(child)) && + if (YGNodeStyleGetFlexBasis(child).defined && !YGFloatIsUndefined(mainAxisSize)) { if (YGFloatIsUndefined(child->layout.computedFlexBasis) || (YGIsExperimentalFeatureEnabled(YGExperimentalFeatureWebFlexBasis) && child->layout.computedFlexBasisGeneration != gCurrentGenerationCount)) { child->layout.computedFlexBasis = - fmaxf(YGValueToFloat(YGNodeStyleGetFlexBasisWithUnit(child), mainAxisParentSize), YGNodePaddingAndBorderForAxis(child, mainAxis, parentWidth)); + fmaxf(YGValueResolve(YGNodeStyleGetFlexBasis(child), mainAxisParentSize), YGNodePaddingAndBorderForAxis(child, mainAxis, parentWidth)); } } else if (isMainAxisRow && isRowStyleDimDefined) { // The width is definite, so use that as the flex basis. child->layout.computedFlexBasis = - fmaxf(YGValueToFloat(child->style.dimensions[YGDimensionWidth], parentWidth), + fmaxf(YGValueResolve(child->style.dimensions[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(YGValueToFloat(child->style.dimensions[YGDimensionHeight], parentHeight), + fmaxf(YGValueResolve(child->style.dimensions[YGDimensionHeight], parentHeight), YGNodePaddingAndBorderForAxis(child, YGFlexDirectionColumn, parentWidth)); } else { // Compute the flex basis and hypothetical main size (i.e. the clamped @@ -1160,12 +1103,12 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node, childHeightMeasureMode = YGMeasureModeUndefined; if (isRowStyleDimDefined) { - childWidth = YGValueToFloat(child->style.dimensions[YGDimensionWidth], parentWidth) + + childWidth = YGValueResolve(child->style.dimensions[YGDimensionWidth], parentWidth) + YGNodeMarginForAxis(child, YGFlexDirectionRow, parentWidth); childWidthMeasureMode = YGMeasureModeExactly; } if (isColumnStyleDimDefined) { - childHeight = YGValueToFloat(child->style.dimensions[YGDimensionHeight], parentHeight) + + childHeight = YGValueResolve(child->style.dimensions[YGDimensionHeight], parentHeight) + YGNodeMarginForAxis(child, YGFlexDirectionColumn, parentWidth); childHeightMeasureMode = YGMeasureModeExactly; } @@ -1216,10 +1159,10 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node, } } - YGConstrainMaxSizeForMode(YGValueToFloat(child->style.maxDimensions[YGDimensionWidth], parentWidth), + YGConstrainMaxSizeForMode(YGValueResolve(child->style.maxDimensions[YGDimensionWidth], parentWidth), &childWidthMeasureMode, &childWidth); - YGConstrainMaxSizeForMode(YGValueToFloat(child->style.maxDimensions[YGDimensionHeight], parentHeight), + YGConstrainMaxSizeForMode(YGValueResolve(child->style.maxDimensions[YGDimensionHeight], parentHeight), &childHeightMeasureMode, &childHeight); @@ -1260,7 +1203,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node, YGMeasureMode childHeightMeasureMode = YGMeasureModeUndefined; if (YGNodeIsStyleDimDefined(child, YGFlexDirectionRow)) { - childWidth = YGValueToFloat(child->style.dimensions[YGDimensionWidth], width) + + childWidth = YGValueResolve(child->style.dimensions[YGDimensionWidth], width) + YGNodeMarginForAxis(child, YGFlexDirectionRow, width); } else { // If the child doesn't have a specified width, compute the width based @@ -1278,7 +1221,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node, } if (YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn)) { - childHeight = YGValueToFloat(child->style.dimensions[YGDimensionHeight], height) + + childHeight = YGValueResolve(child->style.dimensions[YGDimensionHeight], height) + YGNodeMarginForAxis(child, YGFlexDirectionColumn, width); } else { // If the child doesn't have a specified height, compute the height @@ -1289,8 +1232,8 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node, childHeight = node->layout.measuredDimensions[YGDimensionHeight] - (YGNodeLeadingBorder(node, YGFlexDirectionColumn) + YGNodeTrailingBorder(node, YGFlexDirectionColumn)) - - (YGNodeLeadingPosition(child, YGFlexDirectionColumn, width) + - YGNodeTrailingPosition(child, YGFlexDirectionColumn, width)); + (YGNodeLeadingPosition(child, YGFlexDirectionColumn, height) + + YGNodeTrailingPosition(child, YGFlexDirectionColumn, height)); childHeight = YGNodeBoundAxis(child, YGFlexDirectionColumn, childHeight, height, width); } } @@ -1982,7 +1925,7 @@ static void YGNodelayoutImpl(const YGNodeRef node, childHeightMeasureMode = YGFloatIsUndefined(childHeight) ? YGMeasureModeUndefined : YGMeasureModeAtMost; } else { - childHeight = YGValueToFloat(currentRelativeChild->style.dimensions[YGDimensionHeight], availableInnerHeight) + + childHeight = YGValueResolve(currentRelativeChild->style.dimensions[YGDimensionHeight], availableInnerHeight) + YGNodeMarginForAxis(currentRelativeChild, YGFlexDirectionColumn, availableInnerWidth); childHeightMeasureMode = YGMeasureModeExactly; } @@ -2002,7 +1945,7 @@ static void YGNodelayoutImpl(const YGNodeRef node, childWidthMeasureMode = YGFloatIsUndefined(childWidth) ? YGMeasureModeUndefined : YGMeasureModeAtMost; } else { - childWidth = YGValueToFloat(currentRelativeChild->style.dimensions[YGDimensionWidth], availableInnerWidth) + + childWidth = YGValueResolve(currentRelativeChild->style.dimensions[YGDimensionWidth], availableInnerWidth) + YGNodeMarginForAxis(currentRelativeChild, YGFlexDirectionRow, availableInnerWidth); childWidthMeasureMode = YGMeasureModeExactly; } @@ -2022,10 +1965,10 @@ static void YGNodelayoutImpl(const YGNodeRef node, } } - YGConstrainMaxSizeForMode(YGValueToFloat(currentRelativeChild->style.maxDimensions[YGDimensionWidth], availableInnerWidth), + YGConstrainMaxSizeForMode(YGValueResolve(currentRelativeChild->style.maxDimensions[YGDimensionWidth], availableInnerWidth), &childWidthMeasureMode, &childWidth); - YGConstrainMaxSizeForMode(YGValueToFloat(currentRelativeChild->style.maxDimensions[YGDimensionHeight], availableInnerHeight), + YGConstrainMaxSizeForMode(YGValueResolve(currentRelativeChild->style.maxDimensions[YGDimensionHeight], availableInnerHeight), &childHeightMeasureMode, &childHeight); @@ -2065,10 +2008,10 @@ static void YGNodelayoutImpl(const YGNodeRef node, // constraint by the min size defined for the main axis. if (measureModeMainDim == YGMeasureModeAtMost && remainingFreeSpace > 0) { - if (!YGValueIsUndefined(node->style.minDimensions[dim[mainAxis]]) && - YGValueToFloat(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) { + if (node->style.minDimensions[dim[mainAxis]].defined && + YGValueResolve(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) { remainingFreeSpace = fmaxf(0, - YGValueToFloat(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) - + YGValueResolve(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) - (availableInnerMainDim - remainingFreeSpace)); } else { remainingFreeSpace = 0; @@ -2222,10 +2165,10 @@ static void YGNodelayoutImpl(const YGNodeRef node, YGNodeMarginForAxis(child, YGFlexDirectionColumn, availableInnerWidth); } - YGConstrainMaxSizeForMode(YGValueToFloat(child->style.maxDimensions[YGDimensionWidth], availableInnerWidth), + YGConstrainMaxSizeForMode(YGValueResolve(child->style.maxDimensions[YGDimensionWidth], availableInnerWidth), &childWidthMeasureMode, &childWidth); - YGConstrainMaxSizeForMode(YGValueToFloat(child->style.maxDimensions[YGDimensionHeight], availableInnerHeight), + YGConstrainMaxSizeForMode(YGValueResolve(child->style.maxDimensions[YGDimensionHeight], availableInnerHeight), &childHeightMeasureMode, &childHeight); @@ -2763,22 +2706,22 @@ void YGNodeCalculateLayout(const YGNodeRef node, if (!YGFloatIsUndefined(width)) { widthMeasureMode = YGMeasureModeExactly; } else if (YGNodeIsStyleDimDefined(node, YGFlexDirectionRow)) { - width = YGValueToFloat(node->style.dimensions[dim[YGFlexDirectionRow]], availableWidth) + + width = YGValueResolve(node->style.dimensions[dim[YGFlexDirectionRow]], availableWidth) + YGNodeMarginForAxis(node, YGFlexDirectionRow, availableWidth); widthMeasureMode = YGMeasureModeExactly; - } else if (YGValueToFloat(node->style.maxDimensions[YGDimensionWidth], availableWidth) >= 0.0) { - width = YGValueToFloat(node->style.maxDimensions[YGDimensionWidth], availableWidth); + } else if (YGValueResolve(node->style.maxDimensions[YGDimensionWidth], availableWidth) >= 0.0) { + width = YGValueResolve(node->style.maxDimensions[YGDimensionWidth], availableWidth); widthMeasureMode = YGMeasureModeAtMost; } if (!YGFloatIsUndefined(height)) { heightMeasureMode = YGMeasureModeExactly; } else if (YGNodeIsStyleDimDefined(node, YGFlexDirectionColumn)) { - height = YGValueToFloat(node->style.dimensions[dim[YGFlexDirectionColumn]], availableHeight) + + height = YGValueResolve(node->style.dimensions[dim[YGFlexDirectionColumn]], availableHeight) + YGNodeMarginForAxis(node, YGFlexDirectionColumn, availableWidth); heightMeasureMode = YGMeasureModeExactly; - } else if (YGValueToFloat(node->style.maxDimensions[YGDimensionHeight], availableHeight) >= 0.0) { - height = YGValueToFloat(node->style.maxDimensions[YGDimensionHeight], availableHeight); + } else if (YGValueResolve(node->style.maxDimensions[YGDimensionHeight], availableHeight) >= 0.0) { + height = YGValueResolve(node->style.maxDimensions[YGDimensionHeight], availableHeight); heightMeasureMode = YGMeasureModeAtMost; } diff --git a/yoga/Yoga.h b/yoga/Yoga.h index c30d14a7..358d217f 100644 --- a/yoga/Yoga.h +++ b/yoga/Yoga.h @@ -38,11 +38,10 @@ typedef struct YGSize { float height; } YGSize; -typedef struct YGValue{ +typedef struct YGValue { float value; YGUnit unit; bool defined; - } YGValue; WIN_EXPORT YGValue YGPx(const float value); @@ -93,7 +92,6 @@ WIN_EXPORT bool YGNodeIsDirty(const YGNodeRef node); WIN_EXPORT void YGNodePrint(const YGNodeRef node, const YGPrintOptions options); WIN_EXPORT bool YGFloatIsUndefined(const float value); -WIN_EXPORT bool YGValueIsUndefined(const YGValue value); WIN_EXPORT bool YGNodeCanUseCachedMeasurement(const YGMeasureMode widthMode, const float width, @@ -119,9 +117,8 @@ WIN_EXPORT void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node); #define YG_NODE_STYLE_PROPERTY_UNIT(type, name, paramName) \ - YG_NODE_STYLE_PROPERTY(float, name, paramName); \ - WIN_EXPORT void YGNodeStyleSet##name##WithUnit(const YGNodeRef node, const type paramName); \ - WIN_EXPORT type YGNodeStyleGet##name##WithUnit(const YGNodeRef node); + WIN_EXPORT void YGNodeStyleSet##name##(const YGNodeRef node, const type paramName); \ + WIN_EXPORT type YGNodeStyleGet##name##(const YGNodeRef node); #define YG_NODE_STYLE_EDGE_PROPERTY(type, name, paramName) \ WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node, \ @@ -130,11 +127,10 @@ WIN_EXPORT void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge); #define YG_NODE_STYLE_EDGE_PROPERTY_UNIT(type, name, paramName) \ - YG_NODE_STYLE_EDGE_PROPERTY(float, name, paramName) \ - WIN_EXPORT void YGNodeStyleSet##name##WithUnit(const YGNodeRef node, \ + WIN_EXPORT void YGNodeStyleSet##name##(const YGNodeRef node, \ const YGEdge edge, \ const type paramName); \ - WIN_EXPORT type YGNodeStyleGet##name##WithUnit(const YGNodeRef node, const YGEdge edge); + WIN_EXPORT type YGNodeStyleGet##name##(const YGNodeRef node, const YGEdge edge); #define YG_NODE_LAYOUT_PROPERTY(type, name) \ WIN_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node);