2019-06-06 19:36:56 -07:00
|
|
|
/*
|
2021-12-30 15:08:43 -08:00
|
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
2016-12-03 04:40:18 -08:00
|
|
|
*
|
2019-10-15 10:30:08 -07:00
|
|
|
* This source code is licensed under the MIT license found in the
|
|
|
|
|
* LICENSE file in the root directory of this source tree.
|
2016-12-03 04:40:18 -08:00
|
|
|
*/
|
2019-10-15 10:30:08 -07:00
|
|
|
|
2016-12-03 04:40:18 -08:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
#include <stdbool.h>
|
2023-09-11 19:51:40 -07:00
|
|
|
#include <stddef.h>
|
C++ Cleanup 9/N: YGAssert (#1353)
Summary:
X-link: https://github.com/facebook/react-native/pull/39201
Pull Request resolved: https://github.com/facebook/yoga/pull/1353
## This diff
This moves and renames `YGAssert`, and removes it from the public API, since external users should not need to call into internal Yoga assert functions, and the current API prevents us from making this a macro later to include the condition in the message.
## This stack
The organization of the C++ internals of Yoga are in need of attention.
1. Some of the C++ internals are namespaced, but others not.
2. Some of the namespaces include `detail`, but are meant to be used outside of the translation unit (FB Clang Tidy rules warn on any usage of these)
2. Most of the files are in a flat hierarchy, except for event tracing in its own folder
3. Some files and functions begin with YG, others don’t
4. Some functions are uppercase, others are not
5. Almost all of the interesting logic is in Yoga.cpp, and the file is too large to reason about
6. There are multiple grab bag files where folks put random functions they need in (Utils, BitUtils, Yoga-Internal.h)
7. There is no clear indication from file structure or type naming what is private vs not
8. Handles like `YGNodeRef` and `YGConfigRef` can be used to access internals just by importing headers
This stack does some much needed spring cleaning:
1. All non-public headers and C++ implementation details are in separate folders from the root level `yoga`. This will give us room to split up logic and add more files without too large a flat hierarchy
3. All private C++ internals are under the `facebook::yoga` namespace. Details namespaces are only ever used within the same header, as they are intended
4. Utils files are split
5. Most C++ internals drop the YG prefix
6. Most C++ internal function names are all lower camel case
7. We start to split up Yoga.cpp
8. Every header beginning with YG or at the top-level directory is public and C only, with the exception of Yoga-Internal.h which has non-public functions for bindings
9. It is not possible to use private APIs without static casting handles to internal classes
This will give us more leeway to continue splitting monolithic files, and consistent guidelines for style in new files as well.
These changes should not be breaking to any project using only public Yoga headers. This includes every usage of Yoga in fbsource except for RN Fabric which is currently tied to internals. This refactor should make that boundary clearer.
Reviewed By: rshest
Differential Revision: D48769809
fbshipit-source-id: b5480ac54781bc01b00c158b07d2d751fac87d37
2023-09-04 11:20:17 -07:00
|
|
|
#include <stdint.h>
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2023-05-04 00:41:12 -07:00
|
|
|
#include <yoga/YGEnums.h>
|
|
|
|
|
#include <yoga/YGMacros.h>
|
|
|
|
|
#include <yoga/YGValue.h>
|
2016-12-03 04:40:18 -08:00
|
|
|
|
|
|
|
|
YG_EXTERN_C_BEGIN
|
|
|
|
|
|
|
|
|
|
typedef struct YGSize {
|
|
|
|
|
float width;
|
|
|
|
|
float height;
|
|
|
|
|
} YGSize;
|
|
|
|
|
|
2018-07-19 09:57:04 -07:00
|
|
|
typedef struct YGConfig* YGConfigRef;
|
2023-09-11 19:51:40 -07:00
|
|
|
typedef const struct YGConfig* YGConfigConstRef;
|
2017-12-19 11:18:00 -08:00
|
|
|
|
|
|
|
|
typedef struct YGNode* YGNodeRef;
|
2019-04-23 10:07:09 -07:00
|
|
|
typedef const struct YGNode* YGNodeConstRef;
|
2017-12-19 11:18:00 -08:00
|
|
|
|
2018-07-19 09:57:04 -07:00
|
|
|
typedef YGSize (*YGMeasureFunc)(
|
2023-09-11 19:51:40 -07:00
|
|
|
YGNodeConstRef node,
|
2018-07-19 09:57:04 -07:00
|
|
|
float width,
|
|
|
|
|
YGMeasureMode widthMode,
|
|
|
|
|
float height,
|
|
|
|
|
YGMeasureMode heightMode);
|
2023-09-11 19:51:40 -07:00
|
|
|
typedef float (*YGBaselineFunc)(YGNodeConstRef node, float width, float height);
|
|
|
|
|
typedef void (*YGDirtiedFunc)(YGNodeConstRef node);
|
|
|
|
|
typedef void (*YGPrintFunc)(YGNodeConstRef node);
|
|
|
|
|
typedef void (*YGNodeCleanupFunc)(YGNodeConstRef node);
|
2018-07-19 09:57:04 -07:00
|
|
|
typedef int (*YGLogger)(
|
2023-09-11 19:51:40 -07:00
|
|
|
YGConfigConstRef config,
|
|
|
|
|
YGNodeConstRef node,
|
2018-07-19 09:57:04 -07:00
|
|
|
YGLogLevel level,
|
|
|
|
|
const char* format,
|
|
|
|
|
va_list args);
|
2023-09-11 19:51:40 -07:00
|
|
|
typedef YGNodeRef (*YGCloneNodeFunc)(
|
|
|
|
|
YGNodeConstRef oldNode,
|
|
|
|
|
YGNodeConstRef owner,
|
2023-09-11 19:51:40 -07:00
|
|
|
size_t childIndex);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
|
|
|
|
// YGNode
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGNodeRef YGNodeNew(void);
|
|
|
|
|
YG_EXPORT YGNodeRef YGNodeNewWithConfig(YGConfigConstRef config);
|
|
|
|
|
YG_EXPORT YGNodeRef YGNodeClone(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT void YGNodeFree(YGNodeRef node);
|
|
|
|
|
YG_EXPORT void YGNodeFreeRecursiveWithCleanupFunc(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGNodeRef node,
|
2018-11-26 16:00:37 -08:00
|
|
|
YGNodeCleanupFunc cleanup);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeFreeRecursive(YGNodeRef node);
|
|
|
|
|
YG_EXPORT void YGNodeReset(YGNodeRef node);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeInsertChild(YGNodeRef node, YGNodeRef child, size_t index);
|
|
|
|
|
|
|
|
|
|
YG_EXPORT void YGNodeSwapChild(YGNodeRef node, YGNodeRef child, size_t index);
|
|
|
|
|
|
|
|
|
|
YG_EXPORT void YGNodeRemoveChild(YGNodeRef node, YGNodeRef child);
|
|
|
|
|
YG_EXPORT void YGNodeRemoveAllChildren(YGNodeRef node);
|
|
|
|
|
YG_EXPORT YGNodeRef YGNodeGetChild(YGNodeRef node, size_t index);
|
|
|
|
|
YG_EXPORT YGNodeRef YGNodeGetOwner(YGNodeRef node);
|
|
|
|
|
YG_EXPORT YGNodeRef YGNodeGetParent(YGNodeRef node);
|
|
|
|
|
YG_EXPORT size_t YGNodeGetChildCount(YGNodeConstRef node);
|
2023-09-13 20:12:55 -07:00
|
|
|
YG_EXPORT void
|
|
|
|
|
YGNodeSetChildren(YGNodeRef owner, const YGNodeRef* children, size_t count);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeSetIsReferenceBaseline(
|
2018-11-14 02:49:27 -08:00
|
|
|
YGNodeRef node,
|
|
|
|
|
bool isReferenceBaseline);
|
|
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT bool YGNodeIsReferenceBaseline(YGNodeConstRef node);
|
2018-11-14 02:49:27 -08:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeCalculateLayout(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGNodeRef node,
|
|
|
|
|
float availableWidth,
|
|
|
|
|
float availableHeight,
|
|
|
|
|
YGDirection ownerDirection);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
|
|
|
|
// Mark a node as dirty. Only valid for nodes with a custom measure function
|
|
|
|
|
// set.
|
2019-01-16 08:39:58 -08:00
|
|
|
//
|
|
|
|
|
// 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
|
|
|
|
|
// this dirty marking manually.
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeMarkDirty(YGNodeRef node);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2019-01-16 08:39:58 -08:00
|
|
|
// Marks the current node and all its descendants as dirty.
|
|
|
|
|
//
|
2021-03-15 16:53:05 -07:00
|
|
|
// Intended to be used for Yoga benchmarks. Don't use in production, as calling
|
2019-01-16 08:39:58 -08:00
|
|
|
// `YGCalculateLayout` will cause the recalculation of each and every node.
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeMarkDirtyAndPropagateToDescendants(YGNodeRef node);
|
2018-02-08 04:51:12 -08:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodePrint(YGNodeConstRef node, YGPrintOptions options);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT bool YGFloatIsUndefined(float value);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
C++ Cleanup 10/N: YGNodeCalculateLayout (#1352)
Summary:
X-link: https://github.com/facebook/react-native/pull/39195
Pull Request resolved: https://github.com/facebook/yoga/pull/1352
## This diff
This splits out all of the logic under `YGNodeCalculateLayout` to a couple of different files, does some mechanical renaming, and starts to split up the implementation a tiny bit. After this, core layout functions are all C++ convention and namespaced.
Each new file is marked as a move for the sake of blame history. It means Phabricator has a very inaccurate count of lines removed though.
## This stack
The organization of the C++ internals of Yoga are in need of attention.
1. Some of the C++ internals are namespaced, but others not.
2. Some of the namespaces include `detail`, but are meant to be used outside of the translation unit (FB Clang Tidy rules warn on any usage of these)
2. Most of the files are in a flat hierarchy, except for event tracing in its own folder
3. Some files and functions begin with YG, others don’t
4. Some functions are uppercase, others are not
5. Almost all of the interesting logic is in Yoga.cpp, and the file is too large to reason about
6. There are multiple grab bag files where folks put random functions they need in (Utils, BitUtils, Yoga-Internal.h)
7. There is no clear indication from file structure or type naming what is private vs not
8. Handles like `YGNodeRef` and `YGConfigRef` can be used to access internals just by importing headers
This stack does some much needed spring cleaning:
1. All non-public headers and C++ implementation details are in separate folders from the root level `yoga`. This will give us room to split up logic and add more files without too large a flat hierarchy
3. All private C++ internals are under the `facebook::yoga` namespace. Details namespaces are only ever used within the same header, as they are intended
4. Utils files are split
5. Most C++ internals drop the YG prefix
6. Most C++ internal function names are all lower camel case
7. We start to split up Yoga.cpp
8. Every header beginning with YG or at the top-level directory is public and C only, with the exception of Yoga-Internal.h which has non-public functions for bindings
9. It is not possible to use private APIs without static casting handles to internal classes
This will give us more leeway to continue splitting monolithic files, and consistent guidelines for style in new files as well.
These changes should not be breaking to any project using only public Yoga headers. This includes every usage of Yoga in fbsource except for RN Fabric which is currently tied to internals. This refactor should make that boundary clearer.
Reviewed By: rshest
Differential Revision: D48770478
fbshipit-source-id: 2a74b86441c3352de03ae193c98fc3a3573047ed
2023-09-05 05:24:54 -07:00
|
|
|
// TODO: This should not be part of the public API. Remove after removing
|
|
|
|
|
// ComponentKit usage of it.
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT bool YGNodeCanUseCachedMeasurement(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGMeasureMode widthMode,
|
C++ Cleanup 10/N: YGNodeCalculateLayout (#1352)
Summary:
X-link: https://github.com/facebook/react-native/pull/39195
Pull Request resolved: https://github.com/facebook/yoga/pull/1352
## This diff
This splits out all of the logic under `YGNodeCalculateLayout` to a couple of different files, does some mechanical renaming, and starts to split up the implementation a tiny bit. After this, core layout functions are all C++ convention and namespaced.
Each new file is marked as a move for the sake of blame history. It means Phabricator has a very inaccurate count of lines removed though.
## This stack
The organization of the C++ internals of Yoga are in need of attention.
1. Some of the C++ internals are namespaced, but others not.
2. Some of the namespaces include `detail`, but are meant to be used outside of the translation unit (FB Clang Tidy rules warn on any usage of these)
2. Most of the files are in a flat hierarchy, except for event tracing in its own folder
3. Some files and functions begin with YG, others don’t
4. Some functions are uppercase, others are not
5. Almost all of the interesting logic is in Yoga.cpp, and the file is too large to reason about
6. There are multiple grab bag files where folks put random functions they need in (Utils, BitUtils, Yoga-Internal.h)
7. There is no clear indication from file structure or type naming what is private vs not
8. Handles like `YGNodeRef` and `YGConfigRef` can be used to access internals just by importing headers
This stack does some much needed spring cleaning:
1. All non-public headers and C++ implementation details are in separate folders from the root level `yoga`. This will give us room to split up logic and add more files without too large a flat hierarchy
3. All private C++ internals are under the `facebook::yoga` namespace. Details namespaces are only ever used within the same header, as they are intended
4. Utils files are split
5. Most C++ internals drop the YG prefix
6. Most C++ internal function names are all lower camel case
7. We start to split up Yoga.cpp
8. Every header beginning with YG or at the top-level directory is public and C only, with the exception of Yoga-Internal.h which has non-public functions for bindings
9. It is not possible to use private APIs without static casting handles to internal classes
This will give us more leeway to continue splitting monolithic files, and consistent guidelines for style in new files as well.
These changes should not be breaking to any project using only public Yoga headers. This includes every usage of Yoga in fbsource except for RN Fabric which is currently tied to internals. This refactor should make that boundary clearer.
Reviewed By: rshest
Differential Revision: D48770478
fbshipit-source-id: 2a74b86441c3352de03ae193c98fc3a3573047ed
2023-09-05 05:24:54 -07:00
|
|
|
float availableWidth,
|
2019-04-23 08:08:51 -07:00
|
|
|
YGMeasureMode heightMode,
|
C++ Cleanup 10/N: YGNodeCalculateLayout (#1352)
Summary:
X-link: https://github.com/facebook/react-native/pull/39195
Pull Request resolved: https://github.com/facebook/yoga/pull/1352
## This diff
This splits out all of the logic under `YGNodeCalculateLayout` to a couple of different files, does some mechanical renaming, and starts to split up the implementation a tiny bit. After this, core layout functions are all C++ convention and namespaced.
Each new file is marked as a move for the sake of blame history. It means Phabricator has a very inaccurate count of lines removed though.
## This stack
The organization of the C++ internals of Yoga are in need of attention.
1. Some of the C++ internals are namespaced, but others not.
2. Some of the namespaces include `detail`, but are meant to be used outside of the translation unit (FB Clang Tidy rules warn on any usage of these)
2. Most of the files are in a flat hierarchy, except for event tracing in its own folder
3. Some files and functions begin with YG, others don’t
4. Some functions are uppercase, others are not
5. Almost all of the interesting logic is in Yoga.cpp, and the file is too large to reason about
6. There are multiple grab bag files where folks put random functions they need in (Utils, BitUtils, Yoga-Internal.h)
7. There is no clear indication from file structure or type naming what is private vs not
8. Handles like `YGNodeRef` and `YGConfigRef` can be used to access internals just by importing headers
This stack does some much needed spring cleaning:
1. All non-public headers and C++ implementation details are in separate folders from the root level `yoga`. This will give us room to split up logic and add more files without too large a flat hierarchy
3. All private C++ internals are under the `facebook::yoga` namespace. Details namespaces are only ever used within the same header, as they are intended
4. Utils files are split
5. Most C++ internals drop the YG prefix
6. Most C++ internal function names are all lower camel case
7. We start to split up Yoga.cpp
8. Every header beginning with YG or at the top-level directory is public and C only, with the exception of Yoga-Internal.h which has non-public functions for bindings
9. It is not possible to use private APIs without static casting handles to internal classes
This will give us more leeway to continue splitting monolithic files, and consistent guidelines for style in new files as well.
These changes should not be breaking to any project using only public Yoga headers. This includes every usage of Yoga in fbsource except for RN Fabric which is currently tied to internals. This refactor should make that boundary clearer.
Reviewed By: rshest
Differential Revision: D48770478
fbshipit-source-id: 2a74b86441c3352de03ae193c98fc3a3573047ed
2023-09-05 05:24:54 -07:00
|
|
|
float availableHeight,
|
2019-04-23 08:08:51 -07:00
|
|
|
YGMeasureMode lastWidthMode,
|
C++ Cleanup 10/N: YGNodeCalculateLayout (#1352)
Summary:
X-link: https://github.com/facebook/react-native/pull/39195
Pull Request resolved: https://github.com/facebook/yoga/pull/1352
## This diff
This splits out all of the logic under `YGNodeCalculateLayout` to a couple of different files, does some mechanical renaming, and starts to split up the implementation a tiny bit. After this, core layout functions are all C++ convention and namespaced.
Each new file is marked as a move for the sake of blame history. It means Phabricator has a very inaccurate count of lines removed though.
## This stack
The organization of the C++ internals of Yoga are in need of attention.
1. Some of the C++ internals are namespaced, but others not.
2. Some of the namespaces include `detail`, but are meant to be used outside of the translation unit (FB Clang Tidy rules warn on any usage of these)
2. Most of the files are in a flat hierarchy, except for event tracing in its own folder
3. Some files and functions begin with YG, others don’t
4. Some functions are uppercase, others are not
5. Almost all of the interesting logic is in Yoga.cpp, and the file is too large to reason about
6. There are multiple grab bag files where folks put random functions they need in (Utils, BitUtils, Yoga-Internal.h)
7. There is no clear indication from file structure or type naming what is private vs not
8. Handles like `YGNodeRef` and `YGConfigRef` can be used to access internals just by importing headers
This stack does some much needed spring cleaning:
1. All non-public headers and C++ implementation details are in separate folders from the root level `yoga`. This will give us room to split up logic and add more files without too large a flat hierarchy
3. All private C++ internals are under the `facebook::yoga` namespace. Details namespaces are only ever used within the same header, as they are intended
4. Utils files are split
5. Most C++ internals drop the YG prefix
6. Most C++ internal function names are all lower camel case
7. We start to split up Yoga.cpp
8. Every header beginning with YG or at the top-level directory is public and C only, with the exception of Yoga-Internal.h which has non-public functions for bindings
9. It is not possible to use private APIs without static casting handles to internal classes
This will give us more leeway to continue splitting monolithic files, and consistent guidelines for style in new files as well.
These changes should not be breaking to any project using only public Yoga headers. This includes every usage of Yoga in fbsource except for RN Fabric which is currently tied to internals. This refactor should make that boundary clearer.
Reviewed By: rshest
Differential Revision: D48770478
fbshipit-source-id: 2a74b86441c3352de03ae193c98fc3a3573047ed
2023-09-05 05:24:54 -07:00
|
|
|
float lastAvailableWidth,
|
2019-04-23 08:08:51 -07:00
|
|
|
YGMeasureMode lastHeightMode,
|
C++ Cleanup 10/N: YGNodeCalculateLayout (#1352)
Summary:
X-link: https://github.com/facebook/react-native/pull/39195
Pull Request resolved: https://github.com/facebook/yoga/pull/1352
## This diff
This splits out all of the logic under `YGNodeCalculateLayout` to a couple of different files, does some mechanical renaming, and starts to split up the implementation a tiny bit. After this, core layout functions are all C++ convention and namespaced.
Each new file is marked as a move for the sake of blame history. It means Phabricator has a very inaccurate count of lines removed though.
## This stack
The organization of the C++ internals of Yoga are in need of attention.
1. Some of the C++ internals are namespaced, but others not.
2. Some of the namespaces include `detail`, but are meant to be used outside of the translation unit (FB Clang Tidy rules warn on any usage of these)
2. Most of the files are in a flat hierarchy, except for event tracing in its own folder
3. Some files and functions begin with YG, others don’t
4. Some functions are uppercase, others are not
5. Almost all of the interesting logic is in Yoga.cpp, and the file is too large to reason about
6. There are multiple grab bag files where folks put random functions they need in (Utils, BitUtils, Yoga-Internal.h)
7. There is no clear indication from file structure or type naming what is private vs not
8. Handles like `YGNodeRef` and `YGConfigRef` can be used to access internals just by importing headers
This stack does some much needed spring cleaning:
1. All non-public headers and C++ implementation details are in separate folders from the root level `yoga`. This will give us room to split up logic and add more files without too large a flat hierarchy
3. All private C++ internals are under the `facebook::yoga` namespace. Details namespaces are only ever used within the same header, as they are intended
4. Utils files are split
5. Most C++ internals drop the YG prefix
6. Most C++ internal function names are all lower camel case
7. We start to split up Yoga.cpp
8. Every header beginning with YG or at the top-level directory is public and C only, with the exception of Yoga-Internal.h which has non-public functions for bindings
9. It is not possible to use private APIs without static casting handles to internal classes
This will give us more leeway to continue splitting monolithic files, and consistent guidelines for style in new files as well.
These changes should not be breaking to any project using only public Yoga headers. This includes every usage of Yoga in fbsource except for RN Fabric which is currently tied to internals. This refactor should make that boundary clearer.
Reviewed By: rshest
Differential Revision: D48770478
fbshipit-source-id: 2a74b86441c3352de03ae193c98fc3a3573047ed
2023-09-05 05:24:54 -07:00
|
|
|
float lastAvailableHeight,
|
2019-04-23 08:08:51 -07:00
|
|
|
float lastComputedWidth,
|
|
|
|
|
float lastComputedHeight,
|
|
|
|
|
float marginRow,
|
|
|
|
|
float marginColumn,
|
|
|
|
|
YGConfigRef config);
|
|
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeCopyStyle(YGNodeRef dstNode, YGNodeConstRef srcNode);
|
2023-04-20 14:01:14 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void* YGNodeGetContext(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT void YGNodeSetContext(YGNodeRef node, void* context);
|
2023-04-20 14:01:14 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGConfigConstRef YGNodeGetConfig(YGNodeRef node);
|
|
|
|
|
YG_EXPORT void YGNodeSetConfig(YGNodeRef node, YGConfigRef config);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGConfigSetPrintTreeFlag(YGConfigRef config, bool enabled);
|
|
|
|
|
YG_EXPORT bool YGNodeHasMeasureFunc(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT void YGNodeSetMeasureFunc(YGNodeRef node, YGMeasureFunc measureFunc);
|
|
|
|
|
YG_EXPORT bool YGNodeHasBaselineFunc(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT void YGNodeSetBaselineFunc(
|
|
|
|
|
YGNodeRef node,
|
|
|
|
|
YGBaselineFunc baselineFunc);
|
|
|
|
|
YG_EXPORT YGDirtiedFunc YGNodeGetDirtiedFunc(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT void YGNodeSetDirtiedFunc(YGNodeRef node, YGDirtiedFunc dirtiedFunc);
|
|
|
|
|
YG_EXPORT void YGNodeSetPrintFunc(YGNodeRef node, YGPrintFunc printFunc);
|
|
|
|
|
YG_EXPORT bool YGNodeGetHasNewLayout(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT void YGNodeSetHasNewLayout(YGNodeRef node, bool hasNewLayout);
|
|
|
|
|
YG_EXPORT YGNodeType YGNodeGetNodeType(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT void YGNodeSetNodeType(YGNodeRef node, YGNodeType nodeType);
|
|
|
|
|
YG_EXPORT bool YGNodeIsDirty(YGNodeConstRef node);
|
|
|
|
|
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetDirection(YGNodeRef node, YGDirection direction);
|
|
|
|
|
YG_EXPORT YGDirection YGNodeStyleGetDirection(YGNodeConstRef node);
|
|
|
|
|
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetFlexDirection(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGNodeRef node,
|
|
|
|
|
YGFlexDirection flexDirection);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(YGNodeConstRef node);
|
2018-07-19 09:57:06 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetJustifyContent(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGNodeRef node,
|
|
|
|
|
YGJustify justifyContent);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGJustify YGNodeStyleGetJustifyContent(YGNodeConstRef node);
|
2018-07-19 09:57:06 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetAlignContent(YGNodeRef node, YGAlign alignContent);
|
|
|
|
|
YG_EXPORT YGAlign YGNodeStyleGetAlignContent(YGNodeConstRef node);
|
2018-07-19 09:57:06 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetAlignItems(YGNodeRef node, YGAlign alignItems);
|
|
|
|
|
YG_EXPORT YGAlign YGNodeStyleGetAlignItems(YGNodeConstRef node);
|
2018-07-19 09:57:06 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetAlignSelf(YGNodeRef node, YGAlign alignSelf);
|
|
|
|
|
YG_EXPORT YGAlign YGNodeStyleGetAlignSelf(YGNodeConstRef node);
|
2018-07-19 09:57:06 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetPositionType(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGNodeRef node,
|
|
|
|
|
YGPositionType positionType);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGPositionType YGNodeStyleGetPositionType(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetFlexWrap(YGNodeRef node, YGWrap flexWrap);
|
|
|
|
|
YG_EXPORT YGWrap YGNodeStyleGetFlexWrap(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetOverflow(YGNodeRef node, YGOverflow overflow);
|
|
|
|
|
YG_EXPORT YGOverflow YGNodeStyleGetOverflow(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetDisplay(YGNodeRef node, YGDisplay display);
|
|
|
|
|
YG_EXPORT YGDisplay YGNodeStyleGetDisplay(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetFlex(YGNodeRef node, float flex);
|
|
|
|
|
YG_EXPORT float YGNodeStyleGetFlex(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetFlexGrow(YGNodeRef node, float flexGrow);
|
|
|
|
|
YG_EXPORT float YGNodeStyleGetFlexGrow(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetFlexShrink(YGNodeRef node, float flexShrink);
|
|
|
|
|
YG_EXPORT float YGNodeStyleGetFlexShrink(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetFlexBasis(YGNodeRef node, float flexBasis);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node);
|
|
|
|
|
YG_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node);
|
2018-07-19 09:57:06 -07:00
|
|
|
|
2023-09-13 20:12:55 -07:00
|
|
|
YG_EXPORT void
|
|
|
|
|
YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float position);
|
|
|
|
|
YG_EXPORT void
|
|
|
|
|
YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float position);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin);
|
2023-09-13 20:12:55 -07:00
|
|
|
YG_EXPORT void
|
|
|
|
|
YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float margin);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge);
|
|
|
|
|
YG_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge);
|
2018-07-19 09:57:06 -07:00
|
|
|
|
2023-09-13 20:12:55 -07:00
|
|
|
YG_EXPORT void
|
|
|
|
|
YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float padding);
|
|
|
|
|
YG_EXPORT void
|
|
|
|
|
YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float padding);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetBorder(YGNodeRef node, YGEdge edge, float border);
|
|
|
|
|
YG_EXPORT float YGNodeStyleGetBorder(YGNodeConstRef node, YGEdge edge);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-13 20:12:55 -07:00
|
|
|
YG_EXPORT void
|
|
|
|
|
YGNodeStyleSetGap(YGNodeRef node, YGGutter gutter, float gapLength);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT float YGNodeStyleGetGap(YGNodeConstRef node, YGGutter gutter);
|
2022-10-13 08:18:49 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float width);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float width);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node);
|
|
|
|
|
YG_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float height);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, float height);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node);
|
|
|
|
|
YG_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetMinWidth(YGNodeRef node, float minWidth);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetMinWidthPercent(YGNodeRef node, float minWidth);
|
|
|
|
|
YG_EXPORT YGValue YGNodeStyleGetMinWidth(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetMinHeight(YGNodeRef node, float minHeight);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetMinHeightPercent(YGNodeRef node, float minHeight);
|
|
|
|
|
YG_EXPORT YGValue YGNodeStyleGetMinHeight(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetMaxWidth(YGNodeRef node, float maxWidth);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetMaxWidthPercent(YGNodeRef node, float maxWidth);
|
|
|
|
|
YG_EXPORT YGValue YGNodeStyleGetMaxWidth(YGNodeConstRef node);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetMaxHeight(YGNodeRef node, float maxHeight);
|
|
|
|
|
YG_EXPORT void YGNodeStyleSetMaxHeightPercent(YGNodeRef node, float maxHeight);
|
|
|
|
|
YG_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeConstRef node);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2019-01-16 08:39:58 -08:00
|
|
|
// Yoga specific properties, not compatible with flexbox specification Aspect
|
|
|
|
|
// ratio control the size of the undefined dimension of a node. Aspect ratio is
|
|
|
|
|
// encoded as a floating point value width/height. e.g. A value of 2 leads to a
|
|
|
|
|
// node with a width twice the size of its height while a value of 0.5 gives the
|
|
|
|
|
// opposite effect.
|
2016-12-22 02:57:15 -08:00
|
|
|
//
|
2018-07-19 09:57:04 -07:00
|
|
|
// - On a node with a set width/height aspect ratio control the size of the
|
2019-01-16 08:39:58 -08:00
|
|
|
// unset dimension
|
2018-07-19 09:57:04 -07:00
|
|
|
// - On a node with a set flex basis aspect ratio controls the size of the node
|
2019-01-16 08:39:58 -08:00
|
|
|
// in the cross axis if unset
|
2018-07-19 09:57:04 -07:00
|
|
|
// - On a node with a measure function aspect ratio works as though the measure
|
2019-01-16 08:39:58 -08:00
|
|
|
// function measures the flex basis
|
2018-07-19 09:57:04 -07:00
|
|
|
// - On a node with flex grow/shrink aspect ratio controls the size of the node
|
2019-01-16 08:39:58 -08:00
|
|
|
// in the cross axis if unset
|
2016-12-03 04:40:18 -08:00
|
|
|
// - Aspect ratio takes min/max dimensions into account
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, float aspectRatio);
|
|
|
|
|
YG_EXPORT float YGNodeStyleGetAspectRatio(YGNodeConstRef node);
|
|
|
|
|
|
|
|
|
|
YG_EXPORT float YGNodeLayoutGetLeft(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT float YGNodeLayoutGetTop(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT float YGNodeLayoutGetRight(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT float YGNodeLayoutGetBottom(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT float YGNodeLayoutGetWidth(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT float YGNodeLayoutGetHeight(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT YGDirection YGNodeLayoutGetDirection(YGNodeConstRef node);
|
|
|
|
|
YG_EXPORT bool YGNodeLayoutGetHadOverflow(YGNodeConstRef node);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2018-07-19 09:57:04 -07:00
|
|
|
// 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
|
|
|
|
|
// YGNodeStyleGetXXX. However if they were set using a percentage value then the
|
|
|
|
|
// returned value is the computed value used during layout.
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT float YGNodeLayoutGetMargin(YGNodeConstRef node, YGEdge edge);
|
|
|
|
|
YG_EXPORT float YGNodeLayoutGetBorder(YGNodeConstRef node, YGEdge edge);
|
|
|
|
|
YG_EXPORT float YGNodeLayoutGetPadding(YGNodeConstRef node, YGEdge edge);
|
2019-04-23 08:08:51 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGConfigSetLogger(YGConfigRef config, YGLogger logger);
|
2019-01-16 08:39:58 -08:00
|
|
|
// Set this to number of pixels in 1 point to round calculation results If you
|
|
|
|
|
// want to avoid rounding - set PointScaleFactor to 0
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGConfigSetPointScaleFactor(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGConfigRef config,
|
|
|
|
|
float pixelsInPoint);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT float YGConfigGetPointScaleFactor(YGConfigConstRef config);
|
2017-02-24 09:45:31 -08:00
|
|
|
|
2017-03-01 09:19:55 -08:00
|
|
|
// YGConfig
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGConfigRef YGConfigNew(void);
|
|
|
|
|
YG_EXPORT void YGConfigFree(YGConfigRef config);
|
2017-03-01 09:19:55 -08:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGConfigSetExperimentalFeatureEnabled(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGConfigRef config,
|
|
|
|
|
YGExperimentalFeature feature,
|
|
|
|
|
bool enabled);
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT bool YGConfigIsExperimentalFeatureEnabled(
|
2023-09-11 19:51:40 -07:00
|
|
|
YGConfigConstRef config,
|
2019-04-23 08:08:51 -07:00
|
|
|
YGExperimentalFeature feature);
|
2016-12-03 04:40:18 -08:00
|
|
|
|
2019-07-23 03:19:41 -07:00
|
|
|
// Using the web defaults is the preferred configuration for new projects. Usage
|
2019-01-16 08:39:58 -08:00
|
|
|
// of non web defaults should be considered as legacy.
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGConfigSetUseWebDefaults(YGConfigRef config, bool enabled);
|
|
|
|
|
YG_EXPORT bool YGConfigGetUseWebDefaults(YGConfigConstRef config);
|
2017-03-03 10:47:42 -08:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGConfigSetCloneNodeFunc(
|
2019-04-23 08:08:51 -07:00
|
|
|
YGConfigRef config,
|
|
|
|
|
YGCloneNodeFunc callback);
|
Persistent Yoga
Summary:
This is meant to show a possible route format for a persistent form of Yoga. Where previous layouts can remain intact while still taking advantage of incremental layout by reusing previous subtrees.
```c
YGNodeRef YGNodeClone(const YGNodeRef node);
```
The core of this functionality is a new API to clone an existing node. This makes a new detached node with all the same values as the previous one. Conceptually this makes the original node "frozen" from that point on. It's now immutable. (This is not yet enforced at runtime in this PR but something we should add.)
Since the original is frozen, we reuse the children set from the original node. Their parent pointers still point back to the original tree though.
The cloned node is still mutable. It can have its styles updated, and nodes can be inserted or deleted. If an insertion/deletion happens on a cloned node whose children were reused, it'll first shallow clone its children automatically.
As a convenience I also added an API to clear all children:
```c
void YGNodeRemoveAllChildren(const YGNodeRef node);
```
During insert/delete, or as a result of layout a set of reused children may need to be first cloned. A kind of copy-on-write. When that happens, the host may want to respond. E.g. by updating the `context` such as by cloning any wrapper objects and attaching them to the new node.
```c
typedef void (*YGNodeClonedFunc)(YGNodeRef oldNode,
YGNodeRef newNode,
YGNodeRef parent,
int childIndex);
void YGConfigSetNodeClonedFunc(YGConfigRef config,
YGNodeClonedFunc callback);
```
This PR doesn't change any existing semantics for trees that are not first cloned.
It's possible for a single node to exist in two trees at once and be used by multiple threads. Therefore it's not safe to recursively free a whole tree when you use persistence. To solve this, any user of the library has to manually manage ref counting or tracing GC. E.g. by replicating the tree structure in a wrapper.
In a follow up we could consider moving ref counting into Yoga.
Closes https://github.com/facebook/yoga/pull/636
Reviewed By: emilsjolander
Differential Revision: D5941921
Pulled By: sebmarkbage
fbshipit-source-id: c8e93421824c112d09c4773bed4e3141b6491ccf
2017-10-17 01:02:04 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT YGConfigConstRef YGConfigGetDefault(void);
|
2017-05-03 09:22:35 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGConfigSetContext(YGConfigRef config, void* context);
|
|
|
|
|
YG_EXPORT void* YGConfigGetContext(YGConfigConstRef config);
|
2017-05-03 09:22:35 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT void YGConfigSetErrata(YGConfigRef config, YGErrata errata);
|
|
|
|
|
YG_EXPORT YGErrata YGConfigGetErrata(YGConfigConstRef config);
|
Add YGErrata integration within C ABI (#37075)
Summary:
X-link: https://github.com/facebook/react-native/pull/37075
Pull Request resolved: https://github.com/facebook/yoga/pull/1255
This diff wires up YGErrata to a public API, along with existing functions to set UseLegacyStretchBehaviour.
The `UseLegacyStretchBehaviour` functions will be removed after the world internally is transitioned to `YGConfigSetErrata`. This is intentionally breaking, since most users previously enabling `UseLegacyStretchBehaviour` will want to pick a new appropriate errata setting. Internally, users of the API will be moved to`YGErrataAll`.
The overall change looks like:
1. Clean up YGConfig to use accessors/setters
2. Change up YGconfig internal storage
1. Fabric has a config per ShadowNode, so it makes sense to do some size optimization before adding more (free-form bools to bitfield, `std::array<bool,>` to `std::bitset` since not specialized)
3. Wire accessor/setter of UseLegacyStretchBehaviour to errata while both APIs exist
4. Add errata APIs to C ABI
After this we will need to expose the ABI to more language projections, and (more involved), add usages of the API to internal consumption of Yoga before adding more errata and removing `UseLegacyStretchBehaviour`.
Note that this API representation is similar, but distinct to `YGExperimentalFeature`. I think that API may also have made sense as an enum bitset, like we explicitly want for the new API, but it's not really worth changing the existing API to make that happen.
Reviewed By: rshest
Differential Revision: D45254097
fbshipit-source-id: 5c725ce5a77b25c1356f753d11c468587dbd8ded
2023-04-27 06:48:04 -07:00
|
|
|
|
2023-09-11 19:51:40 -07:00
|
|
|
YG_EXPORT float YGRoundValueToPixelGrid(
|
2020-04-27 14:38:51 -07:00
|
|
|
double value,
|
|
|
|
|
double pointScaleFactor,
|
2019-04-23 08:08:51 -07:00
|
|
|
bool forceCeil,
|
|
|
|
|
bool forceFloor);
|
2017-12-06 16:25:26 -08:00
|
|
|
|
2016-12-03 04:40:18 -08:00
|
|
|
YG_EXTERN_C_END
|