rename csharp code

Summary: new name

Reviewed By: splhack

Differential Revision: D4247106

fbshipit-source-id: 6e1097de104f3a011c78ae65b33e57865b007711

csharp/Facebook.Yoga/Facebook.Yoga.xproj

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>75bb7605-e54b-4ede-8f5a-ff1f24464236</ProjectGuid>
+    <RootNamespace>Facebook.Yoga</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.targets" Condition="'$(VSToolsPath)' != ''" />
+</Project>

csharp/Facebook.Yoga/MeasureFunction.cs

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public delegate long MeasureFunction(
+        YogaNode node,
+        float width,
+        YogaMeasureMode widthMode,
+        float height,
+        YogaMeasureMode heightMode);
+}

csharp/Facebook.Yoga/MeasureOutput.cs

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public class MeasureOutput
+    {
+        public static long Make(double width, double height)
+        {
+            return Make((int) width, (int) height);
+        }
+
+        public static long Make(int width, int height)
+        {
+            return (long)(((ulong) width) << 32 | ((uint) height));
+        }
+
+        public static int GetWidth(long measureOutput)
+        {
+            return (int) (0xFFFFFFFF & (measureOutput >> 32));
+        }
+
+        public static int GetHeight(long measureOutput)
+        {
+            return (int) (0xFFFFFFFF & measureOutput);
+        }
+    }
+}

csharp/Facebook.Yoga/Native.cs

