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

Add feature to use percentage as value unit #258

Closed
woehrl01 wants to merge 43 commits from percentage-feature into master
pull from: percentage-feature
merge into: DaddyFrosty:master
Conversation 118 Commits 43 Files Changed 41 +4428 -2535
62 changed files with 4428 additions and 2535 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit cac8d3715b - Show all commits

34
tests/YGLayoutDefaultValuesTest.cpp
View File

@@ -27,28 +27,28 @@ TEST(YogaTest, assert_default_values) {
ASSERT_EQ(YGOverflowVisible, YGNodeStyleGetOverflow(root));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetFlexGrow(root));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetFlexShrink(root));
ASSERT_FALSE(YGNodeStyleGetFlexBasis(root).defined);
ASSERT_FALSE(YGNodeStyleGetFlexBasis(root).isDefined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeLeft).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeTop).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeRight).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeBottom).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeStart).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeEnd).defined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeLeft).isDefined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeTop).isDefined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeRight).isDefined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeBottom).isDefined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeStart).isDefined);
ASSERT_FALSE(YGNodeStyleGetPosition(root, YGEdgeEnd).isDefined);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeLeft).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeTop).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeRight).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetMargin(root, YGEdgeBottom).value);
ASSERT_FALSE(YGNodeStyleGetMargin(root, YGEdgeStart).defined);
ASSERT_FALSE(YGNodeStyleGetMargin(root, YGEdgeEnd).defined);
ASSERT_FALSE(YGNodeStyleGetMargin(root, YGEdgeStart).isDefined);
ASSERT_FALSE(YGNodeStyleGetMargin(root, YGEdgeEnd).isDefined);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeLeft).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeTop).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeRight).value);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetPadding(root, YGEdgeBottom).value);
ASSERT_FALSE(YGNodeStyleGetPadding(root, YGEdgeStart).defined);
ASSERT_FALSE(YGNodeStyleGetPadding(root, YGEdgeEnd).defined);
ASSERT_FALSE(YGNodeStyleGetPadding(root, YGEdgeStart).isDefined);
ASSERT_FALSE(YGNodeStyleGetPadding(root, YGEdgeEnd).isDefined);
ASSERT_FLOAT_EQ(0, YGNodeStyleGetBorder(root, YGEdgeLeft));
ASSERT_FLOAT_EQ(0, YGNodeStyleGetBorder(root, YGEdgeTop));
@@ -57,12 +57,12 @@ TEST(YogaTest, assert_default_values) {
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetBorder(root, YGEdgeStart)));
ASSERT_TRUE(YGFloatIsUndefined(YGNodeStyleGetBorder(root, YGEdgeEnd)));
ASSERT_FALSE(YGNodeStyleGetWidth(root).defined);
ASSERT_FALSE(YGNodeStyleGetHeight(root).defined);
ASSERT_FALSE(YGNodeStyleGetMinWidth(root).defined);
ASSERT_FALSE(YGNodeStyleGetMinHeight(root).defined);
ASSERT_FALSE(YGNodeStyleGetMaxWidth(root).defined);
ASSERT_FALSE(YGNodeStyleGetMaxHeight(root).defined);
ASSERT_FALSE(YGNodeStyleGetWidth(root).isDefined);
ASSERT_FALSE(YGNodeStyleGetHeight(root).isDefined);
ASSERT_FALSE(YGNodeStyleGetMinWidth(root).isDefined);
ASSERT_FALSE(YGNodeStyleGetMinHeight(root).isDefined);
ASSERT_FALSE(YGNodeStyleGetMaxWidth(root).isDefined);
ASSERT_FALSE(YGNodeStyleGetMaxHeight(root).isDefined);
ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));

2
tests/YGStyleTest.cpp
View File

