Add YGLayoutGetMargin

Summary:
Fix #326. I'll open another PR once this one gets accepted to add support for `YGLayoutGetBorder` 👌
Closes #335

Reviewed By: gkassabli

Differential Revision: D4409399

Pulled By: emilsjolander

fbshipit-source-id: 8153f6701cab60b55a485f6d2e0b9f7767481090

csharp/Facebook.Yoga/Native.cs

@@ -312,6 +312,9 @@ public static extern void YGNodeSetBaselineFunc(
         [DllImport(DllName, ExactSpelling = true, CallingConvention = CallingConvention.Cdecl)]
         public static extern float YGNodeLayoutGetHeight(YGNodeHandle node);
 
+        [DllImport(DllName, ExactSpelling = true, CallingConvention = CallingConvention.Cdecl)]
+        public static extern float YGNodeLayoutGetMargin(YGNodeHandle node, YogaEdge edge);
+
         [DllImport(DllName, ExactSpelling = true, CallingConvention = CallingConvention.Cdecl)]
         public static extern float YGNodeLayoutGetPadding(YGNodeHandle node, YogaEdge edge);
 

csharp/Facebook.Yoga/YogaNode.Spacing.cs

@@ -452,6 +452,54 @@ public float BorderWidth
             }
         }
 
+        public float LayoutMarginLeft
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetMargin(_ygNode, YogaEdge.Left);
+            }
+        }
+
+        public float LayoutMarginTop
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetMargin(_ygNode, YogaEdge.Top);
+            }
+        }
+
+        public float LayoutMarginRight
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetMargin(_ygNode, YogaEdge.Right);
+            }
+        }
+
+        public float LayoutMarginBottom
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetMargin(_ygNode, YogaEdge.Bottom);
+            }
+        }
+
+        public float LayoutMarginStart
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetMargin(_ygNode, YogaEdge.Start);
+            }
+        }
+
+        public float LayoutMarginEnd
+        {
+            get
+            {
+                return Native.YGNodeLayoutGetMargin(_ygNode, YogaEdge.End);
+            }
+        }
+
         public float LayoutPaddingLeft
         {
             get

csharp/tests/Facebook.Yoga/YogaNodeTest.cs

@@ -434,6 +434,23 @@ private void TestMeasureFuncWithDestructorForGC(YogaNode parent)
             });
         }
 