@@ -0,0 +1,286 @@
+/**
+ * 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.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Facebook.Yoga
+{
+    internal static class Native
+    {
+#if UNITY_IOS && !UNITY_EDITOR
+        private const string DllName = "__Internal";
+#else
+        private const string DllName = "yoga";
+#endif
+
+        [DllImport(DllName)]
+        public static extern void YGInteropSetLogger(
+            [MarshalAs(UnmanagedType.FunctionPtr)] YogaLogger.Func func);
+
+        [DllImport(DllName)]
+        public static extern IntPtr CSSNodeNew();
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeInit(IntPtr cssNode);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeFree(IntPtr cssNode);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeReset(IntPtr cssNode);
+
+        [DllImport(DllName)]
+        public static extern int CSSNodeGetInstanceCount();
+
+        [DllImport(DllName)]
+        public static extern void CSSLayoutSetExperimentalFeatureEnabled(
+            YogaExperimentalFeature feature,
+            bool enabled);
+
+        [DllImport(DllName)]
+        public static extern bool CSSLayoutIsExperimentalFeatureEnabled(
+            YogaExperimentalFeature feature);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeInsertChild(IntPtr node, IntPtr child, uint index);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeRemoveChild(IntPtr node, IntPtr child);
+
+        [DllImport(DllName)]
+        public static extern IntPtr CSSNodeGetChild(IntPtr node, uint index);
+
+        [DllImport(DllName)]
+        public static extern uint CSSNodeChildCount(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeCalculateLayout(IntPtr node,
+                            float availableWidth,
+                            float availableHeight,
+                            YogaDirection parentDirection);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeMarkDirty(IntPtr node);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        public static extern bool CSSNodeIsDirty(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodePrint(IntPtr node, YogaPrintOptions options);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        public static extern bool CSSValueIsUndefined(float value);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeCopyStyle(IntPtr dstNode, IntPtr srcNode);
+
+        #region CSS_NODE_PROPERTY
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeSetContext(IntPtr node, IntPtr context);
+
+        [DllImport(DllName)]
+        public static extern IntPtr CSSNodeGetContext(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeSetMeasureFunc(
+            IntPtr node,
+            [MarshalAs(UnmanagedType.FunctionPtr)] YogaMeasureFunc measureFunc);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.FunctionPtr)]
+        public static extern YogaMeasureFunc CSSNodeGetMeasureFunc(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeSetHasNewLayout(IntPtr node, [MarshalAs(UnmanagedType.I1)] bool hasNewLayout);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        public static extern bool CSSNodeGetHasNewLayout(IntPtr node);
+
+        #endregion
+
+        #region CSS_NODE_STYLE_PROPERTY
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetDirection(IntPtr node, YogaDirection direction);
+
+        [DllImport(DllName)]
+        public static extern YogaDirection CSSNodeStyleGetDirection(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetFlexDirection(IntPtr node, YogaFlexDirection flexDirection);
+
+        [DllImport(DllName)]
+        public static extern YogaFlexDirection CSSNodeStyleGetFlexDirection(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetJustifyContent(IntPtr node, YogaJustify justifyContent);
+
+        [DllImport(DllName)]
+        public static extern YogaJustify CSSNodeStyleGetJustifyContent(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetAlignContent(IntPtr node, YogaAlign alignContent);
+
+        [DllImport(DllName)]
+        public static extern YogaAlign CSSNodeStyleGetAlignContent(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetAlignItems(IntPtr node, YogaAlign alignItems);
+
+        [DllImport(DllName)]
+        public static extern YogaAlign CSSNodeStyleGetAlignItems(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetAlignSelf(IntPtr node, YogaAlign alignSelf);
+
+        [DllImport(DllName)]
+        public static extern YogaAlign CSSNodeStyleGetAlignSelf(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetPositionType(IntPtr node, YogaPositionType positionType);
+
+        [DllImport(DllName)]
+        public static extern YogaPositionType CSSNodeStyleGetPositionType(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetFlexWrap(IntPtr node, YogaWrap flexWrap);
+
+        [DllImport(DllName)]
+        public static extern YogaWrap CSSNodeStyleGetFlexWrap(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetOverflow(IntPtr node, YogaOverflow flexWrap);
+
+        [DllImport(DllName)]
+        public static extern YogaOverflow CSSNodeStyleGetOverflow(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetFlex(IntPtr node, float flex);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetFlexGrow(IntPtr node, float flexGrow);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetFlexGrow(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetFlexShrink(IntPtr node, float flexShrink);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetFlexShrink(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetFlexBasis(IntPtr node, float flexBasis);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetFlexBasis(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetWidth(IntPtr node, float width);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetWidth(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetHeight(IntPtr node, float height);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetHeight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetMinWidth(IntPtr node, float minWidth);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetMinWidth(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetMinHeight(IntPtr node, float minHeight);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetMinHeight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetMaxWidth(IntPtr node, float maxWidth);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetMaxWidth(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetMaxHeight(IntPtr node, float maxHeight);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetMaxHeight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetAspectRatio(IntPtr node, float aspectRatio);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetAspectRatio(IntPtr node);
+
+        #endregion
+
+        #region CSS_NODE_STYLE_EDGE_PROPERTY
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetPosition(IntPtr node, YogaEdge edge, float position);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetPosition(IntPtr node, YogaEdge edge);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetMargin(IntPtr node, YogaEdge edge, float margin);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetMargin(IntPtr node, YogaEdge edge);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetPadding(IntPtr node, YogaEdge edge, float padding);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetPadding(IntPtr node, YogaEdge edge);
+
+        [DllImport(DllName)]
+        public static extern void CSSNodeStyleSetBorder(IntPtr node, YogaEdge edge, float border);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeStyleGetBorder(IntPtr node, YogaEdge edge);
+
+        #endregion
+
+        #region CSS_NODE_LAYOUT_PROPERTY
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeLayoutGetLeft(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeLayoutGetTop(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeLayoutGetRight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeLayoutGetBottom(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeLayoutGetWidth(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern float CSSNodeLayoutGetHeight(IntPtr node);
+
+        [DllImport(DllName)]
+        public static extern YogaDirection CSSNodeLayoutGetDirection(IntPtr node);
+
+        #endregion
+    }
+}

csharp/Facebook.Yoga/Properties/AssemblyInfo.cs

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+
+using System.Reflection;
+using System.Resources;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Facebook, Inc.")]
+[assembly: AssemblyProduct("Facebook.Yoga")]
+[assembly: AssemblyTrademark("Copyright (c) 2014-present, Facebook, Inc.")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("75bb7605-e54b-4ede-8f5a-ff1f24464236")]
+
+[assembly: NeutralResourcesLanguage("en")]
+
+[assembly: AssemblyVersion("3.0.0.0")]

csharp/Facebook.Yoga/Spacing.cs

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public class Spacing
+    {
+        public float? Top;
+        public float? Bottom;
+        public float? Left;
+        public float? Right;
+
+        public Spacing(
+            float? top = null,
+            float? bottom = null,
+            float? left = null,
+            float? right = null)
+        {
+            Top = top;
+            Bottom = bottom;
+            Left = left;
+            Right = right;
+        }
+    }
+}

csharp/Facebook.Yoga/YogaAlign.cs

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaAlign
+    {
+        Auto,
+        FlexStart,
+        Center,
+        FlexEnd,
+        Stretch,
+    }
+}

csharp/Facebook.Yoga/YogaConstants.cs

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public static class YogaConstants
+    {
+        public const float Undefined = float.NaN;
+
+        public static bool IsUndefined(float value)
+        {
+            return float.IsNaN(value);
+        }
+    }
+}

csharp/Facebook.Yoga/YogaDimension.cs

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaDimension
+    {
+        Width,
+        Height,
+    }
+}

csharp/Facebook.Yoga/YogaDirection.cs

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaDirection
+    {
+        Inherit,
+        LTR,
+        RTL,
+    }
+}

csharp/Facebook.Yoga/YogaEdge.cs

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaEdge
+    {
+        Left,
+        Top,
+        Right,
+        Bottom,
+        Start,
+        End,
+        Horizontal,
+        Vertical,
+        All,
+    }
+}

csharp/Facebook.Yoga/YogaExperimentalFeature.cs

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaExperimentalFeature
+    {
+        Rounding,
+        WebFlexBasis,
+    }
+}

csharp/Facebook.Yoga/YogaFlexDirection.cs

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaFlexDirection
+    {
+        Column,
+        ColumnReverse,
+        Row,
+        RowReverse,
+    }
+}

csharp/Facebook.Yoga/YogaJustify.cs

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaJustify
+    {
+        FlexStart,
+        Center,
+        FlexEnd,
+        SpaceBetween,
+        SpaceAround,
+    }
+}

csharp/Facebook.Yoga/YogaLogLevel.cs

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaLogLevel
+    {
+        Error,
+        Warn,
+        Info,
+        Debug,
+        Verbose,
+    }
+}

csharp/Facebook.Yoga/YogaLogger.cs

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Facebook.Yoga
+{
+    internal static class YogaLogger
+    {
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void Func(YogaLogLevel level, string message);
+
+        private static bool _initialized;
+        private static Func _managedLogger = null;
+
+        public static Func Logger = null;
+
+        public static void Initialize()
+        {
+            if (!_initialized)
+            {
+                _managedLogger = (level, message) => {
+                    if (Logger != null)
+                    {
+                        Logger(level, message);
+                    }
+
+                    if (level == YogaLogLevel.Error)
+                    {
+                        throw new InvalidOperationException(message);
+                    }
+                };
+                Native.YGInteropSetLogger(_managedLogger);
+                _initialized = true;
+            }
+        }
+    }
+}

csharp/Facebook.Yoga/YogaMeasureFunc.cs

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Facebook.Yoga
+{
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate YogaSize YogaMeasureFunc(
+        IntPtr node,
+        float width,
+        YogaMeasureMode widthMode,
+        float height,
+        YogaMeasureMode heightMode);
+}

csharp/Facebook.Yoga/YogaMeasureMode.cs

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaMeasureMode
+    {
+        Undefined,
+        Exactly,
+        AtMost,
+    }
+}

csharp/Facebook.Yoga/YogaNode.Create.cs

@@ -0,0 +1,233 @@
+/**
+ * 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.
+ */
+
+using System;
+
+namespace Facebook.Yoga
+{
+    public partial class YogaNode
+    {
+        public static YogaNode Create(
+            YogaDirection? styleDirection = null,
+            YogaFlexDirection? flexDirection = null,
+            YogaJustify? justifyContent = null,
+            YogaAlign? alignContent = null,
+            YogaAlign? alignItems = null,
+            YogaAlign? alignSelf = null,
+            YogaPositionType? positionType = null,
+            YogaWrap? wrap = null,
+            YogaOverflow? overflow = null,
+            float? flex = null,
+            float? flexGrow = null,
+            float? flexShrink = null,
+            float? flexBasis = null,
+            Spacing position = null,
+            Spacing margin = null,
+            Spacing padding = null,
+            Spacing border = null,
+            float? Width = null,
+            float? Height = null,
+            float? MaxWidth = null,
+            float? MaxHeight = null,
+            float? MinWidth = null,
+            float? MinHeight = null)
+        {
+            YogaNode node = new YogaNode();
+
+            if (styleDirection.HasValue)
+            {
+                node.StyleDirection = styleDirection.Value;
+            }
+
+            if (flexDirection.HasValue)
+            {
+                node.FlexDirection = flexDirection.Value;
+            }
+
+            if (justifyContent.HasValue)
+            {
+                node.JustifyContent = justifyContent.Value;
+            }
+
+            if (alignContent.HasValue)
+            {
+                node.AlignContent = alignContent.Value;
+            }
+
+            if (alignItems.HasValue)
+            {
+                node.AlignItems = alignItems.Value;
+            }
+
+            if (alignSelf.HasValue)
+            {
+                node.AlignSelf = alignSelf.Value;
+            }
+
+            if (positionType.HasValue)
+            {
+                node.PositionType = positionType.Value;
+            }
+
+            if (wrap.HasValue)
+            {
+                node.Wrap = wrap.Value;
+            }
+
+            if (overflow.HasValue)
+            {
+                node.Overflow = overflow.Value;
+            }
+
+            if (flex.HasValue)
+            {
+                node.Flex = flex.Value;
+            }
+
+            if (flexGrow.HasValue)
+            {
+                node.FlexGrow = flexGrow.Value;
+            }
+
+            if (flexShrink.HasValue)
+            {
+                node.FlexShrink = flexShrink.Value;
+            }
+
+            if (flexBasis.HasValue)
+            {
+                node.FlexBasis = flexBasis.Value;
+            }
+
+            if (position != null)
+            {
+                if (position.Top.HasValue)
+                {
+                    node.SetPosition(YogaEdge.Top, position.Top.Value);
+                }
+
+                if (position.Bottom.HasValue)
+                {
+                    node.SetPosition(YogaEdge.Bottom, position.Bottom.Value);
+                }
+
+                if (position.Left.HasValue)
+                {
+                    node.SetPosition(YogaEdge.Left, position.Left.Value);
+                }
+
+                if (position.Right.HasValue)
+                {
+                    node.SetPosition(YogaEdge.Right, position.Right.Value);
+                }
+            }
+
+            if (margin != null)
+            {
+                if (margin.Top.HasValue)
+                {
+                    node.SetMargin(YogaEdge.Top, margin.Top.Value);
+                }
+
+                if (margin.Bottom.HasValue)
+                {
+                    node.SetMargin(YogaEdge.Bottom, margin.Bottom.Value);
+                }
+
+                if (margin.Left.HasValue)
+                {
+                    node.SetMargin(YogaEdge.Left, margin.Left.Value);
+                }
+
+                if (margin.Right.HasValue)
+                {
+                    node.SetMargin(YogaEdge.Right, margin.Right.Value);
+                }
+            }
+
+            if (padding != null)
+            {
+                if (padding.Top.HasValue)
+                {
+                    node.SetPadding(YogaEdge.Top, padding.Top.Value);
+                }
+
+                if (padding.Bottom.HasValue)
+                {
+                    node.SetPadding(YogaEdge.Bottom, padding.Bottom.Value);
+                }
+
+                if (padding.Left.HasValue)
+                {
+                    node.SetPadding(YogaEdge.Left, padding.Left.Value);
+                }
+
+                if (padding.Right.HasValue)
+                {
+                    node.SetPadding(YogaEdge.Right, padding.Right.Value);
+                }
+            }
+
+            if (border != null)
+            {
+                if (border.Top.HasValue)
+                {
+                    node.SetBorder(YogaEdge.Top, border.Top.Value);
+                }
+
+                if (border.Bottom.HasValue)
+                {
+                    node.SetBorder(YogaEdge.Bottom, border.Bottom.Value);
+                }
+
+                if (border.Left.HasValue)
+                {
+                    node.SetBorder(YogaEdge.Left, border.Left.Value);
+                }
+
+                if (border.Right.HasValue)
+                {
+                    node.SetBorder(YogaEdge.Right, border.Right.Value);
+                }
+            }
+
+            if (Width.HasValue)
+            {
+                node.Width = Width.Value;
+            }
+
+            if (Height.HasValue)
+            {
+                node.Height = Height.Value;
+            }
+
+            if (MinWidth.HasValue)
+            {
+                node.MinWidth = MinWidth.Value;
+            }
+
+            if (MinHeight.HasValue)
+            {
+                node.MinHeight = MinHeight.Value;
+            }
+
+            if (MaxWidth.HasValue)
+            {
+                node.MaxWidth = MaxWidth.Value;
+            }
+
+            if (MaxHeight.HasValue)
+            {
+                node.MaxHeight = MaxHeight.Value;
+            }
+
+            return node;
+        }
+    }
+}

