{-# LINE 1 "lib/Bindings/Yoga.hsc" #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE NoImplicitPrelude  #-}
{-# LANGUAGE StandaloneDeriving #-}
--------------------------------------------------------------------------------




--------------------------------------------------------------------------------

module Bindings.Yoga where

import Data.Data        (Data)
import Data.Typeable    (Typeable)
import Foreign.C.Types  (CFloat(..), CInt(..), CUInt(..))
import Foreign.Ptr      (FunPtr, Ptr, plusPtr)
import Foreign.Storable (Storable(..))

import Prelude (Eq, IO, Show)
import Prelude (($), return)
--------------------------------------------------------------------------------


{-# LINE 24 "lib/Bindings/Yoga.hsc" #-}

{-# LINE 25 "lib/Bindings/Yoga.hsc" #-}

{-# LINE 26 "lib/Bindings/Yoga.hsc" #-}
data C'YGSize = C'YGSize{
  c'YGSize'width :: CFloat,
  c'YGSize'height :: CFloat
} deriving (Eq,Show)
p'YGSize'width p = plusPtr p 0
p'YGSize'width :: Ptr (C'YGSize) -> Ptr (CFloat)
p'YGSize'height p = plusPtr p 4
p'YGSize'height :: Ptr (C'YGSize) -> Ptr (CFloat)
instance Storable C'YGSize where
  sizeOf _ = 8
  alignment _ = 4
  peek _p = do
    v0 <- peekByteOff _p 0
    v1 <- peekByteOff _p 4
    return $ C'YGSize v0 v1
  poke _p (C'YGSize v0 v1) = do
    pokeByteOff _p 0 v0
    pokeByteOff _p 4 v1
    return ()

{-# LINE 27 "lib/Bindings/Yoga.hsc" #-}
deriving instance Typeable C'YGSize

data C'YGNode = C'YGNode

{-# LINE 30 "lib/Bindings/Yoga.hsc" #-}
deriving instance Typeable C'YGNode
deriving instance Data     C'YGNode

type C'YGMeasureFunc = FunPtr (Ptr C'YGNode -> CFloat -> CInt -> CFloat -> CInt -> IO (Ptr C'YGSize))
foreign import ccall "wrapper" mk'YGMeasureFunc
  :: (Ptr C'YGNode -> CFloat -> CInt -> CFloat -> CInt -> IO (Ptr C'YGSize)) -> IO C'YGMeasureFunc
foreign import ccall "dynamic" mK'YGMeasureFunc
  :: C'YGMeasureFunc -> (Ptr C'YGNode -> CFloat -> CInt -> CFloat -> CInt -> IO (Ptr C'YGSize))

{-# LINE 34 "lib/Bindings/Yoga.hsc" #-}

type C'YGPrintFunc = FunPtr (Ptr C'YGNode -> IO ())
foreign import ccall "wrapper" mk'YGPrintFunc
  :: (Ptr C'YGNode -> IO ()) -> IO C'YGPrintFunc
foreign import ccall "dynamic" mK'YGPrintFunc
  :: C'YGPrintFunc -> (Ptr C'YGNode -> IO ())

{-# LINE 36 "lib/Bindings/Yoga.hsc" #-}
{--
typedef int (*YGLogger)(YGLogLevel level, const char *format, va_list args);
WIN_EXPORT void YGSetLogger(YGLogger logger);
WIN_EXPORT void YGLog(YGLogLevel level, const char *message, ...);

typedef void *(*YGMalloc)(size_t size);
typedef void *(*YGCalloc)(size_t count, size_t size);
typedef void *(*YGRealloc)(void *ptr, size_t size);
typedef void (*YGFree)(void *ptr);
WIN_EXPORT void
YGSetMemoryFuncs(YGMalloc ygmalloc, YGCalloc yccalloc, YGRealloc ygrealloc, YGFree ygfree);
-}

foreign import ccall "YGNodeNew" c'YGNodeNew
  :: IO (Ptr C'YGNode)
foreign import ccall "&YGNodeNew" p'YGNodeNew
  :: FunPtr (IO (Ptr C'YGNode))

{-# LINE 50 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeClone" c'YGNodeClone
  :: Ptr C'YGNode -> IO (Ptr C'YGNode)
foreign import ccall "&YGNodeClone" p'YGNodeClone
  :: FunPtr (Ptr C'YGNode -> IO (Ptr C'YGNode))

{-# LINE 51 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeFree" c'YGNodeFree
  :: Ptr C'YGNode -> IO ()
foreign import ccall "&YGNodeFree" p'YGNodeFree
  :: FunPtr (Ptr C'YGNode -> IO ())

{-# LINE 52 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeFreeRecursive" c'YGNodeFreeRecursive
  :: Ptr C'YGNode -> IO ()
foreign import ccall "&YGNodeFreeRecursive" p'YGNodeFreeRecursive
  :: FunPtr (Ptr C'YGNode -> IO ())

{-# LINE 53 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeReset" c'YGNodeReset
  :: Ptr C'YGNode -> IO ()
foreign import ccall "&YGNodeReset" p'YGNodeReset
  :: FunPtr (Ptr C'YGNode -> IO ())

{-# LINE 54 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeGetInstanceCount" c'YGNodeGetInstanceCount
  :: IO (CInt)
foreign import ccall "&YGNodeGetInstanceCount" p'YGNodeGetInstanceCount
  :: FunPtr (IO (CInt))

{-# LINE 55 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeInsertChild" c'YGNodeInsertChild
  :: Ptr C'YGNode -> Ptr C'YGNode -> CUInt -> IO ()
foreign import ccall "&YGNodeInsertChild" p'YGNodeInsertChild
  :: FunPtr (Ptr C'YGNode -> Ptr C'YGNode -> CUInt -> IO ())

{-# LINE 57 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeRemoveChild" c'YGNodeRemoveChild
  :: Ptr C'YGNode -> Ptr C'YGNode -> IO ()
foreign import ccall "&YGNodeRemoveChild" p'YGNodeRemoveChild
  :: FunPtr (Ptr C'YGNode -> Ptr C'YGNode -> IO ())

{-# LINE 58 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeRemoveAllChildren" c'YGNodeRemoveAllChildren
  :: Ptr C'YGNode -> IO ()
foreign import ccall "&YGNodeRemoveAllChildren" p'YGNodeRemoveAllChildren
  :: FunPtr (Ptr C'YGNode -> IO ())

{-# LINE 59 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeGetChild" c'YGNodeGetChild
  :: Ptr C'YGNode -> CUInt -> IO (Ptr C'YGNode)
foreign import ccall "&YGNodeGetChild" p'YGNodeGetChild
  :: FunPtr (Ptr C'YGNode -> CUInt -> IO (Ptr C'YGNode))

{-# LINE 60 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeGetParent" c'YGNodeGetParent
  :: Ptr C'YGNode -> IO (Ptr C'YGNode)
foreign import ccall "&YGNodeGetParent" p'YGNodeGetParent
  :: FunPtr (Ptr C'YGNode -> IO (Ptr C'YGNode))

{-# LINE 61 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeGetChildCount" c'YGNodeGetChildCount
  :: Ptr C'YGNode -> IO (CUInt)
foreign import ccall "&YGNodeGetChildCount" p'YGNodeGetChildCount
  :: FunPtr (Ptr C'YGNode -> IO (CUInt))

{-# LINE 62 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeCalculateLayout" c'YGNodeCalculateLayout
  :: Ptr C'YGNode -> CFloat -> CFloat -> CInt -> IO ()
foreign import ccall "&YGNodeCalculateLayout" p'YGNodeCalculateLayout
  :: FunPtr (Ptr C'YGNode -> CFloat -> CFloat -> CInt -> IO ())

{-# LINE 64 "lib/Bindings/Yoga.hsc" #-}

-- Mark a node as dirty. Only valid for nodes with a custom measure function
-- set.
-- YG knows when to mark all other nodes as dirty but because nodes with
-- measure functions
-- depends on information not known to YG they must perform this dirty
-- marking manually.

foreign import ccall "YGNodeMarkDirty" c'YGNodeMarkDirty
  :: Ptr C'YGNode -> IO ()
foreign import ccall "&YGNodeMarkDirty" p'YGNodeMarkDirty
  :: FunPtr (Ptr C'YGNode -> IO ())

{-# LINE 73 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeIsDirty" c'YGNodeIsDirty
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeIsDirty" p'YGNodeIsDirty
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 74 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodePrint" c'YGNodePrint
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodePrint" p'YGNodePrint
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 76 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeCanUseCachedMeasurement" c'YGNodeCanUseCachedMeasurement
  :: CInt -> CFloat -> CInt -> CFloat -> CInt -> CFloat -> CInt -> CFloat -> CFloat -> CFloat -> CFloat -> CFloat -> IO CInt
foreign import ccall "&YGNodeCanUseCachedMeasurement" p'YGNodeCanUseCachedMeasurement
  :: FunPtr (CInt -> CFloat -> CInt -> CFloat -> CInt -> CFloat -> CInt -> CFloat -> CFloat -> CFloat -> CFloat -> CFloat -> IO CInt)

{-# LINE 78 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeCopyStyle" c'YGNodeCopyStyle
  :: Ptr C'YGNode -> Ptr C'YGNode -> IO ()
foreign import ccall "&YGNodeCopyStyle" p'YGNodeCopyStyle
  :: FunPtr (Ptr C'YGNode -> Ptr C'YGNode -> IO ())

{-# LINE 80 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeSetContext" c'YGNodeSetContext
  :: Ptr C'YGNode -> Ptr () -> IO ()
foreign import ccall "&YGNodeSetContext" p'YGNodeSetContext
  :: FunPtr (Ptr C'YGNode -> Ptr () -> IO ())

{-# LINE 82 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeGetContext" c'YGNodeGetContext
  :: Ptr C'YGNode -> IO (Ptr ())
foreign import ccall "&YGNodeGetContext" p'YGNodeGetContext
  :: FunPtr (Ptr C'YGNode -> IO (Ptr ()))

{-# LINE 83 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeSetMeasureFunc" c'YGNodeSetMeasureFunc
  :: Ptr C'YGNode -> Ptr C'YGMeasureFunc -> IO ()
foreign import ccall "&YGNodeSetMeasureFunc" p'YGNodeSetMeasureFunc
  :: FunPtr (Ptr C'YGNode -> Ptr C'YGMeasureFunc -> IO ())

{-# LINE 85 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeGetMeasureFunc" c'YGNodeGetMeasureFunc
  :: Ptr C'YGNode -> IO (Ptr C'YGMeasureFunc)
foreign import ccall "&YGNodeGetMeasureFunc" p'YGNodeGetMeasureFunc
  :: FunPtr (Ptr C'YGNode -> IO (Ptr C'YGMeasureFunc))

{-# LINE 86 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeSetPrintFunc" c'YGNodeSetPrintFunc
  :: Ptr C'YGNode -> Ptr C'YGPrintFunc -> IO ()
foreign import ccall "&YGNodeSetPrintFunc" p'YGNodeSetPrintFunc
  :: FunPtr (Ptr C'YGNode -> Ptr C'YGPrintFunc -> IO ())

{-# LINE 88 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeGetPrintFunc" c'YGNodeGetPrintFunc
  :: Ptr C'YGNode -> IO (Ptr C'YGPrintFunc)
foreign import ccall "&YGNodeGetPrintFunc" p'YGNodeGetPrintFunc
  :: FunPtr (Ptr C'YGNode -> IO (Ptr C'YGPrintFunc))

{-# LINE 89 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeSetHasNewLayout" c'YGNodeSetHasNewLayout
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeSetHasNewLayout" p'YGNodeSetHasNewLayout
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 91 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeGetHasNewLayout" c'YGNodeGetHasNewLayout
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeGetHasNewLayout" p'YGNodeGetHasNewLayout
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 92 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetDirection" c'YGNodeStyleSetDirection
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetDirection" p'YGNodeStyleSetDirection
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 94 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetDirection" c'YGNodeStyleGetDirection
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetDirection" p'YGNodeStyleGetDirection
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 95 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetFlexDirection" c'YGNodeStyleSetFlexDirection
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetFlexDirection" p'YGNodeStyleSetFlexDirection
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 97 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetFlexDirection" c'YGNodeStyleGetFlexDirection
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetFlexDirection" p'YGNodeStyleGetFlexDirection
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 98 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetJustifyContent" c'YGNodeStyleSetJustifyContent
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetJustifyContent" p'YGNodeStyleSetJustifyContent
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 100 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetJustifyContent" c'YGNodeStyleGetJustifyContent
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetJustifyContent" p'YGNodeStyleGetJustifyContent
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 101 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetAlignContent" c'YGNodeStyleSetAlignContent
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetAlignContent" p'YGNodeStyleSetAlignContent
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 103 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetAlignContent" c'YGNodeStyleGetAlignContent
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetAlignContent" p'YGNodeStyleGetAlignContent
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 104 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetAlignItems" c'YGNodeStyleSetAlignItems
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetAlignItems" p'YGNodeStyleSetAlignItems
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 106 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetAlignItems" c'YGNodeStyleGetAlignItems
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetAlignItems" p'YGNodeStyleGetAlignItems
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 107 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetAlignSelf" c'YGNodeStyleSetAlignSelf
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetAlignSelf" p'YGNodeStyleSetAlignSelf
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 109 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetAlignSelf" c'YGNodeStyleGetAlignSelf
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetAlignSelf" p'YGNodeStyleGetAlignSelf
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 110 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetPositionType" c'YGNodeStyleSetPositionType
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetPositionType" p'YGNodeStyleSetPositionType
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 112 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetPositionType" c'YGNodeStyleGetPositionType
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetPositionType" p'YGNodeStyleGetPositionType
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 113 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetFlexWrap" c'YGNodeStyleSetFlexWrap
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetFlexWrap" p'YGNodeStyleSetFlexWrap
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 115 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetFlexWrap" c'YGNodeStyleGetFlexWrap
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetFlexWrap" p'YGNodeStyleGetFlexWrap
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 116 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetOverflow" c'YGNodeStyleSetOverflow
  :: Ptr C'YGNode -> CInt -> IO ()
foreign import ccall "&YGNodeStyleSetOverflow" p'YGNodeStyleSetOverflow
  :: FunPtr (Ptr C'YGNode -> CInt -> IO ())

{-# LINE 118 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetOverflow" c'YGNodeStyleGetOverflow
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeStyleGetOverflow" p'YGNodeStyleGetOverflow
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 119 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetFlex" c'YGNodeStyleSetFlex
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetFlex" p'YGNodeStyleSetFlex
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 121 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleSetFlexGrow" c'YGNodeStyleSetFlexGrow
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetFlexGrow" p'YGNodeStyleSetFlexGrow
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 122 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetFlexGrow" c'YGNodeStyleGetFlexGrow
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetFlexGrow" p'YGNodeStyleGetFlexGrow
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 123 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleSetFlexShrink" c'YGNodeStyleSetFlexShrink
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetFlexShrink" p'YGNodeStyleSetFlexShrink
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 124 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetFlexShrink" c'YGNodeStyleGetFlexShrink
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetFlexShrink" p'YGNodeStyleGetFlexShrink
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 125 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleSetFlexBasis" c'YGNodeStyleSetFlexBasis
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetFlexBasis" p'YGNodeStyleSetFlexBasis
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 126 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetFlexBasis" c'YGNodeStyleGetFlexBasis
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetFlexBasis" p'YGNodeStyleGetFlexBasis
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 127 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetPosition" c'YGNodeStyleSetPosition
  :: Ptr C'YGNode -> CInt -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetPosition" p'YGNodeStyleSetPosition
  :: FunPtr (Ptr C'YGNode -> CInt -> CFloat -> IO ())

{-# LINE 129 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetPosition" c'YGNodeStyleGetPosition
  :: Ptr C'YGNode -> CInt -> IO CFloat
foreign import ccall "&YGNodeStyleGetPosition" p'YGNodeStyleGetPosition
  :: FunPtr (Ptr C'YGNode -> CInt -> IO CFloat)

{-# LINE 130 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetMargin" c'YGNodeStyleSetMargin
  :: Ptr C'YGNode -> CInt -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetMargin" p'YGNodeStyleSetMargin
  :: FunPtr (Ptr C'YGNode -> CInt -> CFloat -> IO ())

{-# LINE 132 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetMargin" c'YGNodeStyleGetMargin
  :: Ptr C'YGNode -> CInt -> IO CFloat
foreign import ccall "&YGNodeStyleGetMargin" p'YGNodeStyleGetMargin
  :: FunPtr (Ptr C'YGNode -> CInt -> IO CFloat)

{-# LINE 133 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetPadding" c'YGNodeStyleSetPadding
  :: Ptr C'YGNode -> CInt -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetPadding" p'YGNodeStyleSetPadding
  :: FunPtr (Ptr C'YGNode -> CInt -> CFloat -> IO ())

{-# LINE 135 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetPadding" c'YGNodeStyleGetPadding
  :: Ptr C'YGNode -> CInt -> IO CFloat
foreign import ccall "&YGNodeStyleGetPadding" p'YGNodeStyleGetPadding
  :: FunPtr (Ptr C'YGNode -> CInt -> IO CFloat)

{-# LINE 136 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetBorder" c'YGNodeStyleSetBorder
  :: Ptr C'YGNode -> CInt -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetBorder" p'YGNodeStyleSetBorder
  :: FunPtr (Ptr C'YGNode -> CInt -> CFloat -> IO ())

{-# LINE 138 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetBorder" c'YGNodeStyleGetBorder
  :: Ptr C'YGNode -> CInt -> IO CFloat
foreign import ccall "&YGNodeStyleGetBorder" p'YGNodeStyleGetBorder
  :: FunPtr (Ptr C'YGNode -> CInt -> IO CFloat)

{-# LINE 139 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetWidth" c'YGNodeStyleSetWidth
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetWidth" p'YGNodeStyleSetWidth
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 141 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetWidth" c'YGNodeStyleGetWidth
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetWidth" p'YGNodeStyleGetWidth
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 142 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleSetHeight" c'YGNodeStyleSetHeight
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetHeight" p'YGNodeStyleSetHeight
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 143 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetHeight" c'YGNodeStyleGetHeight
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetHeight" p'YGNodeStyleGetHeight
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 144 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetMinWidth" c'YGNodeStyleSetMinWidth
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetMinWidth" p'YGNodeStyleSetMinWidth
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 146 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetMinWidth" c'YGNodeStyleGetMinWidth
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetMinWidth" p'YGNodeStyleGetMinWidth
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 147 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleSetMinHeight" c'YGNodeStyleSetMinHeight
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetMinHeight" p'YGNodeStyleSetMinHeight
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 148 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetMinHeight" c'YGNodeStyleGetMinHeight
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetMinHeight" p'YGNodeStyleGetMinHeight
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 149 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeStyleSetMaxWidth" c'YGNodeStyleSetMaxWidth
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetMaxWidth" p'YGNodeStyleSetMaxWidth
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 151 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetMaxWidth" c'YGNodeStyleGetMaxWidth
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetMaxWidth" p'YGNodeStyleGetMaxWidth
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 152 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleSetMaxHeight" c'YGNodeStyleSetMaxHeight
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetMaxHeight" p'YGNodeStyleSetMaxHeight
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 153 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetMaxHeight" c'YGNodeStyleGetMaxHeight
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetMaxHeight" p'YGNodeStyleGetMaxHeight
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 154 "lib/Bindings/Yoga.hsc" #-}

-- Yoga specific properties, not compatible with flexbox specification
-- Aspect ratio control the size of the undefined dimension of a node.
-- - 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
-- - On a node with a measure function aspect ratio works as though the measure function measures
-- the flex basis
-- - On a node with flex grow/shrink aspect ratio controls the size of the node in the cross axis if
-- unset
-- - Aspect ratio takes min/max dimensions into account
foreign import ccall "YGNodeStyleSetAspectRatio" c'YGNodeStyleSetAspectRatio
  :: Ptr C'YGNode -> CFloat -> IO ()
foreign import ccall "&YGNodeStyleSetAspectRatio" p'YGNodeStyleSetAspectRatio
  :: FunPtr (Ptr C'YGNode -> CFloat -> IO ())

{-# LINE 166 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeStyleGetAspectRatio" c'YGNodeStyleGetAspectRatio
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeStyleGetAspectRatio" p'YGNodeStyleGetAspectRatio
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 167 "lib/Bindings/Yoga.hsc" #-}

foreign import ccall "YGNodeLayoutGetLeft" c'YGNodeLayoutGetLeft
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeLayoutGetLeft" p'YGNodeLayoutGetLeft
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 169 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeLayoutGetTop" c'YGNodeLayoutGetTop
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeLayoutGetTop" p'YGNodeLayoutGetTop
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 170 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeLayoutGetRight" c'YGNodeLayoutGetRight
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeLayoutGetRight" p'YGNodeLayoutGetRight
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 171 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeLayoutGetBottom" c'YGNodeLayoutGetBottom
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeLayoutGetBottom" p'YGNodeLayoutGetBottom
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 172 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeLayoutGetWidth" c'YGNodeLayoutGetWidth
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeLayoutGetWidth" p'YGNodeLayoutGetWidth
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 173 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeLayoutGetHeight" c'YGNodeLayoutGetHeight
  :: Ptr C'YGNode -> IO CFloat
foreign import ccall "&YGNodeLayoutGetHeight" p'YGNodeLayoutGetHeight
  :: FunPtr (Ptr C'YGNode -> IO CFloat)

{-# LINE 174 "lib/Bindings/Yoga.hsc" #-}
foreign import ccall "YGNodeLayoutGetDirection" c'YGNodeLayoutGetDirection
  :: Ptr C'YGNode -> IO CInt
foreign import ccall "&YGNodeLayoutGetDirection" p'YGNodeLayoutGetDirection
  :: FunPtr (Ptr C'YGNode -> IO CInt)

{-# LINE 175 "lib/Bindings/Yoga.hsc" #-}