+        [Test]
+        public void TestLayoutMargin() {
+          YogaNode node = new YogaNode();
+          node.Width = 100;
+          node.Height = 100;
+          node.MarginStart = 1;
+          node.MarginEnd = 2;
+          node.MarginTop = 3;
+          node.MarginBottom = 4;
+          node.CalculateLayout();
+
+          Assert.AreEqual(1, node.LayoutMarginLeft);
+          Assert.AreEqual(2, node.LayoutMarginRight);
+          Assert.AreEqual(3, node.LayoutMarginTop);
+          Assert.AreEqual(4, node.LayoutMarginBottom);
+        }
+
         [Test]
         public void TestLayoutPadding() {
           YogaNode node = new YogaNode();

java/com/facebook/yoga/YogaNode.java

@@ -70,6 +70,14 @@ public static boolean isExperimentalFeatureEnabled(YogaExperimentalFeature featu
   @DoNotStrip
   private float mLeft = YogaConstants.UNDEFINED;
   @DoNotStrip
+  private float mMarginLeft = 0;
+  @DoNotStrip
+  private float mMarginTop = 0;
+  @DoNotStrip
+  private float mMarginRight = 0;
+  @DoNotStrip
+  private float mMarginBottom = 0;
+  @DoNotStrip
   private float mPaddingLeft = 0;
   @DoNotStrip
   private float mPaddingTop = 0;
@@ -573,6 +581,26 @@ public float getLayoutHeight() {
     return mHeight;
   }
 
+  @Override
+  public float getLayoutMargin(YogaEdge edge) {
+    switch (edge) {
+      case LEFT:
+        return mMarginLeft;
+      case TOP:
+        return mMarginTop;
+      case RIGHT:
+        return mMarginRight;
+      case BOTTOM:
+        return mMarginBottom;
+      case START:
+        return getLayoutDirection() == YogaDirection.RTL ? mMarginRight : mMarginLeft;
+      case END:
+        return getLayoutDirection() == YogaDirection.RTL ? mMarginLeft : mMarginRight;
+      default:
+        throw new IllegalArgumentException("Cannot get layout margins of multi-edge shorthands");
+    }
+  }
+
   @Override
   public float getLayoutPadding(YogaEdge edge) {
     switch (edge) {

java/com/facebook/yoga/YogaNodeAPI.java

@@ -82,6 +82,7 @@ public interface YogaNodeAPI<YogaNodeType extends YogaNodeAPI> {
   float getLayoutY();
   float getLayoutWidth();
   float getLayoutHeight();
+  float getLayoutMargin(YogaEdge edge);
   float getLayoutPadding(YogaEdge edge);
   YogaDirection getLayoutDirection();
   YogaOverflow getOverflow();

java/jni/YGJNI.cpp

@@ -30,6 +30,11 @@ static void YGTransferLayoutOutputsRecursive(YGNodeRef root) {
     static auto leftField = obj->getClass()->getField<jfloat>("mLeft");
     static auto topField = obj->getClass()->getField<jfloat>("mTop");
 
+    static auto marginLeftField = obj->getClass()->getField<jfloat>("mMarginLeft");
+    static auto marginTopField = obj->getClass()->getField<jfloat>("mMarginTop");
+    static auto marginRightField = obj->getClass()->getField<jfloat>("mMarginRight");
+    static auto marginBottomField = obj->getClass()->getField<jfloat>("mMarginBottom");
+
     static auto paddingLeftField = obj->getClass()->getField<jfloat>("mPaddingLeft");
     static auto paddingTopField = obj->getClass()->getField<jfloat>("mPaddingTop");
     static auto paddingRightField = obj->getClass()->getField<jfloat>("mPaddingRight");
@@ -40,6 +45,11 @@ static void YGTransferLayoutOutputsRecursive(YGNodeRef root) {
     obj->setFieldValue(leftField, YGNodeLayoutGetLeft(root));
     obj->setFieldValue(topField, YGNodeLayoutGetTop(root));
 
+    obj->setFieldValue(marginLeftField, YGNodeLayoutGetMargin(root, YGEdgeLeft));
+    obj->setFieldValue(marginTopField, YGNodeLayoutGetMargin(root, YGEdgeTop));
+    obj->setFieldValue(marginRightField, YGNodeLayoutGetMargin(root, YGEdgeRight));
+    obj->setFieldValue(marginBottomField, YGNodeLayoutGetMargin(root, YGEdgeBottom));
+
     obj->setFieldValue(paddingLeftField, YGNodeLayoutGetPadding(root, YGEdgeLeft));
     obj->setFieldValue(paddingTopField, YGNodeLayoutGetPadding(root, YGEdgeTop));
     obj->setFieldValue(paddingRightField, YGNodeLayoutGetPadding(root, YGEdgeRight));

java/tests/com/facebook/yoga/YogaNodeTest.java

@@ -168,6 +168,23 @@ public void testCopyStyle() {
     assertEquals(100, (int) node0.getMaxHeight().value);
   }
 
+  @Test
+  public void testLayoutMargin() {
+    final YogaNode node = new YogaNode();
+    node.setWidth(100);
+    node.setHeight(100);
+    node.setMargin(YogaEdge.START, 1);
+    node.setMargin(YogaEdge.END, 2);
+    node.setMargin(YogaEdge.TOP, 3);
+    node.setMargin(YogaEdge.BOTTOM, 4);
+    node.calculateLayout();
+
+    assertEquals(1, (int) node.getLayoutMargin(YogaEdge.LEFT));
+    assertEquals(2, (int) node.getLayoutMargin(YogaEdge.RIGHT));
+    assertEquals(3, (int) node.getLayoutMargin(YogaEdge.TOP));
+    assertEquals(4, (int) node.getLayoutMargin(YogaEdge.BOTTOM));
+  }
+
   @Test
   public void testLayoutPadding() {
     final YogaNode node = new YogaNode();

javascript/sources/Node.cc

@@ -453,3 +453,13 @@ Layout Node::getComputedLayout(void) const
 
     return layout;
 }
+
+double Node::getComputedMargin(int edge) const
+{
+    return YGNodeLayoutGetMargin(m_node, static_cast<YGEdge>(edge));
+}
+
+double Node::getComputedPadding(int edge) const
+{
+    return YGNodeLayoutGetPadding(m_node, static_cast<YGEdge>(edge));
+}

javascript/sources/Node.hh

@@ -176,6 +176,9 @@ class Node {
 
     Layout getComputedLayout(void) const;
 
+    double getComputedMargin(int edge) const;
+    double getComputedPadding(int edge) const;
+
  private:
 
     YGNodeRef m_node;

javascript/sources/nbind.cc

@@ -153,4 +153,7 @@ NBIND_CLASS(Node)
     method(getComputedHeight);
 
     method(getComputedLayout);
+
+    method(getComputedMargin);
+    method(getComputedPadding);
 }

javascript/tests/Facebook.Yoga/YGComputedMarginTest.js

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+
+var Yoga = Yoga || require("../../sources/entry-" + process.env.TEST_ENTRY);
+
+it("margin_start", function () {
+  var root = Yoga.Node.create();
+  root.setWidth(100);
+  root.setHeight(100);
+  root.setMargin(Yoga.EDGE_START, `10%`);
+
+  root.calculateLayout(100, 100, Yoga.DIRECTION_LTR);
+
+  console.assert(10 === root.getComputedMargin(Yoga.EDGE_LEFT), "10 === root.getComputedMargin(Yoga.EDGE_LEFT)");
+  console.assert(0 === root.getComputedMargin(Yoga.EDGE_RIGHT), "0 === root.getComputedMargin(Yoga.EDGE_RIGHT)");
+
+  root.calculateLayout(100, 100, Yoga.DIRECTION_RTL);
+
+  console.assert(0 === root.getComputedMargin(Yoga.EDGE_LEFT), "0 === root.getComputedMargin(Yoga.EDGE_LEFT)");
+  console.assert(10 === root.getComputedMargin(Yoga.EDGE_RIGHT), "10 === root.getComputedMargin(Yoga.EDGE_RIGHT)");
+
+  if (typeof root !== "undefined")
+    root.freeRecursive();
+
+  (typeof gc !== "undefined") && gc();
+  console.assert(0 === Yoga.getInstanceCount(), "0 === Yoga.getInstanceCount() (" + Yoga.getInstanceCount() + ")");
+});

javascript/tests/Facebook.Yoga/YGComputedPaddingTest.js

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+
+var Yoga = Yoga || require("../../sources/entry-" + process.env.TEST_ENTRY);
+
+it("padding_start", function () {
+  var root = Yoga.Node.create();
+  root.setWidth(100);
+  root.setHeight(100);
+  root.setPadding(Yoga.EDGE_START, `10%`);
+
+  root.calculateLayout(100, 100, Yoga.DIRECTION_LTR);
+
+  console.assert(10 === root.getComputedPadding(Yoga.EDGE_LEFT), "10 === root.getComputedPadding(Yoga.EDGE_LEFT)");
+  console.assert(0 === root.getComputedPadding(Yoga.EDGE_RIGHT), "0 === root.getComputedPadding(Yoga.EDGE_RIGHT)");
+
+  root.calculateLayout(100, 100, Yoga.DIRECTION_RTL);
+
+  console.assert(0 === root.getComputedPadding(Yoga.EDGE_LEFT), "0 === root.getComputedPadding(Yoga.EDGE_LEFT)");
+  console.assert(10 === root.getComputedPadding(Yoga.EDGE_RIGHT), "10 === root.getComputedPadding(Yoga.EDGE_RIGHT)");
+
+  if (typeof root !== "undefined")
+    root.freeRecursive();
+
+  (typeof gc !== "undefined") && gc();
+  console.assert(0 === Yoga.getInstanceCount(), "0 === Yoga.getInstanceCount() (" + Yoga.getInstanceCount() + ")");
+});

tests/YGComputedMarginTest.cpp

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ */
+
+#include <yoga/Yoga.h>
+#include <gtest/gtest.h>
+
+TEST(YogaTest, computed_layout_margin) {
+  const YGNodeRef root = YGNodeNew();
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+  YGNodeStyleSetMarginPercent(root, YGEdgeStart, 10);
+
+  YGNodeCalculateLayout(root, 100, 100, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetMargin(root, YGEdgeLeft));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetMargin(root, YGEdgeRight));
+
+  YGNodeCalculateLayout(root, 100, 100, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetMargin(root, YGEdgeLeft));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetMargin(root, YGEdgeRight));
+
+  YGNodeFreeRecursive(root);
+}