csharp/Facebook.Yoga/YogaNode.cs

@@ -0,0 +1,584 @@
+/**
+ * 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.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Facebook.Yoga
+{
+    public partial class YogaNode : IEnumerable<YogaNode>
+    {
+        private IntPtr _cssNode;
+        private WeakReference _parent;
+        private List<YogaNode> _children;
+        private MeasureFunction _measureFunction;
+        private YogaMeasureFunc _cssMeasureFunc;
+        private object _data;
+
+        public YogaNode()
+        {
+            YogaLogger.Initialize();
+
+            _cssNode = Native.CSSNodeNew();
+            if (_cssNode == IntPtr.Zero)
+            {
+                throw new InvalidOperationException("Failed to allocate native memory");
+            }
+        }
+
+        ~YogaNode()
+        {
+            Native.CSSNodeFree(_cssNode);
+        }
+
+        public void Reset()
+        {
+            _measureFunction = null;
+            _data = null;
+
+            Native.CSSNodeReset(_cssNode);
+        }
+
+        public bool IsDirty
+        {
+            get
+            {
+                return Native.CSSNodeIsDirty(_cssNode);
+            }
+        }
+
+        public virtual void MarkDirty()
+        {
+            Native.CSSNodeMarkDirty(_cssNode);
+        }
+
+        public bool HasNewLayout
+        {
+            get
+            {
+                return Native.CSSNodeGetHasNewLayout(_cssNode);
+            }
+        }
+
+        public void MarkHasNewLayout()
+        {
+            Native.CSSNodeSetHasNewLayout(_cssNode, true);
+        }
+
+        public YogaNode Parent
+        {
+            get
+            {
+                return _parent != null ? _parent.Target as YogaNode : null;
+            }
+        }
+
+        public bool IsMeasureDefined
+        {
+            get
+            {
+                return _measureFunction != null;
+            }
+        }
+
+        public void CopyStyle(YogaNode srcNode)
+        {
+            Native.CSSNodeCopyStyle(_cssNode, srcNode._cssNode);
+        }
+
+        public YogaDirection StyleDirection
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetDirection(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetDirection(_cssNode, value);
+            }
+        }
+
+        public YogaFlexDirection FlexDirection
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetFlexDirection(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetFlexDirection(_cssNode, value);
+            }
+        }
+
+        public YogaJustify JustifyContent
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetJustifyContent(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetJustifyContent(_cssNode, value);
+            }
+        }
+
+        public YogaAlign AlignItems
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetAlignItems(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetAlignItems(_cssNode, value);
+            }
+        }
+
+        public YogaAlign AlignSelf
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetAlignSelf(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetAlignSelf(_cssNode, value);
+            }
+        }
+
+        public YogaAlign AlignContent
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetAlignContent(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetAlignContent(_cssNode, value);
+            }
+        }
+
+        public YogaPositionType PositionType
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetPositionType(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetPositionType(_cssNode, value);
+            }
+        }
+
+        public YogaWrap Wrap
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetFlexWrap(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetFlexWrap(_cssNode, value);
+            }
+        }
+
+        public float Flex
+        {
+            set
+            {
+                Native.CSSNodeStyleSetFlex(_cssNode, value);
+            }
+        }
+
+        public float FlexGrow
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetFlexGrow(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetFlexGrow(_cssNode, value);
+            }
+        }
+
+        public float FlexShrink
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetFlexShrink(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetFlexShrink(_cssNode, value);
+            }
+        }
+
+        public float FlexBasis
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetFlexBasis(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetFlexBasis(_cssNode, value);
+            }
+        }
+
+        public float GetMargin(YogaEdge edge)
+        {
+            return Native.CSSNodeStyleGetMargin(_cssNode, edge);
+        }
+
+        public void SetMargin(YogaEdge edge, float value)
+        {
+            Native.CSSNodeStyleSetMargin(_cssNode, edge, value);
+        }
+
+        public float GetPadding(YogaEdge edge)
+        {
+            return Native.CSSNodeStyleGetPadding(_cssNode, edge);
+        }
+
+        public void SetPadding(YogaEdge edge, float padding)
+        {
+            Native.CSSNodeStyleSetPadding(_cssNode, edge, padding);
+        }
+
+        public float GetBorder(YogaEdge edge)
+        {
+            return Native.CSSNodeStyleGetBorder(_cssNode, edge);
+        }
+
+        public void SetBorder(YogaEdge edge, float border)
+        {
+            Native.CSSNodeStyleSetBorder(_cssNode, edge, border);
+        }
+
+        public float GetPosition(YogaEdge edge)
+        {
+            return Native.CSSNodeStyleGetPosition(_cssNode, edge);
+        }
+
+        public void SetPosition(YogaEdge edge, float position)
+        {
+            Native.CSSNodeStyleSetPosition(_cssNode, edge, position);
+        }
+
+        public float Width
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetWidth(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetWidth(_cssNode, value);
+            }
+        }
+
+        public float Height
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetHeight(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetHeight(_cssNode, value);
+            }
+        }
+
+        public float MaxWidth
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetMaxWidth(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetMaxWidth(_cssNode, value);
+            }
+        }
+
+        public float MaxHeight
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetMaxHeight(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetMaxHeight(_cssNode, value);
+            }
+        }
+
+        public float MinWidth
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetMinWidth(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetMinWidth(_cssNode, value);
+            }
+        }
+
+        public float MinHeight
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetMinHeight(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetMinHeight(_cssNode, value);
+            }
+        }
+
+        public float StyleAspectRatio
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetAspectRatio(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetAspectRatio(_cssNode, value);
+            }
+        }
+
+        public float LayoutX
+        {
+            get
+            {
+                return Native.CSSNodeLayoutGetLeft(_cssNode);
+            }
+        }
+
+        public float LayoutY
+        {
+            get
+            {
+                return Native.CSSNodeLayoutGetTop(_cssNode);
+            }
+        }
+
+        public float LayoutWidth
+        {
+            get
+            {
+                return Native.CSSNodeLayoutGetWidth(_cssNode);
+            }
+        }
+
+        public float LayoutHeight
+        {
+            get
+            {
+                return Native.CSSNodeLayoutGetHeight(_cssNode);
+            }
+        }
+
+        public YogaDirection LayoutDirection
+        {
+            get
+            {
+                return Native.CSSNodeLayoutGetDirection(_cssNode);
+            }
+        }
+
+        public YogaOverflow Overflow
+        {
+            get
+            {
+                return Native.CSSNodeStyleGetOverflow(_cssNode);
+            }
+
+            set
+            {
+                Native.CSSNodeStyleSetOverflow(_cssNode, value);
+            }
+        }
+
+        public object Data
+        {
+            get
+            {
+                return _data;
+            }
+
+            set
+            {
+                _data = value;
+            }
+        }
+
+        public YogaNode this[int index]
+        {
+            get
+            {
+                return _children[index];
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                return _children != null ? _children.Count : 0;
+            }
+        }
+
+        public void MarkLayoutSeen()
+        {
+            Native.CSSNodeSetHasNewLayout(_cssNode, false);
+        }
+
+        public bool ValuesEqual(float f1, float f2)
+        {
+            if (float.IsNaN(f1) || float.IsNaN(f2))
+            {
+                return float.IsNaN(f1) && float.IsNaN(f2);
+            }
+
+            return Math.Abs(f2 - f1) < float.Epsilon;
+        }
+
+        public void Insert(int index, YogaNode node)
+        {
+            if (_children == null)
+            {
+                _children = new List<YogaNode>(4);
+            }
+            _children.Insert(index, node);
+            node._parent = new WeakReference(this);
+            Native.CSSNodeInsertChild(_cssNode, node._cssNode, (uint)index);
+        }
+
+        public void RemoveAt(int index)
+        {
+            var child = _children[index];
+            child._parent = null;
+            _children.RemoveAt(index);
+            Native.CSSNodeRemoveChild(_cssNode, child._cssNode);
+        }
+
+        public void Clear()
+        {
+            if (_children != null)
+            {
+                while (_children.Count > 0)
+                {
+                    RemoveAt(_children.Count-1);
+                }
+            }
+        }
+
+        public int IndexOf(YogaNode node)
+        {
+            return _children != null ? _children.IndexOf(node) : -1;
+        }
+
+        public void SetMeasureFunction(MeasureFunction measureFunction)
+        {
+            _measureFunction = measureFunction;
+            _cssMeasureFunc = measureFunction != null ? MeasureInternal : (YogaMeasureFunc)null;
+            Native.CSSNodeSetMeasureFunc(_cssNode, _cssMeasureFunc);
+        }
+
+        public void CalculateLayout()
+        {
+            Native.CSSNodeCalculateLayout(
+                _cssNode,
+                YogaConstants.Undefined,
+                YogaConstants.Undefined,
+                Native.CSSNodeStyleGetDirection(_cssNode));
+        }
+
+        private YogaSize MeasureInternal(
+            IntPtr node,
+            float width,
+            YogaMeasureMode widthMode,
+            float height,
+            YogaMeasureMode heightMode)
+        {
+            if (_measureFunction == null)
+            {
+                throw new InvalidOperationException("Measure function is not defined.");
+            }
+
+            long output = _measureFunction(this, width, widthMode, height, heightMode);
+            return new YogaSize { width = MeasureOutput.GetWidth(output), height = MeasureOutput.GetHeight(output) };
+        }
+
+        public string Print(YogaPrintOptions options =
+            YogaPrintOptions.Layout|YogaPrintOptions.Style|YogaPrintOptions.Children)
+        {
+            StringBuilder sb = new StringBuilder();
+            YogaLogger.Func orig = YogaLogger.Logger;
+            YogaLogger.Logger = (level, message) => {sb.Append(message);};
+            Native.CSSNodePrint(_cssNode, options);
+            YogaLogger.Logger = orig;
+            return sb.ToString();
+        }
+
+        public IEnumerator<YogaNode> GetEnumerator()
+        {
+            return _children != null ? ((IEnumerable<YogaNode>)_children).GetEnumerator() :
+                System.Linq.Enumerable.Empty<YogaNode>().GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return _children != null ? ((IEnumerable<YogaNode>)_children).GetEnumerator() :
+                System.Linq.Enumerable.Empty<YogaNode>().GetEnumerator();
+        }
+
+        public static int GetInstanceCount()
+        {
+            return Native.CSSNodeGetInstanceCount();
+        }
+
+        public static void SetExperimentalFeatureEnabled(
+            YogaExperimentalFeature feature,
+            bool enabled)
+        {
+            Native.CSSLayoutSetExperimentalFeatureEnabled(feature, enabled);
+        }
+
+        public static bool IsExperimentalFeatureEnabled(YogaExperimentalFeature feature)
+        {
+            return Native.CSSLayoutIsExperimentalFeatureEnabled(feature);
+        }
+    }
+}

csharp/Facebook.Yoga/YogaOverflow.cs

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaOverflow
+    {
+        Visible,
+        Hidden,
+        Scroll,
+    }
+}

csharp/Facebook.Yoga/YogaPositionType.cs

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaPositionType
+    {
+        Relative,
+        Absolute,
+    }
+}

csharp/Facebook.Yoga/YogaPrintOptions.cs

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaPrintOptions
+    {
+        Layout = 1,
+        Style = 2,
+        Children = 4,
+    }
+}

csharp/Facebook.Yoga/YogaSize.cs

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+
+using System.Runtime.InteropServices;
+
+namespace Facebook.Yoga
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct YogaSize
+    {
+        public float width;
+        public float height;
+    }
+}

csharp/Facebook.Yoga/YogaWrap.cs

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+namespace Facebook.Yoga
+{
+    public enum YogaWrap
+    {
+        NoWrap,
+        Wrap,
+    }
+}

csharp/Facebook.Yoga/project.json

@@ -0,0 +1,14 @@
+{
+  "language": "en",
+  "version": "3.0.0-*",
+
+  "dependencies": {
+    "NETStandard.Library": "1.6.0"
+  },
+
+  "frameworks": {
+    "netstandard1.6": {
+      "imports": "dnxcore50"
+    }
+  }
+}