DaddyFrosty/yoga
1
0
Fork 0
Code Issues 96 Pull Requests 31 Actions Packages Projects Releases 33 Wiki Activity

Yoga.h: clean up const / extern

Browse Source 
Summary:
@public

Remove unnecessary `const` and `extern` specifiers from `Yoga.h`.

- Function declarations are `extern` by default
- The removed `const` specifiers for pass-by-valye parameters are only meaningful for the *definition* of functions, not for the declaration.
In this specific case, I found `const YGNodeRef` particularly confusing, as it is a `typedef` for a pointer type. `const` does not refer to the pointed-to object, but to the parameter itself, i.e. `const YGNodeRef` is `YGNode * const`, and not `const YGNode *`.

Reviewed By: SidharthGuglani

Differential Revision: D14999097

fbshipit-source-id: 8350870cb67f4a34722f796c4f4a2fc7dde41b99
This commit is contained in:
David Aurelio
2019-04-23 08:08:51 -07:00
committed by Facebook Github Bot
parent e9bb1efb03
commit e167642672
2 changed files with 166 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
yoga/Yoga.cpp
View File

@@ -473,7 +473,7 @@ static void YGNodeSetChildrenInternal(
} }
void YGNodeSetChildren( void YGNodeSetChildren(
YGNodeRef const owner, const YGNodeRef owner,
const YGNodeRef c[], const YGNodeRef c[],
const uint32_t count) { const uint32_t count) {
const YGVector children = {c, c + count}; const YGVector children = {c, c + count};

392
yoga/Yoga.h
View File

@@ -38,14 +38,13 @@ typedef YGSize (*YGMeasureFunc)(
YGMeasureMode widthMode, YGMeasureMode widthMode,
float height, float height,
YGMeasureMode heightMode); YGMeasureMode heightMode);
typedef float ( typedef float (*YGBaselineFunc)(YGNodeRef node, float width, float height);
*YGBaselineFunc)(YGNodeRef node, const float width, const float height);
typedef void (*YGDirtiedFunc)(YGNodeRef node); typedef void (*YGDirtiedFunc)(YGNodeRef node);
typedef void (*YGPrintFunc)(YGNodeRef node); typedef void (*YGPrintFunc)(YGNodeRef node);
typedef void (*YGNodeCleanupFunc)(YGNodeRef node); typedef void (*YGNodeCleanupFunc)(YGNodeRef node);
typedef int (*YGLogger)( typedef int (*YGLogger)(
const YGConfigRef config, YGConfigRef config,
const YGNodeRef node, YGNodeRef node,
YGLogLevel level, YGLogLevel level,
const char* format, const char* format,
va_list args); va_list args);
@@ -54,31 +53,31 @@ typedef YGNodeRef (
// YGNode // YGNode
WIN_EXPORT YGNodeRef YGNodeNew(void); WIN_EXPORT YGNodeRef YGNodeNew(void);
WIN_EXPORT YGNodeRef YGNodeNewWithConfig(const YGConfigRef config); WIN_EXPORT YGNodeRef YGNodeNewWithConfig(YGConfigRef config);
WIN_EXPORT YGNodeRef YGNodeClone(const YGNodeRef node); WIN_EXPORT YGNodeRef YGNodeClone(YGNodeRef node);
WIN_EXPORT void YGNodeFree(const YGNodeRef node); WIN_EXPORT void YGNodeFree(YGNodeRef node);
WIN_EXPORT void YGNodeFreeRecursiveWithCleanupFunc( WIN_EXPORT void YGNodeFreeRecursiveWithCleanupFunc(
const YGNodeRef node, YGNodeRef node,
YGNodeCleanupFunc cleanup); YGNodeCleanupFunc cleanup);
WIN_EXPORT void YGNodeFreeRecursive(const YGNodeRef node); WIN_EXPORT void YGNodeFreeRecursive(YGNodeRef node);
WIN_EXPORT void YGNodeReset(const YGNodeRef node); WIN_EXPORT void YGNodeReset(YGNodeRef node);
WIN_EXPORT int32_t YGNodeGetInstanceCount(void); WIN_EXPORT int32_t YGNodeGetInstanceCount(void);
WIN_EXPORT void YGNodeInsertChild( WIN_EXPORT void YGNodeInsertChild(
const YGNodeRef node, YGNodeRef node,
const YGNodeRef child, YGNodeRef child,
const uint32_t index); uint32_t index);
WIN_EXPORT void YGNodeRemoveChild(const YGNodeRef node, const YGNodeRef child); WIN_EXPORT void YGNodeRemoveChild(YGNodeRef node, YGNodeRef child);
WIN_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef node); WIN_EXPORT void YGNodeRemoveAllChildren(YGNodeRef node);
WIN_EXPORT YGNodeRef YGNodeGetChild(const YGNodeRef node, const uint32_t index); WIN_EXPORT YGNodeRef YGNodeGetChild(YGNodeRef node, uint32_t index);
WIN_EXPORT YGNodeRef YGNodeGetOwner(const YGNodeRef node); WIN_EXPORT YGNodeRef YGNodeGetOwner(YGNodeRef node);
WIN_EXPORT YGNodeRef YGNodeGetParent(const YGNodeRef node); WIN_EXPORT YGNodeRef YGNodeGetParent(YGNodeRef node);
WIN_EXPORT uint32_t YGNodeGetChildCount(const YGNodeRef node); WIN_EXPORT uint32_t YGNodeGetChildCount(YGNodeRef node);
WIN_EXPORT void YGNodeSetChildren( WIN_EXPORT void YGNodeSetChildren(
YGNodeRef const owner, YGNodeRef owner,
const YGNodeRef children[], const YGNodeRef children[],
const uint32_t count); uint32_t count);
WIN_EXPORT void YGNodeSetIsReferenceBaseline( WIN_EXPORT void YGNodeSetIsReferenceBaseline(
YGNodeRef node, YGNodeRef node,
@@ -87,10 +86,10 @@ WIN_EXPORT void YGNodeSetIsReferenceBaseline(
WIN_EXPORT bool YGNodeIsReferenceBaseline(YGNodeRef node); WIN_EXPORT bool YGNodeIsReferenceBaseline(YGNodeRef node);
WIN_EXPORT void YGNodeCalculateLayout( WIN_EXPORT void YGNodeCalculateLayout(
const YGNodeRef node, YGNodeRef node,
const float availableWidth, float availableWidth,
const float availableHeight, float availableHeight,
const YGDirection ownerDirection); YGDirection ownerDirection);
// Mark a node as dirty. Only valid for nodes with a custom measure function // Mark a node as dirty. Only valid for nodes with a custom measure function
// set. // set.
@@ -98,36 +97,34 @@ WIN_EXPORT void YGNodeCalculateLayout(
// Yoga knows when to mark all other nodes as dirty but because nodes with // Yoga knows when to mark all other nodes as dirty but because nodes with
// measure functions depend on information not known to Yoga they must perform // measure functions depend on information not known to Yoga they must perform
// this dirty marking manually. // this dirty marking manually.
WIN_EXPORT void YGNodeMarkDirty(const YGNodeRef node); WIN_EXPORT void YGNodeMarkDirty(YGNodeRef node);
// Marks the current node and all its descendants as dirty. // Marks the current node and all its descendants as dirty.
// //
// Intended to be used for Uoga benchmarks. Don't use in production, as calling // Intended to be used for Uoga benchmarks. Don't use in production, as calling
// `YGCalculateLayout` will cause the recalculation of each and every node. // `YGCalculateLayout` will cause the recalculation of each and every node.
WIN_EXPORT void YGNodeMarkDirtyAndPropogateToDescendants(const YGNodeRef node); WIN_EXPORT void YGNodeMarkDirtyAndPropogateToDescendants(YGNodeRef node);
WIN_EXPORT void YGNodePrint(const YGNodeRef node, const YGPrintOptions options); WIN_EXPORT void YGNodePrint(YGNodeRef node, YGPrintOptions options);
WIN_EXPORT bool YGFloatIsUndefined(const float value); WIN_EXPORT bool YGFloatIsUndefined(float value);
WIN_EXPORT bool YGNodeCanUseCachedMeasurement( WIN_EXPORT bool YGNodeCanUseCachedMeasurement(
const YGMeasureMode widthMode, YGMeasureMode widthMode,
const float width, float width,
const YGMeasureMode heightMode, YGMeasureMode heightMode,
const float height, float height,
const YGMeasureMode lastWidthMode, YGMeasureMode lastWidthMode,
const float lastWidth, float lastWidth,
const YGMeasureMode lastHeightMode, YGMeasureMode lastHeightMode,
const float lastHeight, float lastHeight,
const float lastComputedWidth, float lastComputedWidth,
const float lastComputedHeight, float lastComputedHeight,
const float marginRow, float marginRow,
const float marginColumn, float marginColumn,
const YGConfigRef config); YGConfigRef config);
WIN_EXPORT void YGNodeCopyStyle( WIN_EXPORT void YGNodeCopyStyle(YGNodeRef dstNode, YGNodeRef srcNode);
const YGNodeRef dstNode,
const YGNodeRef srcNode);
WIN_EXPORT void* YGNodeGetContext(YGNodeRef node); WIN_EXPORT void* YGNodeGetContext(YGNodeRef node);
WIN_EXPORT void YGNodeSetContext(YGNodeRef node, void* context); WIN_EXPORT void YGNodeSetContext(YGNodeRef node, void* context);
@@ -144,167 +141,116 @@ WIN_EXPORT void YGNodeSetHasNewLayout(YGNodeRef node, bool hasNewLayout);
YGNodeType YGNodeGetNodeType(YGNodeRef node); YGNodeType YGNodeGetNodeType(YGNodeRef node);
void YGNodeSetNodeType(YGNodeRef node, YGNodeType nodeType); void YGNodeSetNodeType(YGNodeRef node, YGNodeType nodeType);
WIN_EXPORT bool YGNodeIsDirty(YGNodeRef node); WIN_EXPORT bool YGNodeIsDirty(YGNodeRef node);
bool YGNodeLayoutGetDidUseLegacyFlag(const YGNodeRef node); bool YGNodeLayoutGetDidUseLegacyFlag(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetDirection( WIN_EXPORT void YGNodeStyleSetDirection(YGNodeRef node, YGDirection direction);
const YGNodeRef node, WIN_EXPORT YGDirection YGNodeStyleGetDirection(YGNodeRef node);
const YGDirection direction);
WIN_EXPORT YGDirection YGNodeStyleGetDirection(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetFlexDirection( WIN_EXPORT void YGNodeStyleSetFlexDirection(
const YGNodeRef node, YGNodeRef node,
const YGFlexDirection flexDirection); YGFlexDirection flexDirection);
WIN_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(const YGNodeRef node); WIN_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetJustifyContent( WIN_EXPORT void YGNodeStyleSetJustifyContent(
const YGNodeRef node, YGNodeRef node,
const YGJustify justifyContent); YGJustify justifyContent);
WIN_EXPORT YGJustify YGNodeStyleGetJustifyContent(const YGNodeRef node); WIN_EXPORT YGJustify YGNodeStyleGetJustifyContent(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetAlignContent( WIN_EXPORT void YGNodeStyleSetAlignContent(
const YGNodeRef node, YGNodeRef node,
const YGAlign alignContent); YGAlign alignContent);
WIN_EXPORT YGAlign YGNodeStyleGetAlignContent(const YGNodeRef node); WIN_EXPORT YGAlign YGNodeStyleGetAlignContent(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetAlignItems( WIN_EXPORT void YGNodeStyleSetAlignItems(YGNodeRef node, YGAlign alignItems);
const YGNodeRef node, WIN_EXPORT YGAlign YGNodeStyleGetAlignItems(YGNodeRef node);
const YGAlign alignItems);
WIN_EXPORT YGAlign YGNodeStyleGetAlignItems(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetAlignSelf( WIN_EXPORT void YGNodeStyleSetAlignSelf(YGNodeRef node, YGAlign alignSelf);
const YGNodeRef node, WIN_EXPORT YGAlign YGNodeStyleGetAlignSelf(YGNodeRef node);
const YGAlign alignSelf);
WIN_EXPORT YGAlign YGNodeStyleGetAlignSelf(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetPositionType( WIN_EXPORT void YGNodeStyleSetPositionType(
const YGNodeRef node, YGNodeRef node,
const YGPositionType positionType); YGPositionType positionType);
WIN_EXPORT YGPositionType YGNodeStyleGetPositionType(const YGNodeRef node); WIN_EXPORT YGPositionType YGNodeStyleGetPositionType(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetFlexWrap( WIN_EXPORT void YGNodeStyleSetFlexWrap(YGNodeRef node, YGWrap flexWrap);
const YGNodeRef node, WIN_EXPORT YGWrap YGNodeStyleGetFlexWrap(YGNodeRef node);
const YGWrap flexWrap);
WIN_EXPORT YGWrap YGNodeStyleGetFlexWrap(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetOverflow( WIN_EXPORT void YGNodeStyleSetOverflow(YGNodeRef node, YGOverflow overflow);
const YGNodeRef node, WIN_EXPORT YGOverflow YGNodeStyleGetOverflow(YGNodeRef node);
const YGOverflow overflow);
WIN_EXPORT YGOverflow YGNodeStyleGetOverflow(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetDisplay( WIN_EXPORT void YGNodeStyleSetDisplay(YGNodeRef node, YGDisplay display);
const YGNodeRef node, WIN_EXPORT YGDisplay YGNodeStyleGetDisplay(YGNodeRef node);
const YGDisplay display);
WIN_EXPORT YGDisplay YGNodeStyleGetDisplay(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetFlex(const YGNodeRef node, const float flex); WIN_EXPORT void YGNodeStyleSetFlex(YGNodeRef node, float flex);
WIN_EXPORT float YGNodeStyleGetFlex(const YGNodeRef node); WIN_EXPORT float YGNodeStyleGetFlex(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetFlexGrow( WIN_EXPORT void YGNodeStyleSetFlexGrow(YGNodeRef node, float flexGrow);
const YGNodeRef node, WIN_EXPORT float YGNodeStyleGetFlexGrow(YGNodeRef node);
const float flexGrow);
WIN_EXPORT float YGNodeStyleGetFlexGrow(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetFlexShrink( WIN_EXPORT void YGNodeStyleSetFlexShrink(YGNodeRef node, float flexShrink);
const YGNodeRef node, WIN_EXPORT float YGNodeStyleGetFlexShrink(YGNodeRef node);
const float flexShrink);
WIN_EXPORT float YGNodeStyleGetFlexShrink(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetFlexBasis( WIN_EXPORT void YGNodeStyleSetFlexBasis(YGNodeRef node, float flexBasis);
const YGNodeRef node, WIN_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis);
const float flexBasis); WIN_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetFlexBasisPercent( WIN_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeRef node);
const YGNodeRef node,
const float flexBasis);
WIN_EXPORT void YGNodeStyleSetFlexBasisAuto(const YGNodeRef node);
WIN_EXPORT YGValue YGNodeStyleGetFlexBasis(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetPosition( WIN_EXPORT void YGNodeStyleSetPosition(
const YGNodeRef node, YGNodeRef node,
const YGEdge edge, YGEdge edge,
const float position); float position);
WIN_EXPORT void YGNodeStyleSetPositionPercent( WIN_EXPORT void YGNodeStyleSetPositionPercent(
const YGNodeRef node, YGNodeRef node,
const YGEdge edge, YGEdge edge,
const float position); float position);
WIN_EXPORT YGValue WIN_EXPORT YGValue YGNodeStyleGetPosition(YGNodeRef node, YGEdge edge);
YGNodeStyleGetPosition(const YGNodeRef node, const YGEdge edge);
WIN_EXPORT void YGNodeStyleSetMargin( WIN_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin);
const YGNodeRef node,
const YGEdge edge,
const float margin);
WIN_EXPORT void YGNodeStyleSetMarginPercent( WIN_EXPORT void YGNodeStyleSetMarginPercent(
const YGNodeRef node, YGNodeRef node,
const YGEdge edge, YGEdge edge,
const float margin); float margin);
WIN_EXPORT void YGNodeStyleSetMarginAuto( WIN_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge);
const YGNodeRef node, WIN_EXPORT YGValue YGNodeStyleGetMargin(YGNodeRef node, YGEdge edge);
const YGEdge edge);
WIN_EXPORT YGValue
YGNodeStyleGetMargin(const YGNodeRef node, const YGEdge edge);
WIN_EXPORT void YGNodeStyleSetPadding( WIN_EXPORT void YGNodeStyleSetPadding(
const YGNodeRef node, YGNodeRef node,
const YGEdge edge, YGEdge edge,
const float padding); float padding);
WIN_EXPORT void YGNodeStyleSetPaddingPercent( WIN_EXPORT void YGNodeStyleSetPaddingPercent(
const YGNodeRef node, YGNodeRef node,
const YGEdge edge, YGEdge edge,
const float padding); float padding);
WIN_EXPORT YGValue WIN_EXPORT YGValue YGNodeStyleGetPadding(YGNodeRef node, YGEdge edge);
YGNodeStyleGetPadding(const YGNodeRef node, const YGEdge edge);
WIN_EXPORT void YGNodeStyleSetBorder( WIN_EXPORT void YGNodeStyleSetBorder(YGNodeRef node, YGEdge edge, float border);
const YGNodeRef node, WIN_EXPORT float YGNodeStyleGetBorder(YGNodeRef node, YGEdge edge);
const YGEdge edge,
const float border);
WIN_EXPORT float YGNodeStyleGetBorder(const YGNodeRef node, const YGEdge edge);
WIN_EXPORT void YGNodeStyleSetWidth(const YGNodeRef node, const float width); WIN_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float width);
WIN_EXPORT void YGNodeStyleSetWidthPercent( WIN_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float width);
const YGNodeRef node, WIN_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node);
const float width); WIN_EXPORT YGValue YGNodeStyleGetWidth(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetWidthAuto(const YGNodeRef node);
WIN_EXPORT YGValue YGNodeStyleGetWidth(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetHeight(const YGNodeRef node, const float height); WIN_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float height);
WIN_EXPORT void YGNodeStyleSetHeightPercent( WIN_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, float height);
const YGNodeRef node, WIN_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node);
const float height); WIN_EXPORT YGValue YGNodeStyleGetHeight(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetHeightAuto(const YGNodeRef node);
WIN_EXPORT YGValue YGNodeStyleGetHeight(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetMinWidth( WIN_EXPORT void YGNodeStyleSetMinWidth(YGNodeRef node, float minWidth);
const YGNodeRef node, WIN_EXPORT void YGNodeStyleSetMinWidthPercent(YGNodeRef node, float minWidth);
const float minWidth); WIN_EXPORT YGValue YGNodeStyleGetMinWidth(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetMinWidthPercent(
const YGNodeRef node,
const float minWidth);
WIN_EXPORT YGValue YGNodeStyleGetMinWidth(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetMinHeight( WIN_EXPORT void YGNodeStyleSetMinHeight(YGNodeRef node, float minHeight);
const YGNodeRef node, WIN_EXPORT void YGNodeStyleSetMinHeightPercent(YGNodeRef node, float minHeight);
const float minHeight); WIN_EXPORT YGValue YGNodeStyleGetMinHeight(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetMinHeightPercent(
const YGNodeRef node,
const float minHeight);
WIN_EXPORT YGValue YGNodeStyleGetMinHeight(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetMaxWidth( WIN_EXPORT void YGNodeStyleSetMaxWidth(YGNodeRef node, float maxWidth);
const YGNodeRef node, WIN_EXPORT void YGNodeStyleSetMaxWidthPercent(YGNodeRef node, float maxWidth);
const float maxWidth); WIN_EXPORT YGValue YGNodeStyleGetMaxWidth(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetMaxWidthPercent(
const YGNodeRef node,
const float maxWidth);
WIN_EXPORT YGValue YGNodeStyleGetMaxWidth(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetMaxHeight( WIN_EXPORT void YGNodeStyleSetMaxHeight(YGNodeRef node, float maxHeight);
const YGNodeRef node, WIN_EXPORT void YGNodeStyleSetMaxHeightPercent(YGNodeRef node, float maxHeight);
const float maxHeight); WIN_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeRef node);
WIN_EXPORT void YGNodeStyleSetMaxHeightPercent(
const YGNodeRef node,
const float maxHeight);
WIN_EXPORT YGValue YGNodeStyleGetMaxHeight(const YGNodeRef node);
// Yoga specific properties, not compatible with flexbox specification Aspect // Yoga specific properties, not compatible with flexbox specification Aspect
// ratio control the size of the undefined dimension of a node. Aspect ratio is // ratio control the size of the undefined dimension of a node. Aspect ratio is
@@ -321,49 +267,45 @@ WIN_EXPORT YGValue YGNodeStyleGetMaxHeight(const YGNodeRef node);
// - On a node with flex grow/shrink aspect ratio controls the size of the node // - On a node with flex grow/shrink aspect ratio controls the size of the node
// in the cross axis if unset // in the cross axis if unset
// - Aspect ratio takes min/max dimensions into account // - Aspect ratio takes min/max dimensions into account
WIN_EXPORT void YGNodeStyleSetAspectRatio( WIN_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, float aspectRatio);
const YGNodeRef node, WIN_EXPORT float YGNodeStyleGetAspectRatio(YGNodeRef node);
const float aspectRatio);
WIN_EXPORT float YGNodeStyleGetAspectRatio(const YGNodeRef node);
WIN_EXPORT float YGNodeLayoutGetLeft(const YGNodeRef node); WIN_EXPORT float YGNodeLayoutGetLeft(YGNodeRef node);
WIN_EXPORT float YGNodeLayoutGetTop(const YGNodeRef node); WIN_EXPORT float YGNodeLayoutGetTop(YGNodeRef node);
WIN_EXPORT float YGNodeLayoutGetRight(const YGNodeRef node); WIN_EXPORT float YGNodeLayoutGetRight(YGNodeRef node);
WIN_EXPORT float YGNodeLayoutGetBottom(const YGNodeRef node); WIN_EXPORT float YGNodeLayoutGetBottom(YGNodeRef node);
WIN_EXPORT float YGNodeLayoutGetWidth(const YGNodeRef node); WIN_EXPORT float YGNodeLayoutGetWidth(YGNodeRef node);
WIN_EXPORT float YGNodeLayoutGetHeight(const YGNodeRef node); WIN_EXPORT float YGNodeLayoutGetHeight(YGNodeRef node);
WIN_EXPORT YGDirection YGNodeLayoutGetDirection(const YGNodeRef node); WIN_EXPORT YGDirection YGNodeLayoutGetDirection(YGNodeRef node);
WIN_EXPORT bool YGNodeLayoutGetHadOverflow(const YGNodeRef node); WIN_EXPORT bool YGNodeLayoutGetHadOverflow(YGNodeRef node);
bool YGNodeLayoutGetDidLegacyStretchFlagAffectLayout(const YGNodeRef node); bool YGNodeLayoutGetDidLegacyStretchFlagAffectLayout(YGNodeRef node);
// Get the computed values for these nodes after performing layout. If they were // Get the computed values for these nodes after performing layout. If they were
// set using point values then the returned value will be the same as // set using point values then the returned value will be the same as
// YGNodeStyleGetXXX. However if they were set using a percentage value then the // YGNodeStyleGetXXX. However if they were set using a percentage value then the
// returned value is the computed value used during layout. // returned value is the computed value used during layout.
WIN_EXPORT float YGNodeLayoutGetMargin(const YGNodeRef node, const YGEdge edge); WIN_EXPORT float YGNodeLayoutGetMargin(YGNodeRef node, YGEdge edge);
WIN_EXPORT float YGNodeLayoutGetBorder(const YGNodeRef node, const YGEdge edge); WIN_EXPORT float YGNodeLayoutGetBorder(YGNodeRef node, YGEdge edge);
WIN_EXPORT float YGNodeLayoutGetPadding( WIN_EXPORT float YGNodeLayoutGetPadding(YGNodeRef node, YGEdge edge);
const YGNodeRef node,
const YGEdge edge);
WIN_EXPORT void YGConfigSetLogger(const YGConfigRef config, YGLogger logger); WIN_EXPORT void YGConfigSetLogger(YGConfigRef config, YGLogger logger);
WIN_EXPORT void YGAssert(const bool condition, const char* message); WIN_EXPORT void YGAssert(bool condition, const char* message);
WIN_EXPORT void YGAssertWithNode( WIN_EXPORT void YGAssertWithNode(
const YGNodeRef node, YGNodeRef node,
const bool condition, bool condition,
const char* message); const char* message);
WIN_EXPORT void YGAssertWithConfig( WIN_EXPORT void YGAssertWithConfig(
const YGConfigRef config, YGConfigRef config,
const bool condition, bool condition,
const char* message); const char* message);
// Set this to number of pixels in 1 point to round calculation results If you // Set this to number of pixels in 1 point to round calculation results If you
// want to avoid rounding - set PointScaleFactor to 0 // want to avoid rounding - set PointScaleFactor to 0
WIN_EXPORT void YGConfigSetPointScaleFactor( WIN_EXPORT void YGConfigSetPointScaleFactor(
const YGConfigRef config, YGConfigRef config,
const float pixelsInPoint); float pixelsInPoint);
void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour( void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
const YGConfigRef config, YGConfigRef config,
const bool shouldDiffLayout); bool shouldDiffLayout);
// Yoga previously had an error where containers would take the maximum space // Yoga previously had an error where containers would take the maximum space
// possible instead of the minimum like they are supposed to. In practice this // possible instead of the minimum like they are supposed to. In practice this
@@ -371,45 +313,43 @@ void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
// was such a long-standing bug we must allow legacy users to switch back to // was such a long-standing bug we must allow legacy users to switch back to
// this behaviour. // this behaviour.
WIN_EXPORT void YGConfigSetUseLegacyStretchBehaviour( WIN_EXPORT void YGConfigSetUseLegacyStretchBehaviour(
const YGConfigRef config, YGConfigRef config,
const bool useLegacyStretchBehaviour); bool useLegacyStretchBehaviour);
// YGConfig // YGConfig
WIN_EXPORT YGConfigRef YGConfigNew(void); WIN_EXPORT YGConfigRef YGConfigNew(void);
WIN_EXPORT void YGConfigFree(const YGConfigRef config); WIN_EXPORT void YGConfigFree(YGConfigRef config);
WIN_EXPORT void YGConfigCopy(const YGConfigRef dest, const YGConfigRef src); WIN_EXPORT void YGConfigCopy(YGConfigRef dest, YGConfigRef src);
WIN_EXPORT int32_t YGConfigGetInstanceCount(void); WIN_EXPORT int32_t YGConfigGetInstanceCount(void);
WIN_EXPORT void YGConfigSetExperimentalFeatureEnabled( WIN_EXPORT void YGConfigSetExperimentalFeatureEnabled(
const YGConfigRef config, YGConfigRef config,
const YGExperimentalFeature feature, YGExperimentalFeature feature,
const bool enabled); bool enabled);
WIN_EXPORT bool YGConfigIsExperimentalFeatureEnabled( WIN_EXPORT bool YGConfigIsExperimentalFeatureEnabled(
const YGConfigRef config, YGConfigRef config,
const YGExperimentalFeature feature); YGExperimentalFeature feature);
// Using the web defaults is the prefered configuration for new projects. Usage // Using the web defaults is the prefered configuration for new projects. Usage
// of non web defaults should be considered as legacy. // of non web defaults should be considered as legacy.
WIN_EXPORT void YGConfigSetUseWebDefaults( WIN_EXPORT void YGConfigSetUseWebDefaults(YGConfigRef config, bool enabled);
const YGConfigRef config, WIN_EXPORT bool YGConfigGetUseWebDefaults(YGConfigRef config);
const bool enabled);
WIN_EXPORT bool YGConfigGetUseWebDefaults(const YGConfigRef config);
WIN_EXPORT void YGConfigSetCloneNodeFunc( WIN_EXPORT void YGConfigSetCloneNodeFunc(
const YGConfigRef config, YGConfigRef config,
const YGCloneNodeFunc callback); YGCloneNodeFunc callback);
// Export only for C# // Export only for C#
WIN_EXPORT YGConfigRef YGConfigGetDefault(void); WIN_EXPORT YGConfigRef YGConfigGetDefault(void);
WIN_EXPORT void YGConfigSetContext(const YGConfigRef config, void* context); WIN_EXPORT void YGConfigSetContext(YGConfigRef config, void* context);
WIN_EXPORT void* YGConfigGetContext(const YGConfigRef config); WIN_EXPORT void* YGConfigGetContext(YGConfigRef config);
WIN_EXPORT float YGRoundValueToPixelGrid( WIN_EXPORT float YGRoundValueToPixelGrid(
const float value, float value,
const float pointScaleFactor, float pointScaleFactor,
const bool forceCeil, bool forceCeil,
const bool forceFloor); bool forceFloor);
YG_EXTERN_C_END YG_EXTERN_C_END
@@ -419,12 +359,10 @@ YG_EXTERN_C_END
#include <vector> #include <vector>
// Calls f on each node in the tree including the given node argument. // Calls f on each node in the tree including the given node argument.
extern void YGTraversePreOrder( void YGTraversePreOrder(
YGNodeRef const node, YGNodeRef node,
std::function<void(YGNodeRef node)>&& f); std::function<void(YGNodeRef node)>&& f);
extern void YGNodeSetChildren( void YGNodeSetChildren(YGNodeRef owner, const std::vector<YGNodeRef>& children);
YGNodeRef const owner,
const std::vector<YGNodeRef>& children);
#endif #endif