From 3d10ba5f72f11e421a50653218b663dd538d7123 Mon Sep 17 00:00:00 2001 From: Emil Sjolander Date: Thu, 22 Dec 2016 02:57:12 -0800 Subject: [PATCH 01/13] Correctly check if child is flex by also accounting for undefined Summary: We were incorrectly returning true for children which had no flex as the flex was nan and not 0. Differential Revision: D4346712 fbshipit-source-id: 69ef0bb3fe5b4fcd3b3e2fe5aa348529be40252a --- yoga/Yoga.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/yoga/Yoga.c b/yoga/Yoga.c index e207a9b8..4762cee4 100644 --- a/yoga/Yoga.c +++ b/yoga/Yoga.c @@ -825,7 +825,7 @@ static YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection, static inline bool YGNodeIsFlex(const YGNodeRef node) { return (node->style.positionType == YGPositionTypeRelative && - (node->style.flexGrow != 0 || node->style.flexShrink != 0 || node->style.flex != 0)); + (YGNodeStyleGetFlexGrow(node) != 0 || YGNodeStyleGetFlexShrink(node) != 0)); } static inline float YGNodeDimWithMargin(const YGNodeRef node, const YGFlexDirection axis) { From 071f576db99775e51d384e99373a86610f712a28 Mon Sep 17 00:00:00 2001 From: Emil Sjolander Date: Thu, 22 Dec 2016 02:57:15 -0800 Subject: [PATCH 02/13] BREAKING - Change aspect ratio to always be width/height Summary: @public Aspect ratio being defined as width/height or height/width depending on the situation it was used in turned out to be very confusing. This diff makes aspect ratio always be defined as width/height irregardless of the usage. Differential Revision: D4339132 fbshipit-source-id: e5da32750b55ddaf6acaf1cbd7662d86f2b480c3 --- tests/YGAspectRatioTest.cpp | 4 ++-- yoga/Yoga.c | 6 +++--- yoga/Yoga.h | 3 +++ 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/tests/YGAspectRatioTest.cpp b/tests/YGAspectRatioTest.cpp index 22846c9b..8b28abdb 100644 --- a/tests/YGAspectRatioTest.cpp +++ b/tests/YGAspectRatioTest.cpp @@ -351,7 +351,7 @@ TEST(YogaTest, aspect_ratio_double_main) { const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetWidth(root_child0, 50); - YGNodeStyleSetAspectRatio(root_child0, 2); + YGNodeStyleSetAspectRatio(root_child0, 0.5); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); @@ -372,7 +372,7 @@ TEST(YogaTest, aspect_ratio_half_main) { const YGNodeRef root_child0 = YGNodeNew(); YGNodeStyleSetWidth(root_child0, 100); - YGNodeStyleSetAspectRatio(root_child0, 0.5); + YGNodeStyleSetAspectRatio(root_child0, 2); YGNodeInsertChild(root, root_child0, 0); YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); diff --git a/yoga/Yoga.c b/yoga/Yoga.c index 4762cee4..8b1c5fda 100644 --- a/yoga/Yoga.c +++ b/yoga/Yoga.c @@ -1062,7 +1062,7 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node, if (!YGValueIsUndefined(child->style.aspectRatio)) { if (!isMainAxisRow && childWidthMeasureMode == YGMeasureModeExactly) { child->layout.computedFlexBasis = - fmaxf(childWidth * child->style.aspectRatio, + fmaxf(childWidth / child->style.aspectRatio, YGNodePaddingAndBorderForAxis(child, YGFlexDirectionColumn)); return; } else if (isMainAxisRow && childHeightMeasureMode == YGMeasureModeExactly) { @@ -1157,7 +1157,7 @@ static void YGNodeAbsoluteLayoutChild(const YGNodeRef node, childWidth = fmaxf(childHeight * child->style.aspectRatio, YGNodePaddingAndBorderForAxis(child, YGFlexDirectionColumn)); } else if (YGValueIsUndefined(childHeight)) { - childHeight = fmaxf(childWidth * child->style.aspectRatio, + childHeight = fmaxf(childWidth / child->style.aspectRatio, YGNodePaddingAndBorderForAxis(child, YGFlexDirectionRow)); } } @@ -1880,7 +1880,7 @@ static void YGNodelayoutImpl(const YGNodeRef node, if (!YGValueIsUndefined(currentRelativeChild->style.aspectRatio)) { if (isMainAxisRow && childHeightMeasureMode != YGMeasureModeExactly) { childHeight = - fmaxf(childWidth * currentRelativeChild->style.aspectRatio, + fmaxf(childWidth / currentRelativeChild->style.aspectRatio, YGNodePaddingAndBorderForAxis(currentRelativeChild, YGFlexDirectionColumn)); childHeightMeasureMode = YGMeasureModeExactly; } else if (!isMainAxisRow && childWidthMeasureMode != YGMeasureModeExactly) { diff --git a/yoga/Yoga.h b/yoga/Yoga.h index 3bb96727..5e10b503 100644 --- a/yoga/Yoga.h +++ b/yoga/Yoga.h @@ -151,6 +151,9 @@ YG_NODE_STYLE_PROPERTY(float, MaxHeight, maxHeight); // Yoga specific properties, not compatible with flexbox specification // Aspect ratio control the size of the undefined dimension of a node. +// Aspect ratio is encoded as a floating point value width/height. e.g. A value of 2 leads to a node +// with a width twice the size of its height while a value of 0.5 gives the opposite effect. +// // - On a node with a set width/height aspect ratio control the size of the unset dimension // - On a node with a set flex basis aspect ratio controls the size of the node in the cross axis if // unset From 1b5eb7da5e451b549bba75238a132e05c726facd Mon Sep 17 00:00:00 2001 From: Emil Sjolander Date: Thu, 22 Dec 2016 02:57:16 -0800 Subject: [PATCH 03/13] BREAKING - Increase priority of AspectRatio to override flex, align stretch, and fixed sizes if specified. Summary: @public AspectRatio is a new addition and soon after introduction we noticed use cases which is did not support. Specifically we wanted to support a node being as large as possible within a container while maintaining an arbitrary aspect ratio. This was not possible due to the low priority of AspectRatio, by increasing the priority of AspectRatio this is now possible as FlexGrow will grow an item to fit its parent unless the AspectRatio makes it too big in the cross axis, the AspectRatio will now override the FlexGrow in the main axis in that case. Differential Revision: D4346720 fbshipit-source-id: 1f15613604190e3ad5ff4a467ba57db4bcfd2741 --- tests/YGAspectRatioTest.cpp | 273 +++++++++++++++++++++++++++++++++++- yoga/Yoga.c | 24 +++- 2 files changed, 292 insertions(+), 5 deletions(-) diff --git a/tests/YGAspectRatioTest.cpp b/tests/YGAspectRatioTest.cpp index 8b28abdb..b6e32de2 100644 --- a/tests/YGAspectRatioTest.cpp +++ b/tests/YGAspectRatioTest.cpp @@ -63,12 +63,15 @@ TEST(YogaTest, aspect_ratio_main_defined) { YGNodeFreeRecursive(root); } -TEST(YogaTest, aspect_ratio_both_dimensions_defined) { +TEST(YogaTest, aspect_ratio_both_dimensions_defined_row) { const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); + YGNodeStyleSetAlignItems(root, YGAlignFlexStart); YGNodeStyleSetWidth(root, 100); YGNodeStyleSetHeight(root, 100); const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetWidth(root_child0, 100); YGNodeStyleSetHeight(root_child0, 50); YGNodeStyleSetAspectRatio(root_child0, 1); YGNodeInsertChild(root, root_child0, 0); @@ -78,6 +81,28 @@ TEST(YogaTest, aspect_ratio_both_dimensions_defined) { ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); ASSERT_EQ(100, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(100, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_both_dimensions_defined_column) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetAlignItems(root, YGAlignFlexStart); + YGNodeStyleSetWidth(root, 100); + YGNodeStyleSetHeight(root, 100); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetWidth(root_child0, 100); + YGNodeStyleSetHeight(root_child0, 50); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(50, YGNodeLayoutGetWidth(root_child0)); ASSERT_EQ(50, YGNodeLayoutGetHeight(root_child0)); YGNodeFreeRecursive(root); @@ -405,3 +430,249 @@ TEST(YogaTest, aspect_ratio_with_measure_func) { YGNodeFreeRecursive(root); } + +TEST(YogaTest, aspect_ratio_width_height_flex_grow_row) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); + YGNodeStyleSetAlignItems(root, YGAlignFlexStart); + YGNodeStyleSetWidth(root, 100); + YGNodeStyleSetHeight(root, 200); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetWidth(root_child0, 50); + YGNodeStyleSetHeight(root_child0, 50); + YGNodeStyleSetFlexGrow(root_child0, 1); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(100, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(100, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_width_height_flex_grow_column) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetAlignItems(root, YGAlignFlexStart); + YGNodeStyleSetWidth(root, 200); + YGNodeStyleSetHeight(root, 100); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetWidth(root_child0, 50); + YGNodeStyleSetHeight(root_child0, 50); + YGNodeStyleSetFlexGrow(root_child0, 1); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(100, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(100, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_height_as_flex_basis) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetAlignItems(root, YGAlignFlexStart); + YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); + YGNodeStyleSetWidth(root, 200); + YGNodeStyleSetHeight(root, 200); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetHeight(root_child0, 50); + YGNodeStyleSetFlexGrow(root_child0, 1); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + const YGNodeRef root_child1 = YGNodeNew(); + YGNodeStyleSetHeight(root_child1, 100); + YGNodeStyleSetFlexGrow(root_child1, 1); + YGNodeStyleSetAspectRatio(root_child1, 1); + YGNodeInsertChild(root, root_child1, 1); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(75, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(75, YGNodeLayoutGetHeight(root_child0)); + + ASSERT_EQ(75, YGNodeLayoutGetLeft(root_child1)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child1)); + ASSERT_EQ(125, YGNodeLayoutGetWidth(root_child1)); + ASSERT_EQ(125, YGNodeLayoutGetHeight(root_child1)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_width_as_flex_basis) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetAlignItems(root, YGAlignFlexStart); + YGNodeStyleSetWidth(root, 200); + YGNodeStyleSetHeight(root, 200); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetWidth(root_child0, 50); + YGNodeStyleSetFlexGrow(root_child0, 1); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + const YGNodeRef root_child1 = YGNodeNew(); + YGNodeStyleSetWidth(root_child1, 100); + YGNodeStyleSetFlexGrow(root_child1, 1); + YGNodeStyleSetAspectRatio(root_child1, 1); + YGNodeInsertChild(root, root_child1, 1); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(75, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(75, YGNodeLayoutGetHeight(root_child0)); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child1)); + ASSERT_EQ(75, YGNodeLayoutGetTop(root_child1)); + ASSERT_EQ(125, YGNodeLayoutGetWidth(root_child1)); + ASSERT_EQ(125, YGNodeLayoutGetHeight(root_child1)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_overrides_flex_grow_row) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetAlignItems(root, YGAlignFlexStart); + YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); + YGNodeStyleSetWidth(root, 100); + YGNodeStyleSetHeight(root, 100); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetWidth(root_child0, 50); + YGNodeStyleSetFlexGrow(root_child0, 1); + YGNodeStyleSetAspectRatio(root_child0, 0.5); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(50, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(100, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_overrides_flex_grow_column) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetAlignItems(root, YGAlignFlexStart); + YGNodeStyleSetWidth(root, 100); + YGNodeStyleSetHeight(root, 100); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetHeight(root_child0, 50); + YGNodeStyleSetFlexGrow(root_child0, 1); + YGNodeStyleSetAspectRatio(root_child0, 2); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(100, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(50, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_left_right_absolute) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetWidth(root, 100); + YGNodeStyleSetHeight(root, 100); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); + YGNodeStyleSetPosition(root_child0, YGEdgeLeft, 10); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, 10); + YGNodeStyleSetPosition(root_child0, YGEdgeRight, 10); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(10, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(10, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(80, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(80, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_top_bottom_absolute) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetWidth(root, 100); + YGNodeStyleSetHeight(root, 100); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute); + YGNodeStyleSetPosition(root_child0, YGEdgeLeft, 10); + YGNodeStyleSetPosition(root_child0, YGEdgeTop, 10); + YGNodeStyleSetPosition(root_child0, YGEdgeBottom, 10); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(10, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(10, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(80, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(80, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_width_overrides_align_stretch_row) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow); + YGNodeStyleSetWidth(root, 100); + YGNodeStyleSetHeight(root, 100); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetWidth(root_child0, 50); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(50, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(50, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} + +TEST(YogaTest, aspect_ratio_height_overrides_align_stretch_column) { + const YGNodeRef root = YGNodeNew(); + YGNodeStyleSetWidth(root, 100); + YGNodeStyleSetHeight(root, 100); + + const YGNodeRef root_child0 = YGNodeNew(); + YGNodeStyleSetHeight(root_child0, 50); + YGNodeStyleSetAspectRatio(root_child0, 1); + YGNodeInsertChild(root, root_child0, 0); + + YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR); + + ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0)); + ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0)); + ASSERT_EQ(50, YGNodeLayoutGetWidth(root_child0)); + ASSERT_EQ(50, YGNodeLayoutGetHeight(root_child0)); + + YGNodeFreeRecursive(root); +} diff --git a/yoga/Yoga.c b/yoga/Yoga.c index 8b1c5fda..21f7290e 100644 --- a/yoga/Yoga.c +++ b/yoga/Yoga.c @@ -1878,16 +1878,22 @@ static void YGNodelayoutImpl(const YGNodeRef node, } if (!YGValueIsUndefined(currentRelativeChild->style.aspectRatio)) { - if (isMainAxisRow && childHeightMeasureMode != YGMeasureModeExactly) { + if (isMainAxisRow) { childHeight = fmaxf(childWidth / currentRelativeChild->style.aspectRatio, YGNodePaddingAndBorderForAxis(currentRelativeChild, YGFlexDirectionColumn)); childHeightMeasureMode = YGMeasureModeExactly; - } else if (!isMainAxisRow && childWidthMeasureMode != YGMeasureModeExactly) { + + childHeight = fminf(childHeight, availableInnerHeight); + childWidth = childHeight * currentRelativeChild->style.aspectRatio; + } else { childWidth = fmaxf(childHeight * currentRelativeChild->style.aspectRatio, YGNodePaddingAndBorderForAxis(currentRelativeChild, YGFlexDirectionRow)); childWidthMeasureMode = YGMeasureModeExactly; + + childWidth = fminf(childWidth, availableInnerWidth); + childHeight = childWidth / currentRelativeChild->style.aspectRatio; } } @@ -2080,13 +2086,23 @@ static void YGNodelayoutImpl(const YGNodeRef node, YGMeasureMode childHeightMeasureMode = YGMeasureModeExactly; if (isMainAxisRow) { - childHeight = crossDim; childWidth = child->layout.measuredDimensions[YGDimensionWidth] + YGNodeMarginForAxis(child, YGFlexDirectionRow); + + if (!YGValueIsUndefined(child->style.aspectRatio)) { + childHeight = childWidth / child->style.aspectRatio; + } else { + childHeight = crossDim; + } } else { - childWidth = crossDim; childHeight = child->layout.measuredDimensions[YGDimensionHeight] + YGNodeMarginForAxis(child, YGFlexDirectionColumn); + + if (!YGValueIsUndefined(child->style.aspectRatio)) { + childWidth = childHeight * child->style.aspectRatio; + } else { + childWidth = crossDim; + } } YGConstrainMaxSizeForMode(child->style.maxDimensions[YGDimensionWidth], From ed765fe5085cf6e5c9bfb279f0accf1075f65f4d Mon Sep 17 00:00:00 2001 From: Emil Sjolander Date: Thu, 22 Dec 2016 02:57:18 -0800 Subject: [PATCH 04/13] Convert max cache count into a define Summary: This should not be an enum. A define makes a whole lot more sense Differential Revision: D4346529 fbshipit-source-id: 8641c4c5017d915d64e5884cae09ac8f01861337 --- yoga/Yoga.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/yoga/Yoga.c b/yoga/Yoga.c index 21f7290e..5dd21af1 100644 --- a/yoga/Yoga.c +++ b/yoga/Yoga.c @@ -42,7 +42,7 @@ typedef struct YGCachedMeasurement { // This value was chosen based on empiracle data. Even the most complicated // layouts should not require more than 16 entries to fit within the cache. -enum { YG_MAX_CACHED_RESULT_COUNT = 16 }; +#define YG_MAX_CACHED_RESULT_COUNT 16 typedef struct YGLayout { float position[4]; From ff1a0e1eb8db37a707d2319ea79394bad133e55f Mon Sep 17 00:00:00 2001 From: David Hart Date: Thu, 22 Dec 2016 02:57:19 -0800 Subject: [PATCH 05/13] Transform the Count enum values into private constants Summary: Hides implementation details for the C, Objective-C and Swift APIs. Closes https://github.com/facebook/yoga/pull/292 Differential Revision: D4351523 Pulled By: emilsjolander fbshipit-source-id: 18a1149d169f0d52bd078714295000b5d07434dd --- enums.py | 6 +++--- yoga/YGEnums.h | 26 +++++++++++++------------- yoga/Yoga.c | 7 ------- 3 files changed, 16 insertions(+), 23 deletions(-) diff --git a/enums.py b/enums.py index d2fc6dc0..756c7c43 100644 --- a/enums.py +++ b/enums.py @@ -111,22 +111,22 @@ def to_java_upper(symbol): return out -root = os.path.dirname(__file__) +root = os.path.dirname(os.path.abspath(__file__)) -# write out C header +# write out C headers with open(root + '/yoga/YGEnums.h', 'w') as f: f.write(LICENSE) f.write('#pragma once\n\n') f.write('#include "YGMacros.h"\n\n') f.write('YG_EXTERN_C_BEGIN\n\n') for name, values in ENUMS.items(): + f.write('#define YG%sCount %s\n' % (name, len(values))) f.write('typedef enum YG%s {\n' % name) for value in values: if isinstance(value, tuple): f.write(' YG%s%s = %d,\n' % (name, value[0], value[1])) else: f.write(' YG%s%s,\n' % (name, value)) - f.write(' YG%sCount,\n' % name) f.write('} YG%s;\n' % name) f.write('\n') f.write('YG_EXTERN_C_END\n') diff --git a/yoga/YGEnums.h b/yoga/YGEnums.h index 85d9d2f9..a64c1673 100644 --- a/yoga/YGEnums.h +++ b/yoga/YGEnums.h @@ -13,28 +13,29 @@ YG_EXTERN_C_BEGIN +#define YGFlexDirectionCount 4 typedef enum YGFlexDirection { YGFlexDirectionColumn, YGFlexDirectionColumnReverse, YGFlexDirectionRow, YGFlexDirectionRowReverse, - YGFlexDirectionCount, } YGFlexDirection; +#define YGMeasureModeCount 3 typedef enum YGMeasureMode { YGMeasureModeUndefined, YGMeasureModeExactly, YGMeasureModeAtMost, - YGMeasureModeCount, } YGMeasureMode; +#define YGPrintOptionsCount 3 typedef enum YGPrintOptions { YGPrintOptionsLayout = 1, YGPrintOptionsStyle = 2, YGPrintOptionsChildren = 4, - YGPrintOptionsCount, } YGPrintOptions; +#define YGEdgeCount 9 typedef enum YGEdge { YGEdgeLeft, YGEdgeTop, @@ -45,72 +46,71 @@ typedef enum YGEdge { YGEdgeHorizontal, YGEdgeVertical, YGEdgeAll, - YGEdgeCount, } YGEdge; +#define YGPositionTypeCount 2 typedef enum YGPositionType { YGPositionTypeRelative, YGPositionTypeAbsolute, - YGPositionTypeCount, } YGPositionType; +#define YGDimensionCount 2 typedef enum YGDimension { YGDimensionWidth, YGDimensionHeight, - YGDimensionCount, } YGDimension; +#define YGJustifyCount 5 typedef enum YGJustify { YGJustifyFlexStart, YGJustifyCenter, YGJustifyFlexEnd, YGJustifySpaceBetween, YGJustifySpaceAround, - YGJustifyCount, } YGJustify; +#define YGDirectionCount 3 typedef enum YGDirection { YGDirectionInherit, YGDirectionLTR, YGDirectionRTL, - YGDirectionCount, } YGDirection; +#define YGLogLevelCount 5 typedef enum YGLogLevel { YGLogLevelError, YGLogLevelWarn, YGLogLevelInfo, YGLogLevelDebug, YGLogLevelVerbose, - YGLogLevelCount, } YGLogLevel; +#define YGWrapCount 2 typedef enum YGWrap { YGWrapNoWrap, YGWrapWrap, - YGWrapCount, } YGWrap; +#define YGOverflowCount 3 typedef enum YGOverflow { YGOverflowVisible, YGOverflowHidden, YGOverflowScroll, - YGOverflowCount, } YGOverflow; +#define YGExperimentalFeatureCount 2 typedef enum YGExperimentalFeature { YGExperimentalFeatureRounding, YGExperimentalFeatureWebFlexBasis, - YGExperimentalFeatureCount, } YGExperimentalFeature; +#define YGAlignCount 5 typedef enum YGAlign { YGAlignAuto, YGAlignFlexStart, YGAlignCenter, YGAlignFlexEnd, YGAlignStretch, - YGAlignCount, } YGAlign; YG_EXTERN_C_END diff --git a/yoga/Yoga.c b/yoga/Yoga.c index 5dd21af1..a73f8ad5 100644 --- a/yoga/Yoga.c +++ b/yoga/Yoga.c @@ -133,8 +133,6 @@ static int YGAndroidLog(YGLogLevel level, const char *format, va_list args) { case YGLogLevelVerbose: androidLevel = ANDROID_LOG_VERBOSE; break; - case YGLogLevelCount: - break; } const int result = __android_log_vprint(androidLevel, "YG-layout", format, args); return result; @@ -951,8 +949,6 @@ static void YGConstrainMaxSizeForMode(const float maxSize, YGMeasureMode *mode, *size = maxSize; } break; - case YGMeasureModeCount: - break; } } @@ -1968,7 +1964,6 @@ static void YGNodelayoutImpl(const YGNodeRef node, leadingMainDim = betweenMainDim / 2; break; case YGJustifyFlexStart: - case YGJustifyCount: break; } @@ -2171,7 +2166,6 @@ static void YGNodelayoutImpl(const YGNodeRef node, break; case YGAlignAuto: case YGAlignFlexStart: - case YGAlignCount: break; } @@ -2231,7 +2225,6 @@ static void YGNodelayoutImpl(const YGNodeRef node, break; } case YGAlignAuto: - case YGAlignCount: break; } } From 0df58d8aa2ccd458aef52b50b7453c14e486a73e Mon Sep 17 00:00:00 2001 From: Emil Sjolander Date: Thu, 22 Dec 2016 02:57:21 -0800 Subject: [PATCH 06/13] Declaratively initialize default values of nodes Summary: Improve performance of allocations and reseting by writing fewer bits. Also just looks nicer imho. Reviewed By: passy Differential Revision: D4356994 fbshipit-source-id: ebbe52163e0c86230bfa4131b657941afe16fbf1 --- tests/YGMemoryFuncTest.cpp | 2 +- yoga/Yoga.c | 122 +++++++++++++++++++------------------ 2 files changed, 64 insertions(+), 60 deletions(-) diff --git a/tests/YGMemoryFuncTest.cpp b/tests/YGMemoryFuncTest.cpp index bef2985c..b6481373 100644 --- a/tests/YGMemoryFuncTest.cpp +++ b/tests/YGMemoryFuncTest.cpp @@ -56,7 +56,7 @@ TEST(YogaTest, memory_func_test_funcs) { } YGNodeFreeRecursive(root); ASSERT_NE(testMallocCount, 0); - ASSERT_NE(testCallocCount, 0); + ASSERT_EQ(testCallocCount, 0); ASSERT_NE(testReallocCount, 0); ASSERT_NE(testFreeCount, 0); YGSetMemoryFuncs(NULL, NULL, NULL, NULL); diff --git a/yoga/Yoga.c b/yoga/Yoga.c index a73f8ad5..9723d894 100644 --- a/yoga/Yoga.c +++ b/yoga/Yoga.c @@ -106,6 +106,66 @@ typedef struct YGNode { void *context; } YGNode; +#define YG_DEFAULT_EDGE_VALUES { \ + [YGEdgeLeft] = YGUndefined, \ + [YGEdgeTop] = YGUndefined, \ + [YGEdgeRight] = YGUndefined, \ + [YGEdgeBottom] = YGUndefined, \ + [YGEdgeStart] = YGUndefined, \ + [YGEdgeEnd] = YGUndefined, \ + [YGEdgeHorizontal] = YGUndefined, \ + [YGEdgeVertical] = YGUndefined, \ + [YGEdgeAll] = YGUndefined, \ +} + +#define YG_DEFAULT_DIMENSION_VALUES { \ + [YGDimensionWidth] = YGUndefined, \ + [YGDimensionHeight] = YGUndefined, \ +} + +YGNode gYGNodeDefaults = { + .parent = NULL, + .children = NULL, + .hasNewLayout = true, + .isDirty = false, + + .style = { + .flex = YGUndefined, + .flexGrow = YGUndefined, + .flexShrink = YGUndefined, + .flexBasis = YGUndefined, + .justifyContent = YGJustifyFlexStart, + .alignItems = YGAlignStretch, + .alignContent = YGAlignFlexStart, + .direction = YGDirectionInherit, + .flexDirection = YGFlexDirectionColumn, + .overflow = YGOverflowVisible, + .dimensions = YG_DEFAULT_DIMENSION_VALUES, + .minDimensions = YG_DEFAULT_DIMENSION_VALUES, + .maxDimensions = YG_DEFAULT_DIMENSION_VALUES, + .position = YG_DEFAULT_EDGE_VALUES, + .margin = YG_DEFAULT_EDGE_VALUES, + .padding = YG_DEFAULT_EDGE_VALUES, + .border = YG_DEFAULT_EDGE_VALUES, + .aspectRatio = YGUndefined, + }, + + .layout = { + .dimensions = YG_DEFAULT_DIMENSION_VALUES, + .lastParentDirection = (YGDirection) -1, + .nextCachedMeasurementsIndex = 0, + .computedFlexBasis = YGUndefined, + .measuredDimensions = YG_DEFAULT_DIMENSION_VALUES, + + .cachedLayout = { + .widthMeasureMode = (YGMeasureMode) -1, + .heightMeasureMode = (YGMeasureMode) -1, + .computedWidth = -1, + .computedHeight = -1, + }, + }, +}; + static void YGNodeMarkDirtyInternal(const YGNodeRef node); YGMalloc gYGMalloc = &malloc; @@ -183,69 +243,14 @@ static inline float YGComputedEdgeValue(const float edges[YGEdgeCount], return defaultValue; } -static void YGNodeInit(const YGNodeRef node) { - node->parent = NULL; - node->children = NULL; - node->hasNewLayout = true; - node->isDirty = false; - - node->style.flex = YGUndefined; - node->style.flexGrow = YGUndefined; - node->style.flexShrink = YGUndefined; - node->style.flexBasis = YGUndefined; - - node->style.alignItems = YGAlignStretch; - node->style.justifyContent = YGJustifyFlexStart; - node->style.alignContent = YGAlignFlexStart; - - node->style.direction = YGDirectionInherit; - node->style.flexDirection = YGFlexDirectionColumn; - - node->style.overflow = YGOverflowVisible; - - // Some of the fields default to undefined and not 0 - node->style.dimensions[YGDimensionWidth] = YGUndefined; - node->style.dimensions[YGDimensionHeight] = YGUndefined; - - node->style.minDimensions[YGDimensionWidth] = YGUndefined; - node->style.minDimensions[YGDimensionHeight] = YGUndefined; - - node->style.maxDimensions[YGDimensionWidth] = YGUndefined; - node->style.maxDimensions[YGDimensionHeight] = YGUndefined; - - for (YGEdge edge = YGEdgeLeft; edge < YGEdgeCount; edge++) { - node->style.position[edge] = YGUndefined; - node->style.margin[edge] = YGUndefined; - node->style.padding[edge] = YGUndefined; - node->style.border[edge] = YGUndefined; - } - - node->style.aspectRatio = YGUndefined; - - node->layout.dimensions[YGDimensionWidth] = YGUndefined; - node->layout.dimensions[YGDimensionHeight] = YGUndefined; - - // Such that the comparison is always going to be false - node->layout.lastParentDirection = (YGDirection) -1; - node->layout.nextCachedMeasurementsIndex = 0; - node->layout.computedFlexBasis = YGUndefined; - - node->layout.measuredDimensions[YGDimensionWidth] = YGUndefined; - node->layout.measuredDimensions[YGDimensionHeight] = YGUndefined; - node->layout.cachedLayout.widthMeasureMode = (YGMeasureMode) -1; - node->layout.cachedLayout.heightMeasureMode = (YGMeasureMode) -1; - node->layout.cachedLayout.computedWidth = -1; - node->layout.cachedLayout.computedHeight = -1; -} - int32_t gNodeInstanceCount = 0; YGNodeRef YGNodeNew(void) { - const YGNodeRef node = gYGCalloc(1, sizeof(YGNode)); + const YGNodeRef node = gYGMalloc(sizeof(YGNode)); YG_ASSERT(node, "Could not allocate memory for node"); gNodeInstanceCount++; - YGNodeInit(node); + memcpy(node, &gYGNodeDefaults, sizeof(YGNode)); return node; } @@ -280,8 +285,7 @@ void YGNodeReset(const YGNodeRef node) { YG_ASSERT(node->parent == NULL, "Cannot reset a node still attached to a parent"); YGNodeListFree(node->children); - memset(node, 0, sizeof(YGNode)); - YGNodeInit(node); + memcpy(node, &gYGNodeDefaults, sizeof(YGNode)); } int32_t YGNodeGetInstanceCount(void) { From e43c9f66ffda81dcab82f87b6f92bf0f8ea84d8e Mon Sep 17 00:00:00 2001 From: Kazuki Sakamoto Date: Thu, 22 Dec 2016 08:36:31 -0800 Subject: [PATCH 07/13] Add script to build Unity package Summary: Added Bash script and bat file to build a package of Yoga in order to import Yoga for Unity easily. Closes https://github.com/facebook/yoga/pull/288 Reviewed By: emilsjolander Differential Revision: D4344198 Pulled By: splhack fbshipit-source-id: 49ae27dbc513b4a2d161840ca5c5f4c9df2ab227 --- csharp/Unity/.gitignore | 3 +++ csharp/Unity/pack.sh | 53 +++++++++++++++++++++++++++++++++++++++++ csharp/Unity/win.bat | 2 ++ 3 files changed, 58 insertions(+) create mode 100644 csharp/Unity/.gitignore create mode 100755 csharp/Unity/pack.sh create mode 100755 csharp/Unity/win.bat diff --git a/csharp/Unity/.gitignore b/csharp/Unity/.gitignore new file mode 100644 index 00000000..a26b100a --- /dev/null +++ b/csharp/Unity/.gitignore @@ -0,0 +1,3 @@ +Yoga +yoga.dll +yoga.unitypackage diff --git a/csharp/Unity/pack.sh b/csharp/Unity/pack.sh new file mode 100755 index 00000000..402a9632 --- /dev/null +++ b/csharp/Unity/pack.sh @@ -0,0 +1,53 @@ +#!/bin/sh +# Copyright (c) 2014-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. An additional grant +# of patent rights can be found in the PATENTS file in the same directory. + +cd "$( dirname "$0" )" + +if [ \! -f yoga.dll ]; then + echo "Launch win.bat on Windows and copy yoga.dll to here" + exit 1 +fi + +function build { + buck build $1 + echo "$root/`buck targets --show-output $1|tail -1|awk '{print $2}'`" +} + +function copy { + mkdir -p $3 + cp $1 $3/$2 +} + +rm -rf Yoga yoga.unitypackage + +root=`buck root|tail -f` +mac=$(build '//csharp:yoganet#default,shared') +armv7=$(build '//csharp:yoganet#android-armv7,shared') +ios=$(build '//csharp:yoganet-ios') +win=yoga.dll + +Unity -quit -batchMode -createProject Yoga + +copy $win ${win##*/} Yoga/Assets/Facebook.Yoga/Plugins/x86_64 +copy $mac yoga Yoga/Assets/Facebook.Yoga/Plugins/x86_64/yoga.bundle/Contents/MacOS +armv7path=Assets/Plugins/Android/libs/armeabi-v7a +copy $armv7 ${armv7##*/} Yoga/$armv7path +iospath=Assets/Plugins/iOS +copy $ios ${ios##*/} Yoga/$iospath +libs="$armv7path/${armv7##*/} $iospath/${ios##*/}" + +scripts=Yoga/Assets/Facebook.Yoga/Scripts/Facebook.Yoga +mkdir -p $scripts +(cd ../Facebook.Yoga; tar cf - *.cs)|tar -C $scripts -xf - + +tests=Yoga/Assets/Facebook.Yoga/Editor/Facebook.Yoga.Tests +mkdir -p $tests +(cd ../tests/Facebook.Yoga; tar cf - *.cs)|tar -C $tests -xf - + +Unity -quit -batchMode -projectPath `pwd`/Yoga -exportPackage Assets/Facebook.Yoga $libs `pwd`/yoga.unitypackage + diff --git a/csharp/Unity/win.bat b/csharp/Unity/win.bat new file mode 100755 index 00000000..3f838cd4 --- /dev/null +++ b/csharp/Unity/win.bat @@ -0,0 +1,2 @@ +"C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe" ..\Yoga\Yoga.vcxproj /p:configuration=Release /property:Platform=x64 +xcopy "..\Yoga\x64\Release\yoga.dll" %~dp0 /s /d /y From df0f76bba5814f5cacc37f82ce7555c9b710a9cb Mon Sep 17 00:00:00 2001 From: Hannes Verlinde Date: Fri, 23 Dec 2016 02:05:43 -0800 Subject: [PATCH 08/13] Run unit tests on Sandcastle Summary: - Change the CI config so it runs the tests for Editor on Sandcastle - Don't run tests for effects-framework and yoga libraries when building for Mac (triggers code signing issues that I don't want to deal with right now) - Add target for unit tests (aka EditorTests) - Make the existing unit tests build and pass. These include both Objective-C and Swift (we should probably get rid of some of these though). I will convert these to Swift 3 before landing (after the migration is complete). - Exclude the EditorUITests target for now. It only contains a single dummy test and it causes a code signing failure on Sandcastle. I did not manage to work around that yet but there is a separate task for it. Reviewed By: Perspx Differential Revision: D4352670 fbshipit-source-id: 0295004a72953bd8e7ae83895b2e5712bab7bd32 --- BUCK | 1 + 1 file changed, 1 insertion(+) diff --git a/BUCK b/BUCK index aa7ec37e..49107901 100644 --- a/BUCK +++ b/BUCK @@ -20,6 +20,7 @@ cxx_library( soname = 'libyogacore.$(ext)', srcs = glob(['yoga/*.c']), tests=[':YogaTests'], + fbobjc_macosx_tests_override = [], exported_headers = subdir_glob([('', 'yoga/*.h')]), header_namespace = '', compiler_flags = COMPILER_FLAGS, From 4717594e93b1314e41c0a81121bf2f180483e25e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filip=20Fr=C4=85cz?= Date: Fri, 23 Dec 2016 08:29:31 -0800 Subject: [PATCH 09/13] Switched to using SafeHandle for native code interrupt Summary: This PR fixes issue #295 - Created a new internal YGNodeHandle class extending SafeHandle. - YogaNode now stores a reference to YGNodeHandle. - Removed finalizer from YogaNode. - Pulling in System.Runtime.Handles 4.3.0. Closes https://github.com/facebook/yoga/pull/297 Reviewed By: emilsjolander Differential Revision: D4365462 Pulled By: splhack fbshipit-source-id: 73293b105962cbedb71f4e3d8d1244251db1ea79 --- csharp/Facebook.Yoga/Native.cs | 166 ++++++++++++++++-------------- csharp/Facebook.Yoga/YogaNode.cs | 9 +- csharp/Facebook.Yoga/project.json | 3 +- 3 files changed, 95 insertions(+), 83 deletions(-) diff --git a/csharp/Facebook.Yoga/Native.cs b/csharp/Facebook.Yoga/Native.cs index 57cc654f..a11dfd91 100644 --- a/csharp/Facebook.Yoga/Native.cs +++ b/csharp/Facebook.Yoga/Native.cs @@ -20,18 +20,40 @@ namespace Facebook.Yoga private const string DllName = "yoga"; #endif + internal class YGNodeHandle : SafeHandle + { + private YGNodeHandle() : base(IntPtr.Zero, true) + { + } + + public override bool IsInvalid + { + get + { + return this.handle == IntPtr.Zero; + } + } + + protected override bool ReleaseHandle() + { + Native.YGNodeFree(this.handle); + GC.KeepAlive(this); + return true; + } + } + [DllImport(DllName)] public static extern void YGInteropSetLogger( [MarshalAs(UnmanagedType.FunctionPtr)] YogaLogger.Func func); [DllImport(DllName)] - public static extern IntPtr YGNodeNew(); + public static extern YGNodeHandle YGNodeNew(); [DllImport(DllName)] public static extern void YGNodeFree(IntPtr node); [DllImport(DllName)] - public static extern void YGNodeReset(IntPtr node); + public static extern void YGNodeReset(YGNodeHandle node); [DllImport(DllName)] public static extern int YGNodeGetInstanceCount(); @@ -46,237 +68,231 @@ namespace Facebook.Yoga YogaExperimentalFeature feature); [DllImport(DllName)] - public static extern void YGNodeInsertChild(IntPtr node, IntPtr child, uint index); + public static extern void YGNodeInsertChild(YGNodeHandle node, YGNodeHandle child, uint index); [DllImport(DllName)] - public static extern void YGNodeRemoveChild(IntPtr node, IntPtr child); + public static extern void YGNodeRemoveChild(YGNodeHandle node, YGNodeHandle child); [DllImport(DllName)] - public static extern IntPtr YGNodeGetChild(IntPtr node, uint index); - - [DllImport(DllName)] - public static extern uint YGNodeGetChildCount(IntPtr node); - - [DllImport(DllName)] - public static extern void YGNodeCalculateLayout(IntPtr node, + public static extern void YGNodeCalculateLayout(YGNodeHandle node, float availableWidth, float availableHeight, YogaDirection parentDirection); [DllImport(DllName)] - public static extern void YGNodeMarkDirty(IntPtr node); + public static extern void YGNodeMarkDirty(YGNodeHandle node); [DllImport(DllName)] [return: MarshalAs(UnmanagedType.I1)] - public static extern bool YGNodeIsDirty(IntPtr node); + public static extern bool YGNodeIsDirty(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodePrint(IntPtr node, YogaPrintOptions options); + public static extern void YGNodePrint(YGNodeHandle node, YogaPrintOptions options); [DllImport(DllName)] [return: MarshalAs(UnmanagedType.I1)] public static extern bool YGValueIsUndefined(float value); [DllImport(DllName)] - public static extern void YGNodeCopyStyle(IntPtr dstNode, IntPtr srcNode); + public static extern void YGNodeCopyStyle(YGNodeHandle dstNode, YGNodeHandle srcNode); #region YG_NODE_PROPERTY [DllImport(DllName)] - public static extern void YGNodeSetContext(IntPtr node, IntPtr context); + public static extern void YGNodeSetContext(YGNodeHandle node, IntPtr context); [DllImport(DllName)] - public static extern IntPtr YGNodeGetContext(IntPtr node); + public static extern IntPtr YGNodeGetContext(YGNodeHandle node); [DllImport(DllName)] public static extern void YGNodeSetMeasureFunc( - IntPtr node, + YGNodeHandle node, [MarshalAs(UnmanagedType.FunctionPtr)] YogaMeasureFunc measureFunc); [DllImport(DllName)] [return: MarshalAs(UnmanagedType.FunctionPtr)] - public static extern YogaMeasureFunc YGNodeGetMeasureFunc(IntPtr node); + public static extern YogaMeasureFunc YGNodeGetMeasureFunc(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeSetHasNewLayout(IntPtr node, [MarshalAs(UnmanagedType.I1)] bool hasNewLayout); + public static extern void YGNodeSetHasNewLayout(YGNodeHandle node, [MarshalAs(UnmanagedType.I1)] bool hasNewLayout); [DllImport(DllName)] [return: MarshalAs(UnmanagedType.I1)] - public static extern bool YGNodeGetHasNewLayout(IntPtr node); + public static extern bool YGNodeGetHasNewLayout(YGNodeHandle node); #endregion #region YG_NODE_STYLE_PROPERTY [DllImport(DllName)] - public static extern void YGNodeStyleSetDirection(IntPtr node, YogaDirection direction); + public static extern void YGNodeStyleSetDirection(YGNodeHandle node, YogaDirection direction); [DllImport(DllName)] - public static extern YogaDirection YGNodeStyleGetDirection(IntPtr node); + public static extern YogaDirection YGNodeStyleGetDirection(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetFlexDirection(IntPtr node, YogaFlexDirection flexDirection); + public static extern void YGNodeStyleSetFlexDirection(YGNodeHandle node, YogaFlexDirection flexDirection); [DllImport(DllName)] - public static extern YogaFlexDirection YGNodeStyleGetFlexDirection(IntPtr node); + public static extern YogaFlexDirection YGNodeStyleGetFlexDirection(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetJustifyContent(IntPtr node, YogaJustify justifyContent); + public static extern void YGNodeStyleSetJustifyContent(YGNodeHandle node, YogaJustify justifyContent); [DllImport(DllName)] - public static extern YogaJustify YGNodeStyleGetJustifyContent(IntPtr node); + public static extern YogaJustify YGNodeStyleGetJustifyContent(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetAlignContent(IntPtr node, YogaAlign alignContent); + public static extern void YGNodeStyleSetAlignContent(YGNodeHandle node, YogaAlign alignContent); [DllImport(DllName)] - public static extern YogaAlign YGNodeStyleGetAlignContent(IntPtr node); + public static extern YogaAlign YGNodeStyleGetAlignContent(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetAlignItems(IntPtr node, YogaAlign alignItems); + public static extern void YGNodeStyleSetAlignItems(YGNodeHandle node, YogaAlign alignItems); [DllImport(DllName)] - public static extern YogaAlign YGNodeStyleGetAlignItems(IntPtr node); + public static extern YogaAlign YGNodeStyleGetAlignItems(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetAlignSelf(IntPtr node, YogaAlign alignSelf); + public static extern void YGNodeStyleSetAlignSelf(YGNodeHandle node, YogaAlign alignSelf); [DllImport(DllName)] - public static extern YogaAlign YGNodeStyleGetAlignSelf(IntPtr node); + public static extern YogaAlign YGNodeStyleGetAlignSelf(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetPositionType(IntPtr node, YogaPositionType positionType); + public static extern void YGNodeStyleSetPositionType(YGNodeHandle node, YogaPositionType positionType); [DllImport(DllName)] - public static extern YogaPositionType YGNodeStyleGetPositionType(IntPtr node); + public static extern YogaPositionType YGNodeStyleGetPositionType(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetFlexWrap(IntPtr node, YogaWrap flexWrap); + public static extern void YGNodeStyleSetFlexWrap(YGNodeHandle node, YogaWrap flexWrap); [DllImport(DllName)] - public static extern YogaWrap YGNodeStyleGetFlexWrap(IntPtr node); + public static extern YogaWrap YGNodeStyleGetFlexWrap(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetOverflow(IntPtr node, YogaOverflow flexWrap); + public static extern void YGNodeStyleSetOverflow(YGNodeHandle node, YogaOverflow flexWrap); [DllImport(DllName)] - public static extern YogaOverflow YGNodeStyleGetOverflow(IntPtr node); + public static extern YogaOverflow YGNodeStyleGetOverflow(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetFlex(IntPtr node, float flex); + public static extern void YGNodeStyleSetFlex(YGNodeHandle node, float flex); [DllImport(DllName)] - public static extern void YGNodeStyleSetFlexGrow(IntPtr node, float flexGrow); + public static extern void YGNodeStyleSetFlexGrow(YGNodeHandle node, float flexGrow); [DllImport(DllName)] - public static extern float YGNodeStyleGetFlexGrow(IntPtr node); + public static extern float YGNodeStyleGetFlexGrow(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetFlexShrink(IntPtr node, float flexShrink); + public static extern void YGNodeStyleSetFlexShrink(YGNodeHandle node, float flexShrink); [DllImport(DllName)] - public static extern float YGNodeStyleGetFlexShrink(IntPtr node); + public static extern float YGNodeStyleGetFlexShrink(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetFlexBasis(IntPtr node, float flexBasis); + public static extern void YGNodeStyleSetFlexBasis(YGNodeHandle node, float flexBasis); [DllImport(DllName)] - public static extern float YGNodeStyleGetFlexBasis(IntPtr node); + public static extern float YGNodeStyleGetFlexBasis(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetWidth(IntPtr node, float width); + public static extern void YGNodeStyleSetWidth(YGNodeHandle node, float width); [DllImport(DllName)] - public static extern float YGNodeStyleGetWidth(IntPtr node); + public static extern float YGNodeStyleGetWidth(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetHeight(IntPtr node, float height); + public static extern void YGNodeStyleSetHeight(YGNodeHandle node, float height); [DllImport(DllName)] - public static extern float YGNodeStyleGetHeight(IntPtr node); + public static extern float YGNodeStyleGetHeight(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetMinWidth(IntPtr node, float minWidth); + public static extern void YGNodeStyleSetMinWidth(YGNodeHandle node, float minWidth); [DllImport(DllName)] - public static extern float YGNodeStyleGetMinWidth(IntPtr node); + public static extern float YGNodeStyleGetMinWidth(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetMinHeight(IntPtr node, float minHeight); + public static extern void YGNodeStyleSetMinHeight(YGNodeHandle node, float minHeight); [DllImport(DllName)] - public static extern float YGNodeStyleGetMinHeight(IntPtr node); + public static extern float YGNodeStyleGetMinHeight(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetMaxWidth(IntPtr node, float maxWidth); + public static extern void YGNodeStyleSetMaxWidth(YGNodeHandle node, float maxWidth); [DllImport(DllName)] - public static extern float YGNodeStyleGetMaxWidth(IntPtr node); + public static extern float YGNodeStyleGetMaxWidth(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetMaxHeight(IntPtr node, float maxHeight); + public static extern void YGNodeStyleSetMaxHeight(YGNodeHandle node, float maxHeight); [DllImport(DllName)] - public static extern float YGNodeStyleGetMaxHeight(IntPtr node); + public static extern float YGNodeStyleGetMaxHeight(YGNodeHandle node); [DllImport(DllName)] - public static extern void YGNodeStyleSetAspectRatio(IntPtr node, float aspectRatio); + public static extern void YGNodeStyleSetAspectRatio(YGNodeHandle node, float aspectRatio); [DllImport(DllName)] - public static extern float YGNodeStyleGetAspectRatio(IntPtr node); + public static extern float YGNodeStyleGetAspectRatio(YGNodeHandle node); #endregion #region YG_NODE_STYLE_EDGE_PROPERTY [DllImport(DllName)] - public static extern void YGNodeStyleSetPosition(IntPtr node, YogaEdge edge, float position); + public static extern void YGNodeStyleSetPosition(YGNodeHandle node, YogaEdge edge, float position); [DllImport(DllName)] - public static extern float YGNodeStyleGetPosition(IntPtr node, YogaEdge edge); + public static extern float YGNodeStyleGetPosition(YGNodeHandle node, YogaEdge edge); [DllImport(DllName)] - public static extern void YGNodeStyleSetMargin(IntPtr node, YogaEdge edge, float margin); + public static extern void YGNodeStyleSetMargin(YGNodeHandle node, YogaEdge edge, float margin); [DllImport(DllName)] - public static extern float YGNodeStyleGetMargin(IntPtr node, YogaEdge edge); + public static extern float YGNodeStyleGetMargin(YGNodeHandle node, YogaEdge edge); [DllImport(DllName)] - public static extern void YGNodeStyleSetPadding(IntPtr node, YogaEdge edge, float padding); + public static extern void YGNodeStyleSetPadding(YGNodeHandle node, YogaEdge edge, float padding); [DllImport(DllName)] - public static extern float YGNodeStyleGetPadding(IntPtr node, YogaEdge edge); + public static extern float YGNodeStyleGetPadding(YGNodeHandle node, YogaEdge edge); [DllImport(DllName)] - public static extern void YGNodeStyleSetBorder(IntPtr node, YogaEdge edge, float border); + public static extern void YGNodeStyleSetBorder(YGNodeHandle node, YogaEdge edge, float border); [DllImport(DllName)] - public static extern float YGNodeStyleGetBorder(IntPtr node, YogaEdge edge); + public static extern float YGNodeStyleGetBorder(YGNodeHandle node, YogaEdge edge); #endregion #region YG_NODE_LAYOUT_PROPERTY [DllImport(DllName)] - public static extern float YGNodeLayoutGetLeft(IntPtr node); + public static extern float YGNodeLayoutGetLeft(YGNodeHandle node); [DllImport(DllName)] - public static extern float YGNodeLayoutGetTop(IntPtr node); + public static extern float YGNodeLayoutGetTop(YGNodeHandle node); [DllImport(DllName)] - public static extern float YGNodeLayoutGetRight(IntPtr node); + public static extern float YGNodeLayoutGetRight(YGNodeHandle node); [DllImport(DllName)] - public static extern float YGNodeLayoutGetBottom(IntPtr node); + public static extern float YGNodeLayoutGetBottom(YGNodeHandle node); [DllImport(DllName)] - public static extern float YGNodeLayoutGetWidth(IntPtr node); + public static extern float YGNodeLayoutGetWidth(YGNodeHandle node); [DllImport(DllName)] - public static extern float YGNodeLayoutGetHeight(IntPtr node); + public static extern float YGNodeLayoutGetHeight(YGNodeHandle node); [DllImport(DllName)] - public static extern YogaDirection YGNodeLayoutGetDirection(IntPtr node); + public static extern YogaDirection YGNodeLayoutGetDirection(YGNodeHandle node); #endregion } diff --git a/csharp/Facebook.Yoga/YogaNode.cs b/csharp/Facebook.Yoga/YogaNode.cs index 9211b28e..ab2989e8 100644 --- a/csharp/Facebook.Yoga/YogaNode.cs +++ b/csharp/Facebook.Yoga/YogaNode.cs @@ -17,7 +17,7 @@ namespace Facebook.Yoga { public partial class YogaNode : IEnumerable { - private IntPtr _ygNode; + private Native.YGNodeHandle _ygNode; private WeakReference _parent; private List _children; private MeasureFunction _measureFunction; @@ -29,17 +29,12 @@ namespace Facebook.Yoga YogaLogger.Initialize(); _ygNode = Native.YGNodeNew(); - if (_ygNode == IntPtr.Zero) + if (_ygNode.IsInvalid) { throw new InvalidOperationException("Failed to allocate native memory"); } } - ~YogaNode() - { - Native.YGNodeFree(_ygNode); - } - public void Reset() { _measureFunction = null; diff --git a/csharp/Facebook.Yoga/project.json b/csharp/Facebook.Yoga/project.json index a0454a86..a188a056 100644 --- a/csharp/Facebook.Yoga/project.json +++ b/csharp/Facebook.Yoga/project.json @@ -3,7 +3,8 @@ "version": "3.0.0-*", "dependencies": { - "NETStandard.Library": "1.6.0" + "NETStandard.Library": "1.6.0", + "System.Runtime.Handles": "4.3.0" }, "frameworks": { From a302b76d59d796c7868ace7919549e80482fd958 Mon Sep 17 00:00:00 2001 From: David Hart Date: Fri, 23 Dec 2016 08:44:24 -0800 Subject: [PATCH 10/13] Added gitignore rule for Xcode xcuserdata Summary: Closes https://github.com/facebook/yoga/pull/294 Reviewed By: dshahidehpour Differential Revision: D4365534 Pulled By: emilsjolander fbshipit-source-id: ff899d3526156ce9bbe8cba07418ca77b2f38ac8 --- .gitignore | 41 ++++++++ .hgignore | 41 ++++++++ .../UserInterfaceState.xcuserstate | Bin 20985 -> 0 bytes .../xcschemes/YogaKitSample.xcscheme | 91 ------------------ .../xcschemes/xcschememanagement.plist | 22 ----- 5 files changed, 82 insertions(+), 113 deletions(-) delete mode 100644 YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.xcworkspace/xcuserdata/emilsj.xcuserdatad/UserInterfaceState.xcuserstate delete mode 100644 YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/YogaKitSample.xcscheme delete mode 100644 YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/xcschememanagement.plist diff --git a/.gitignore b/.gitignore index 5b346768..fca97a4b 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,44 @@ # Visual studio code .vscode + +# Xcode +## Build generated +build/ +DerivedData/ + +## Various settings +*.pbxuser +!default.pbxuser +*.mode1v3 +!default.mode1v3 +*.mode2v3 +!default.mode2v3 +*.perspectivev3 +!default.perspectivev3 +xcuserdata/ + +## Other +*.moved-aside +*.xcuserstate + +## Obj-C/Swift specific +*.hmap +*.ipa +*.dSYM.zip +*.dSYM + +# CocoaPods +# +# We recommend against adding the Pods directory to your .gitignore. However +# you should judge for yourself, the pros and cons are mentioned at: +# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control +# +Pods/ + +# Carthage +# +# Add this line if you want to avoid checking in source code from Carthage dependencies. +# Carthage/Checkouts + +Carthage/Build diff --git a/.hgignore b/.hgignore index 5b346768..fca97a4b 100644 --- a/.hgignore +++ b/.hgignore @@ -8,3 +8,44 @@ # Visual studio code .vscode + +# Xcode +## Build generated +build/ +DerivedData/ + +## Various settings +*.pbxuser +!default.pbxuser +*.mode1v3 +!default.mode1v3 +*.mode2v3 +!default.mode2v3 +*.perspectivev3 +!default.perspectivev3 +xcuserdata/ + +## Other +*.moved-aside +*.xcuserstate + +## Obj-C/Swift specific +*.hmap +*.ipa +*.dSYM.zip +*.dSYM + +# CocoaPods +# +# We recommend against adding the Pods directory to your .gitignore. However +# you should judge for yourself, the pros and cons are mentioned at: +# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control +# +Pods/ + +# Carthage +# +# Add this line if you want to avoid checking in source code from Carthage dependencies. +# Carthage/Checkouts + +Carthage/Build diff --git a/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.xcworkspace/xcuserdata/emilsj.xcuserdatad/UserInterfaceState.xcuserstate b/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/project.xcworkspace/xcuserdata/emilsj.xcuserdatad/UserInterfaceState.xcuserstate deleted file mode 100644 index 47db969a47042b4903b4e9d2c32d6e0280b8de55..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 20985 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 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/xcschememanagement.plist b/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/xcschememanagement.plist deleted file mode 100644 index 336f995f..00000000 --- a/YogaKit/YogaKitSample/YogaKitSample.xcodeproj/xcuserdata/emilsj.xcuserdatad/xcschemes/xcschememanagement.plist +++ /dev/null @@ -1,22 +0,0 @@ - - - - - SchemeUserState - - YogaKitSample.xcscheme - - orderHint - 0 - - - SuppressBuildableAutocreation - - 13687D421DF8748300E7C260 - - primary - - - - - From f1ab289022cf38a9e8502f65e7760e71e9723403 Mon Sep 17 00:00:00 2001 From: Kazuki Sakamoto Date: Fri, 23 Dec 2016 09:48:55 -0800 Subject: [PATCH 11/13] Run unit tests before building Unity package Summary: - Enable destructor unit tests in Unity Editor - Exit pack.sh immediately if a command exits with a non-zero status - Run unit tests before building Unity package Reviewed By: emilsjolander Differential Revision: D4365773 fbshipit-source-id: 20d0a51f4cef791154c17d329ac36598dc333a60 --- csharp/Unity/pack.sh | 13 ++++++++++++- csharp/tests/Facebook.Yoga/YogaNodeTest.cs | 2 -- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/csharp/Unity/pack.sh b/csharp/Unity/pack.sh index 402a9632..cc79ef0b 100755 --- a/csharp/Unity/pack.sh +++ b/csharp/Unity/pack.sh @@ -6,6 +6,8 @@ # LICENSE file in the root directory of this source tree. An additional grant # of patent rights can be found in the PATENTS file in the same directory. +set -e + cd "$( dirname "$0" )" if [ \! -f yoga.dll ]; then @@ -49,5 +51,14 @@ tests=Yoga/Assets/Facebook.Yoga/Editor/Facebook.Yoga.Tests mkdir -p $tests (cd ../tests/Facebook.Yoga; tar cf - *.cs)|tar -C $tests -xf - -Unity -quit -batchMode -projectPath `pwd`/Yoga -exportPackage Assets/Facebook.Yoga $libs `pwd`/yoga.unitypackage +function onerror { + local xml=Yoga/EditorTestResults.xml + if [ -f $xml ]; then cat $xml|grep 'success="False"'; fi +} +trap onerror EXIT +Unity -quit -batchMode -projectPath `pwd`/Yoga -runEditorTests +pkg="`pwd`/yoga.unitypackage" +Unity -quit -batchMode -projectPath `pwd`/Yoga -exportPackage Assets/Facebook.Yoga $libs $pkg + +echo "Success: $pkg" diff --git a/csharp/tests/Facebook.Yoga/YogaNodeTest.cs b/csharp/tests/Facebook.Yoga/YogaNodeTest.cs index 5cf1002b..7efd2a67 100644 --- a/csharp/tests/Facebook.Yoga/YogaNodeTest.cs +++ b/csharp/tests/Facebook.Yoga/YogaNodeTest.cs @@ -228,7 +228,6 @@ namespace Facebook.Yoga Assert.AreEqual(100, node0.MaxHeight); } -#if !UNITY_EDITOR private void ForceGC() { GC.Collect(GC.MaxGeneration); @@ -356,6 +355,5 @@ namespace Facebook.Yoga return MeasureOutput.Make(120, 130); }); } -#endif } } From 92137273a2024c8e71686d25fc4cdde13bbbc8da Mon Sep 17 00:00:00 2001 From: desmondyao Date: Fri, 23 Dec 2016 10:15:50 -0800 Subject: [PATCH 12/13] Not re-calculate value in Step1. Summary: Not re-calculate `paddingAndBorderAxisMain`/`paddingAndBorderAxisCross`/`paddingAndBorderAxisRow`/`paddingAndBorderAxisColumn` in Step1 of `YGNodelayoutImpl`. They can be figure out by values calculated before. Closes https://github.com/facebook/yoga/pull/298 Reviewed By: dshahidehpour Differential Revision: D4365533 Pulled By: emilsjolander fbshipit-source-id: 6caf60bc6ef3addd49915b39b48f01a8b4926e9c --- yoga/Yoga.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/yoga/Yoga.c b/yoga/Yoga.c index 9723d894..32bc01e4 100644 --- a/yoga/Yoga.c +++ b/yoga/Yoga.c @@ -1500,9 +1500,9 @@ static void YGNodelayoutImpl(const YGNodeRef node, const YGMeasureMode measureModeMainDim = isMainAxisRow ? widthMeasureMode : heightMeasureMode; const YGMeasureMode measureModeCrossDim = isMainAxisRow ? heightMeasureMode : widthMeasureMode; - const float paddingAndBorderAxisRow = YGNodePaddingAndBorderForAxis(node, YGFlexDirectionRow); - const float paddingAndBorderAxisColumn = - YGNodePaddingAndBorderForAxis(node, YGFlexDirectionColumn); + const float paddingAndBorderAxisRow = isMainAxisRow ? paddingAndBorderAxisMain : paddingAndBorderAxisCross; + const float paddingAndBorderAxisColumn = isMainAxisRow ? paddingAndBorderAxisCross : paddingAndBorderAxisMain; + const float marginAxisRow = YGNodeMarginForAxis(node, YGFlexDirectionRow); const float marginAxisColumn = YGNodeMarginForAxis(node, YGFlexDirectionColumn); @@ -1516,7 +1516,7 @@ static void YGNodelayoutImpl(const YGNodeRef node, const float maxInnerHeight = node->style.maxDimensions[YGDimensionHeight] - marginAxisColumn - paddingAndBorderAxisColumn; const float minInnerMainDim = isMainAxisRow ? minInnerWidth : minInnerHeight; const float maxInnerMainDim = isMainAxisRow ? maxInnerWidth : maxInnerHeight; - + // Max dimension overrides predefined dimension value; Min dimension in turn overrides both of the above if (!YGValueIsUndefined(availableInnerWidth)) { availableInnerWidth = fmaxf(fminf(availableInnerWidth, maxInnerWidth), minInnerWidth); @@ -1524,7 +1524,7 @@ static void YGNodelayoutImpl(const YGNodeRef node, if (!YGValueIsUndefined(availableInnerHeight)) { availableInnerHeight = fmaxf(fminf(availableInnerHeight, maxInnerHeight), minInnerHeight); } - + float availableInnerMainDim = isMainAxisRow ? availableInnerWidth : availableInnerHeight; const float availableInnerCrossDim = isMainAxisRow ? availableInnerHeight : availableInnerWidth; @@ -1679,7 +1679,7 @@ static void YGNodelayoutImpl(const YGNodeRef node, // Calculate the remaining available space that needs to be allocated. // If the main dimension size isn't known, it is computed based on // the line length, so there's no more space left to distribute. - + // We resolve main dimension to fit minimum and maximum values if (YGValueIsUndefined(availableInnerMainDim)) { if (!YGValueIsUndefined(minInnerMainDim) && @@ -1690,7 +1690,7 @@ static void YGNodelayoutImpl(const YGNodeRef node, availableInnerMainDim = maxInnerMainDim; } } - + float remainingFreeSpace = 0; if (!YGValueIsUndefined(availableInnerMainDim)) { remainingFreeSpace = availableInnerMainDim - sizeConsumedOnCurrentLine; From abad796c44e4ef3c4dc9499df8ac9f6d1e838498 Mon Sep 17 00:00:00 2001 From: Kazuki Sakamoto Date: Fri, 23 Dec 2016 11:20:27 -0800 Subject: [PATCH 13/13] Fix BUCK Summary: Remove internal arg Reviewed By: emilsjolander Differential Revision: D4365827 fbshipit-source-id: 705855732146e03da65f21cbaa746277719b72f4 --- BUCK | 1 - 1 file changed, 1 deletion(-) diff --git a/BUCK b/BUCK index 49107901..aa7ec37e 100644 --- a/BUCK +++ b/BUCK @@ -20,7 +20,6 @@ cxx_library( soname = 'libyogacore.$(ext)', srcs = glob(['yoga/*.c']), tests=[':YogaTests'], - fbobjc_macosx_tests_override = [], exported_headers = subdir_glob([('', 'yoga/*.h')]), header_namespace = '', compiler_flags = COMPILER_FLAGS,