@@ -26,7 +26,7 @@ TEST(YogaTest, copy_style_modified) {
const YGNodeRef node0 = YGNodeNew();
ASSERT_FALSE(YGNodeIsDirty(node0));
ASSERT_EQ(YGFlexDirectionColumn, YGNodeStyleGetFlexDirection(node0));
ASSERT_FALSE(YGNodeStyleGetMaxHeight(node0).defined);
ASSERT_FALSE(YGNodeStyleGetMaxHeight(node0).isDefined);
const YGNodeRef node1 = YGNodeNew();
YGNodeStyleSetFlexDirection(node1, YGFlexDirectionRow);

72
yoga/Yoga.c
View File

@@ -115,7 +115,7 @@ YGFree gYGFree = &free;
static YGValue YGValueUndefined = {
.value = YGUndefined,
.defined = false,
.isDefined = false,
.unit = YGUnitPixel
};
@@ -167,20 +167,20 @@ static inline YGValue YGComputedEdgeValue(const YGValue edges[YGEdgeCount],
const float defaultValue) {
YG_ASSERT(edge <= YGEdgeEnd, "Cannot get computed value of multi-edge shorthands");
if (edges[edge].defined) {
if (edges[edge].isDefined) {
return edges[edge];
}
if ((edge == YGEdgeTop || edge == YGEdgeBottom) && edges[YGEdgeVertical].defined) {
if ((edge == YGEdgeTop || edge == YGEdgeBottom) && edges[YGEdgeVertical].isDefined) {
return edges[YGEdgeVertical];
}
if ((edge == YGEdgeLeft || edge == YGEdgeRight || edge == YGEdgeStart || edge == YGEdgeEnd) &&
edges[YGEdgeHorizontal].defined) {
edges[YGEdgeHorizontal].isDefined) {
emilsjolander commented 2016-12-18 22:21:08 -08:00 (Migrated from github.com)
Review
Copy Link

return YGValue {
.value = ...,
.defined = ...,
.unit = ...,
};

return YGValue { .value = ..., .defined = ..., .unit = ..., };
emilsjolander commented 2016-12-18 22:27:26 -08:00 (Migrated from github.com)
Review
Copy Link

YGValueToFloat is not very descriptive of what the function does. I would prefer YGValueResolve or something similar. What do you think?

`YGValueToFloat` is not very descriptive of what the function does. I would prefer `YGValueResolve` or something similar. What do you think?
woehrl01 commented 2016-12-18 22:58:07 -08:00 (Migrated from github.com)
Review
Copy Link

Please don't let me use this syntax here and at the other spots. Visual Studio (at least VS13 which I use) doesn't recognize this syntax, which would need me to change this one everytime I need to compile. (thats the reason I missed some tests at first)

Please don't let me use this syntax here and at the other spots. Visual Studio (at least VS13 which I use) doesn't recognize this syntax, which would need me to change this one everytime I need to compile. (thats the reason I missed some tests at first)
woehrl01 commented 2016-12-18 22:58:19 -08:00 (Migrated from github.com)
Review
Copy Link

sounds good!

sounds good!
emilsjolander commented 2016-12-18 23:12:57 -08:00 (Migrated from github.com)
Review
Copy Link

VS15 has support for this syntax and it is used throughout the project so i suggest upgrading. I would prefer it and it is part of C99. Is there a reason you are using a old VS build? if there are legit usages for old VS then I would be OK with leaving as is.

VS15 has support for this syntax and it is used throughout the project so i suggest upgrading. I would prefer it and it is part of C99. Is there a reason you are using a old VS build? if there are legit usages for old VS then I would be OK with leaving as is.
woehrl01 commented 2016-12-18 23:42:19 -08:00 (Migrated from github.com)
Review
Copy Link

none, except licence. If VS15 supports this I'm fine, making this change.

none, except licence. If VS15 supports this I'm fine, making this change.
emilsjolander commented 2016-12-18 23:46:32 -08:00 (Migrated from github.com)
Review
Copy Link

I think it does from searching google :p please double check yourself

I think it does from searching google :p please double check yourself
woehrl01 commented 2016-12-19 10:16:53 -08:00 (Migrated from github.com)
Review
Copy Link

sorry, just downloaded VS15 community and I can't get it to compile with this syntax 😞

sorry, just downloaded VS15 community and I can't get it to compile with this syntax 😞
woehrl01 commented 2016-12-19 10:28:56 -08:00 (Migrated from github.com)
Review
Copy Link

ups, got it to work, just can't return it at the same time. 😕

ups, got it to work, just can't return it at the same time. 😕
return edges[YGEdgeHorizontal];
}
if (edges[YGEdgeAll].defined) {
if (edges[YGEdgeAll].isDefined) {
return edges[YGEdgeAll];
}
@@ -190,7 +190,7 @@ static inline YGValue YGComputedEdgeValue(const YGValue edges[YGEdgeCount],
YGValue result = {
.value = defaultValue,
.defined = (defaultValue < 0 || defaultValue >= 0), /* is faster than a nan function call and enough at this point */
.isDefined = (defaultValue < 0 || defaultValue >= 0), /* is faster than a nan function call and enough at this point */
.unit = YGUnitPixel,
};
return result;
@@ -263,7 +263,7 @@ int32_t gNodeInstanceCount = 0;
YGValue YGPx(const float value){
YGValue result = {
.value = value,
.defined = !YGFloatIsUndefined(value),
.isDefined = !YGFloatIsUndefined(value),
.unit = YGUnitPixel,
};
return result;
@@ -272,7 +272,7 @@ YGValue YGPx(const float value){
YGValue YGPercent(const float value){
YGValue result = {
.value = value,
.defined = !YGFloatIsUndefined(value),
.isDefined = !YGFloatIsUndefined(value),
.unit = YGUnitPercent,
};
return result;
@@ -413,7 +413,7 @@ inline float YGNodeStyleGetFlexShrink(const YGNodeRef node) {
}
inline YGValue YGNodeStyleGetFlexBasis(const YGNodeRef node) {
if (node->style.flexBasis.defined) {
if (node->style.flexBasis.isDefined) {
return node->style.flexBasis;
}
if (!YGFloatIsUndefined(node->style.flex)) {
@@ -447,10 +447,10 @@ void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) {
}
#define YG_NODE_STYLE_PROPERTY_SETTER_UNIT_IMPL(type, name, paramName, instanceName) \
void YGNodeStyleSet##name##(const YGNodeRef node, const type paramName) { \
void YGNodeStyleSet##name(const YGNodeRef node, const type paramName) { \
if (node->style.instanceName.value != paramName.value || node->style.instanceName.unit != paramName.unit) { \
node->style.instanceName.value = paramName.value; \
node->style.instanceName.defined = !YGFloatIsUndefined(paramName.value); \
node->style.instanceName.isDefined = !YGFloatIsUndefined(paramName.value); \
node->style.instanceName.unit = paramName.unit; \
YGNodeMarkDirtyInternal(node); \
} \
@@ -466,21 +466,21 @@ void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) {
#define YG_NODE_STYLE_PROPERTY_UNIT_IMPL(type, name, paramName, instanceName) \
YG_NODE_STYLE_PROPERTY_SETTER_UNIT_IMPL(type, name, paramName, instanceName) \
\
type YGNodeStyleGet##name##(const YGNodeRef node) { \
type YGNodeStyleGet##name(const YGNodeRef node) { \
return node->style.instanceName; \
}
#define YG_NODE_STYLE_EDGE_PROPERTY_UNIT_IMPL(type, name, paramName, instanceName, defaultValue) \
void YGNodeStyleSet##name##(const YGNodeRef node, const YGEdge edge, const type paramName) { \
void YGNodeStyleSet##name(const YGNodeRef node, const YGEdge edge, const type paramName) { \
if (node->style.instanceName[edge].value != paramName.value || node->style.instanceName[edge].unit != paramName.unit ) { \
node->style.instanceName[edge].value = paramName.value; \
node->style.instanceName[edge].defined = !YGFloatIsUndefined(paramName.value); \
node->style.instanceName[edge].isDefined = !YGFloatIsUndefined(paramName.value); \
node->style.instanceName[edge].unit = paramName.unit; \
YGNodeMarkDirtyInternal(node); \
} \
} \
\
type YGNodeStyleGet##name##(const YGNodeRef node, const YGEdge edge) { \
type YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge) { \
return YGComputedEdgeValue(node->style.instanceName, edge, defaultValue); \
} \
@@ -489,7 +489,7 @@ void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) {
void YGNodeStyleSet##name(const YGNodeRef node, const YGEdge edge, const float paramName) { \
if (node->style.instanceName[edge].value != paramName || node->style.instanceName[edge].unit != YGUnitPixel ) { \
node->style.instanceName[edge].value = paramName; \
node->style.instanceName[edge].defined = !YGFloatIsUndefined(paramName); \
node->style.instanceName[edge].isDefined = !YGFloatIsUndefined(paramName); \
node->style.instanceName[edge].unit = YGUnitPixel; \
YGNodeMarkDirtyInternal(node); \
} \
@@ -567,8 +567,8 @@ static inline bool YGValueEqual(const YGValue a, const YGValue b) {
return false;
}
if (!a.defined) {
return !b.defined;
if (!a.isDefined) {
return !b.isDefined;
}
return fabs(a.value - b.value) < 0.0001;
}
@@ -599,7 +599,7 @@ static void YGPrintNumberIfNotUndefinedf(const char *str, const float number) {
}
static void YGPrintNumberIfNotUndefined(const char *str, const YGValue number) {
if (number.defined) {
if (number.isDefined) {
YGLog(YGLogLevelDebug, "%s: %g%s, ", str, number, number.unit == YGUnitPixel ? "px" : "%");
emilsjolander commented 2016-12-18 22:24:58 -08:00 (Migrated from github.com)
Review
Copy Link

just check for .defined. this function just makes it more verbose.

just check for `.defined`. this function just makes it more verbose.
}
}
@@ -805,7 +805,7 @@ static inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection)
}
static inline float YGNodeLeadingMargin(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) {
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeStart].defined) {
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeStart].isDefined) {
return YGValueResolve(node->style.margin[YGEdgeStart], widthSize);
}
@@ -813,7 +813,7 @@ static inline float YGNodeLeadingMargin(const YGNodeRef node, const YGFlexDirect
}
static float YGNodeTrailingMargin(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) {
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeEnd].defined) {
if (YGFlexDirectionIsRow(axis) && node->style.margin[YGEdgeEnd].isDefined) {
return YGValueResolve(node->style.margin[YGEdgeEnd], widthSize);
}
@@ -821,7 +821,7 @@ static float YGNodeTrailingMargin(const YGNodeRef node, const YGFlexDirection ax
}
static float YGNodeLeadingPadding(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) {
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeStart].defined &&
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeStart].isDefined &&
YGValueResolve(node->style.padding[YGEdgeStart], widthSize) >= 0) {
return YGValueResolve(node->style.padding[YGEdgeStart], widthSize);
}
@@ -830,7 +830,7 @@ static float YGNodeLeadingPadding(const YGNodeRef node, const YGFlexDirection ax
}
static float YGNodeTrailingPadding(const YGNodeRef node, const YGFlexDirection axis, const float widthSize) {
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeEnd].defined &&
if (YGFlexDirectionIsRow(axis) && node->style.padding[YGEdgeEnd].isDefined &&
YGValueResolve(node->style.padding[YGEdgeEnd], widthSize) >= 0) {
return YGValueResolve(node->style.padding[YGEdgeEnd], widthSize);
}
@@ -839,7 +839,7 @@ static float YGNodeTrailingPadding(const YGNodeRef node, const YGFlexDirection a
}
static float YGNodeLeadingBorder(const YGNodeRef node, const YGFlexDirection axis) {
if (YGFlexDirectionIsRow(axis) && node->style.border[YGEdgeStart].defined &&
if (YGFlexDirectionIsRow(axis) && node->style.border[YGEdgeStart].isDefined &&
node->style.border[YGEdgeStart].value >= 0) {
return node->style.border[YGEdgeStart].value;
}
@@ -848,7 +848,7 @@ static float YGNodeLeadingBorder(const YGNodeRef node, const YGFlexDirection axi
}
static float YGNodeTrailingBorder(const YGNodeRef node, const YGFlexDirection axis) {
if (YGFlexDirectionIsRow(axis) && node->style.border[YGEdgeEnd].defined &&
if (YGFlexDirectionIsRow(axis) && node->style.border[YGEdgeEnd].isDefined &&
node->style.border[YGEdgeEnd].value >= 0) {
return node->style.border[YGEdgeEnd].value;
}
@@ -920,7 +920,7 @@ static inline float YGNodeDimWithMargin(const YGNodeRef node, const YGFlexDirect
static inline bool YGNodeIsStyleDimDefined(const YGNodeRef node, const YGFlexDirection axis) {
const YGValue value = node->style.dimensions[dim[axis]];
return value.defined && value.value >= 0.0;
return value.isDefined && value.value >= 0.0;
}
static inline bool YGNodeIsLayoutDimDefined(const YGNodeRef node, const YGFlexDirection axis) {
@@ -930,21 +930,21 @@ static inline bool YGNodeIsLayoutDimDefined(const YGNodeRef node, const YGFlexDi
static inline bool YGNodeIsLeadingPosDefined(const YGNodeRef node, const YGFlexDirection axis) {
return (YGFlexDirectionIsRow(axis) &&
YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined).defined) ||
YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined).defined;
YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined).isDefined) ||
YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined).isDefined;
}
static inline bool YGNodeIsTrailingPosDefined(const YGNodeRef node, const YGFlexDirection axis) {
return (YGFlexDirectionIsRow(axis) &&
YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined).defined) ||
YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined).defined;
YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined).isDefined) ||
YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined).isDefined;
}
static float YGNodeLeadingPosition(const YGNodeRef node, const YGFlexDirection axis, const float axisSize) {
if (YGFlexDirectionIsRow(axis)) {
const YGValue leadingPosition =
YGComputedEdgeValue(node->style.position, YGEdgeStart, YGUndefined);
if (leadingPosition.defined) {
if (leadingPosition.isDefined) {
return YGValueResolve(leadingPosition, axisSize);
}
}
@@ -952,14 +952,14 @@ static float YGNodeLeadingPosition(const YGNodeRef node, const YGFlexDirection a
const YGValue leadingPosition =
YGComputedEdgeValue(node->style.position, leading[axis], YGUndefined);
return !leadingPosition.defined ? 0 : YGValueResolve(leadingPosition, axisSize);
return !leadingPosition.isDefined ? 0 : YGValueResolve(leadingPosition, axisSize);
}
static float YGNodeTrailingPosition(const YGNodeRef node, const YGFlexDirection axis, const float axisSize) {
if (YGFlexDirectionIsRow(axis)) {
const YGValue trailingPosition =
YGComputedEdgeValue(node->style.position, YGEdgeEnd, YGUndefined);
if (trailingPosition.defined) {
if (trailingPosition.isDefined) {
return YGValueResolve(trailingPosition, axisSize);
}
}
@@ -967,7 +967,7 @@ static float YGNodeTrailingPosition(const YGNodeRef node, const YGFlexDirection
const YGValue trailingPosition =
YGComputedEdgeValue(node->style.position, trailing[axis], YGUndefined);
return !trailingPosition.defined ? 0 : YGValueResolve(trailingPosition, axisSize);
return !trailingPosition.isDefined ? 0 : YGValueResolve(trailingPosition, axisSize);
}
static float YGNodeBoundAxisWithinMinAndMax(const YGNodeRef node,
@@ -1077,7 +1077,7 @@ static void YGNodeComputeFlexBasisForChild(const YGNodeRef node,
const bool isRowStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionRow);
const bool isColumnStyleDimDefined = YGNodeIsStyleDimDefined(child, YGFlexDirectionColumn);
if (YGNodeStyleGetFlexBasis(child).defined &&
if (YGNodeStyleGetFlexBasis(child).isDefined &&
!YGFloatIsUndefined(mainAxisSize)) {
if (YGFloatIsUndefined(child->layout.computedFlexBasis) ||
(YGIsExperimentalFeatureEnabled(YGExperimentalFeatureWebFlexBasis) &&
@@ -2009,7 +2009,7 @@ static void YGNodelayoutImpl(const YGNodeRef node,
// constraint by the min size defined for the main axis.
if (measureModeMainDim == YGMeasureModeAtMost && remainingFreeSpace > 0) {
if (node->style.minDimensions[dim[mainAxis]].defined &&
if (node->style.minDimensions[dim[mainAxis]].isDefined &&
YGValueResolve(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) >= 0) {
remainingFreeSpace = fmaxf(0,
YGValueResolve(node->style.minDimensions[dim[mainAxis]], mainAxisParentSize) -

10
yoga/Yoga.h
View File

@@ -41,7 +41,7 @@ typedef struct YGSize {
typedef struct YGValue {
float value;
YGUnit unit;
bool defined;
bool isDefined;
} YGValue;
WIN_EXPORT YGValue YGPx(const float value);
@@ -117,8 +117,8 @@ WIN_EXPORT void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode
WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node);
emilsjolander commented 2016-12-18 22:18:49 -08:00 (Migrated from github.com)
Review
Copy Link

Let's remove the *WithUnit APIs and just use units everywhere. This makes the API smaller and more concise. Also it forces the user to think about units.

Let's remove the *WithUnit APIs and just use units everywhere. This makes the API smaller and more concise. Also it forces the user to think about units.
woehrl01 commented 2016-12-18 22:55:57 -08:00 (Migrated from github.com)
Review
Copy Link

How should we return the units in the getter? Should I use YGValue in both get + set or use (float, YGUnitPixel) in the set and return only the float in get?

How should we return the units in the getter? Should I use YGValue in both get + set or use (float, YGUnitPixel) in the set and return only the float in get?
emilsjolander commented 2016-12-18 23:09:51 -08:00 (Migrated from github.com)
Review
Copy Link

The getter should return a YGValue as well.

The getter should return a YGValue as well.
#define YG_NODE_STYLE_PROPERTY_UNIT(type, name, paramName) \
WIN_EXPORT void YGNodeStyleSet##name##(const YGNodeRef node, const type paramName); \
WIN_EXPORT type YGNodeStyleGet##name##(const YGNodeRef node);
WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node, const type paramName); \
WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node);
#define YG_NODE_STYLE_EDGE_PROPERTY(type, name, paramName) \
WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node, \
@@ -127,10 +127,10 @@ WIN_EXPORT void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode
WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge);
#define YG_NODE_STYLE_EDGE_PROPERTY_UNIT(type, name, paramName) \
WIN_EXPORT void YGNodeStyleSet##name##(const YGNodeRef node, \
WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node, \
const YGEdge edge, \
const type paramName); \
WIN_EXPORT type YGNodeStyleGet##name##(const YGNodeRef node, const YGEdge edge);
WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge);
#define YG_NODE_LAYOUT_PROPERTY(type, name) \
WIN_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node);