diff --git a/enums.py b/enums.py index a81b8c882b..5511f49d46 100755 --- a/enums.py +++ b/enums.py @@ -8,7 +8,15 @@ ENUMS = { "Direction": ["Inherit", "LTR", "RTL"], - "Unit": ["Undefined", "Point", "Percent", "Auto"], + "Unit": [ + "Undefined", + "Point", + "Percent", + "Auto", + "MaxContent", + "FitContent", + "Stretch", + ], "FlexDirection": ["Column", "ColumnReverse", "Row", "RowReverse"], "Justify": [ "FlexStart", diff --git a/java/com/facebook/yoga/YogaNative.java b/java/com/facebook/yoga/YogaNative.java index 89ef5ef16f..582bd1eb19 100644 --- a/java/com/facebook/yoga/YogaNative.java +++ b/java/com/facebook/yoga/YogaNative.java @@ -74,6 +74,9 @@ public class YogaNative { static native void jni_YGNodeStyleSetFlexBasisJNI(long nativePointer, float flexBasis); static native void jni_YGNodeStyleSetFlexBasisPercentJNI(long nativePointer, float percent); static native void jni_YGNodeStyleSetFlexBasisAutoJNI(long nativePointer); + static native void jni_YGNodeStyleSetFlexBasisMaxContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetFlexBasisFitContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetFlexBasisStretchJNI(long nativePointer); static native long jni_YGNodeStyleGetMarginJNI(long nativePointer, int edge); static native void jni_YGNodeStyleSetMarginJNI(long nativePointer, int edge, float margin); static native void jni_YGNodeStyleSetMarginPercentJNI(long nativePointer, int edge, float percent); @@ -91,22 +94,40 @@ public class YogaNative { static native void jni_YGNodeStyleSetWidthJNI(long nativePointer, float width); static native void jni_YGNodeStyleSetWidthPercentJNI(long nativePointer, float percent); static native void jni_YGNodeStyleSetWidthAutoJNI(long nativePointer); + static native void jni_YGNodeStyleSetWidthMaxContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetWidthFitContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetWidthStretchJNI(long nativePointer); static native long jni_YGNodeStyleGetHeightJNI(long nativePointer); static native void jni_YGNodeStyleSetHeightJNI(long nativePointer, float height); static native void jni_YGNodeStyleSetHeightPercentJNI(long nativePointer, float percent); static native void jni_YGNodeStyleSetHeightAutoJNI(long nativePointer); + static native void jni_YGNodeStyleSetHeightMaxContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetHeightFitContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetHeightStretchJNI(long nativePointer); static native long jni_YGNodeStyleGetMinWidthJNI(long nativePointer); static native void jni_YGNodeStyleSetMinWidthJNI(long nativePointer, float minWidth); static native void jni_YGNodeStyleSetMinWidthPercentJNI(long nativePointer, float percent); + static native void jni_YGNodeStyleSetMinWidthMaxContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetMinWidthFitContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetMinWidthStretchJNI(long nativePointer); static native long jni_YGNodeStyleGetMinHeightJNI(long nativePointer); static native void jni_YGNodeStyleSetMinHeightJNI(long nativePointer, float minHeight); static native void jni_YGNodeStyleSetMinHeightPercentJNI(long nativePointer, float percent); + static native void jni_YGNodeStyleSetMinHeightMaxContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetMinHeightFitContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetMinHeightStretchJNI(long nativePointer); static native long jni_YGNodeStyleGetMaxWidthJNI(long nativePointer); static native void jni_YGNodeStyleSetMaxWidthJNI(long nativePointer, float maxWidth); static native void jni_YGNodeStyleSetMaxWidthPercentJNI(long nativePointer, float percent); + static native void jni_YGNodeStyleSetMaxWidthMaxContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetMaxWidthFitContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetMaxWidthStretchJNI(long nativePointer); static native long jni_YGNodeStyleGetMaxHeightJNI(long nativePointer); static native void jni_YGNodeStyleSetMaxHeightJNI(long nativePointer, float maxheight); static native void jni_YGNodeStyleSetMaxHeightPercentJNI(long nativePointer, float percent); + static native void jni_YGNodeStyleSetMaxHeightMaxContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetMaxHeightFitContentJNI(long nativePointer); + static native void jni_YGNodeStyleSetMaxHeightStretchJNI(long nativePointer); static native float jni_YGNodeStyleGetAspectRatioJNI(long nativePointer); static native void jni_YGNodeStyleSetAspectRatioJNI(long nativePointer, float aspectRatio); static native float jni_YGNodeStyleGetGapJNI(long nativePointer, int gutter); diff --git a/java/com/facebook/yoga/YogaNode.java b/java/com/facebook/yoga/YogaNode.java index ba07684675..b683b553ca 100644 --- a/java/com/facebook/yoga/YogaNode.java +++ b/java/com/facebook/yoga/YogaNode.java @@ -124,6 +124,12 @@ public interface Inputs { public abstract void setFlexBasisAuto(); + public abstract void setFlexBasisMaxContent(); + + public abstract void setFlexBasisFitContent(); + + public abstract void setFlexBasisStretch(); + public abstract YogaValue getMargin(YogaEdge edge); public abstract void setMargin(YogaEdge edge, float margin); @@ -158,6 +164,12 @@ public interface Inputs { public abstract void setWidthAuto(); + public abstract void setWidthMaxContent(); + + public abstract void setWidthFitContent(); + + public abstract void setWidthStretch(); + public abstract YogaValue getHeight(); public abstract void setHeight(float height); @@ -166,30 +178,60 @@ public interface Inputs { public abstract void setHeightAuto(); + public abstract void setHeightMaxContent(); + + public abstract void setHeightFitContent(); + + public abstract void setHeightStretch(); + public abstract YogaValue getMinWidth(); public abstract void setMinWidth(float minWidth); public abstract void setMinWidthPercent(float percent); + public abstract void setMinWidthMaxContent(); + + public abstract void setMinWidthFitContent(); + + public abstract void setMinWidthStretch(); + public abstract YogaValue getMinHeight(); public abstract void setMinHeight(float minHeight); public abstract void setMinHeightPercent(float percent); + public abstract void setMinHeightMaxContent(); + + public abstract void setMinHeightFitContent(); + + public abstract void setMinHeightStretch(); + public abstract YogaValue getMaxWidth(); public abstract void setMaxWidth(float maxWidth); public abstract void setMaxWidthPercent(float percent); + public abstract void setMaxWidthMaxContent(); + + public abstract void setMaxWidthFitContent(); + + public abstract void setMaxWidthStretch(); + public abstract YogaValue getMaxHeight(); public abstract void setMaxHeight(float maxheight); public abstract void setMaxHeightPercent(float percent); + public abstract void setMaxHeightMaxContent(); + + public abstract void setMaxHeightFitContent(); + + public abstract void setMaxHeightStretch(); + public abstract float getAspectRatio(); public abstract void setAspectRatio(float aspectRatio); diff --git a/java/com/facebook/yoga/YogaNodeJNIBase.java b/java/com/facebook/yoga/YogaNodeJNIBase.java index a53fe74af0..e25872545e 100644 --- a/java/com/facebook/yoga/YogaNodeJNIBase.java +++ b/java/com/facebook/yoga/YogaNodeJNIBase.java @@ -373,6 +373,18 @@ public void setFlexBasisAuto() { YogaNative.jni_YGNodeStyleSetFlexBasisAutoJNI(mNativePointer); } + public void setFlexBasisMaxContent() { + YogaNative.jni_YGNodeStyleSetFlexBasisMaxContentJNI(mNativePointer); + } + + public void setFlexBasisFitContent() { + YogaNative.jni_YGNodeStyleSetFlexBasisFitContentJNI(mNativePointer); + } + + public void setFlexBasisStretch() { + YogaNative.jni_YGNodeStyleSetFlexBasisStretchJNI(mNativePointer); + } + public YogaValue getMargin(YogaEdge edge) { return valueFromLong(YogaNative.jni_YGNodeStyleGetMarginJNI(mNativePointer, edge.intValue())); } @@ -441,6 +453,18 @@ public void setWidthAuto() { YogaNative.jni_YGNodeStyleSetWidthAutoJNI(mNativePointer); } + public void setWidthMaxContent() { + YogaNative.jni_YGNodeStyleSetWidthMaxContentJNI(mNativePointer); + } + + public void setWidthFitContent() { + YogaNative.jni_YGNodeStyleSetWidthFitContentJNI(mNativePointer); + } + + public void setWidthStretch() { + YogaNative.jni_YGNodeStyleSetWidthStretchJNI(mNativePointer); + } + public YogaValue getHeight() { return valueFromLong(YogaNative.jni_YGNodeStyleGetHeightJNI(mNativePointer)); } @@ -457,6 +481,18 @@ public void setHeightAuto() { YogaNative.jni_YGNodeStyleSetHeightAutoJNI(mNativePointer); } + public void setHeightMaxContent() { + YogaNative.jni_YGNodeStyleSetHeightMaxContentJNI(mNativePointer); + } + + public void setHeightFitContent() { + YogaNative.jni_YGNodeStyleSetHeightFitContentJNI(mNativePointer); + } + + public void setHeightStretch() { + YogaNative.jni_YGNodeStyleSetHeightStretchJNI(mNativePointer); + } + public YogaValue getMinWidth() { return valueFromLong(YogaNative.jni_YGNodeStyleGetMinWidthJNI(mNativePointer)); } @@ -469,6 +505,18 @@ public void setMinWidthPercent(float percent) { YogaNative.jni_YGNodeStyleSetMinWidthPercentJNI(mNativePointer, percent); } + public void setMinWidthMaxContent() { + YogaNative.jni_YGNodeStyleSetMinWidthMaxContentJNI(mNativePointer); + } + + public void setMinWidthFitContent() { + YogaNative.jni_YGNodeStyleSetMinWidthFitContentJNI(mNativePointer); + } + + public void setMinWidthStretch() { + YogaNative.jni_YGNodeStyleSetMinWidthStretchJNI(mNativePointer); + } + public YogaValue getMinHeight() { return valueFromLong(YogaNative.jni_YGNodeStyleGetMinHeightJNI(mNativePointer)); } @@ -481,6 +529,18 @@ public void setMinHeightPercent(float percent) { YogaNative.jni_YGNodeStyleSetMinHeightPercentJNI(mNativePointer, percent); } + public void setMinHeightMaxContent() { + YogaNative.jni_YGNodeStyleSetMinHeightMaxContentJNI(mNativePointer); + } + + public void setMinHeightFitContent() { + YogaNative.jni_YGNodeStyleSetMinHeightFitContentJNI(mNativePointer); + } + + public void setMinHeightStretch() { + YogaNative.jni_YGNodeStyleSetMinHeightStretchJNI(mNativePointer); + } + public YogaValue getMaxWidth() { return valueFromLong(YogaNative.jni_YGNodeStyleGetMaxWidthJNI(mNativePointer)); } @@ -493,6 +553,18 @@ public void setMaxWidthPercent(float percent) { YogaNative.jni_YGNodeStyleSetMaxWidthPercentJNI(mNativePointer, percent); } + public void setMaxWidthMaxContent() { + YogaNative.jni_YGNodeStyleSetMaxWidthMaxContentJNI(mNativePointer); + } + + public void setMaxWidthFitContent() { + YogaNative.jni_YGNodeStyleSetMaxWidthFitContentJNI(mNativePointer); + } + + public void setMaxWidthStretch() { + YogaNative.jni_YGNodeStyleSetMaxWidthStretchJNI(mNativePointer); + } + public YogaValue getMaxHeight() { return valueFromLong(YogaNative.jni_YGNodeStyleGetMaxHeightJNI(mNativePointer)); } @@ -505,6 +577,18 @@ public void setMaxHeightPercent(float percent) { YogaNative.jni_YGNodeStyleSetMaxHeightPercentJNI(mNativePointer, percent); } + public void setMaxHeightMaxContent() { + YogaNative.jni_YGNodeStyleSetMaxHeightMaxContentJNI(mNativePointer); + } + + public void setMaxHeightFitContent() { + YogaNative.jni_YGNodeStyleSetMaxHeightFitContentJNI(mNativePointer); + } + + public void setMaxHeightStretch() { + YogaNative.jni_YGNodeStyleSetMaxHeightStretchJNI(mNativePointer); + } + public float getAspectRatio() { return YogaNative.jni_YGNodeStyleGetAspectRatioJNI(mNativePointer); } diff --git a/java/com/facebook/yoga/YogaProps.java b/java/com/facebook/yoga/YogaProps.java index c596c6a7c1..0cad45fa9c 100644 --- a/java/com/facebook/yoga/YogaProps.java +++ b/java/com/facebook/yoga/YogaProps.java @@ -15,15 +15,33 @@ public interface YogaProps { void setWidthPercent(float percent); + void setWidthAuto(); + + void setWidthMaxContent(); + + void setWidthFitContent(); + + void setWidthStretch(); + void setMinWidth(float minWidth); void setMinWidthPercent(float percent); + void setMinWidthMaxContent(); + + void setMinWidthFitContent(); + + void setMinWidthStretch(); + void setMaxWidth(float maxWidth); void setMaxWidthPercent(float percent); - void setWidthAuto(); + void setMaxWidthMaxContent(); + + void setMaxWidthFitContent(); + + void setMaxWidthStretch(); /* Height properties */ @@ -31,15 +49,33 @@ public interface YogaProps { void setHeightPercent(float percent); + void setHeightAuto(); + + void setHeightMaxContent(); + + void setHeightFitContent(); + + void setHeightStretch(); + void setMinHeight(float minHeight); void setMinHeightPercent(float percent); + void setMinHeightMaxContent(); + + void setMinHeightFitContent(); + + void setMinHeightStretch(); + void setMaxHeight(float maxHeight); void setMaxHeightPercent(float percent); - void setHeightAuto(); + void setMaxHeightMaxContent(); + + void setMaxHeightFitContent(); + + void setMaxHeightStretch(); /* Margin properties */ @@ -81,6 +117,12 @@ public interface YogaProps { void setFlexBasis(float flexBasis); + void setFlexBasisMaxContent(); + + void setFlexBasisFitContent(); + + void setFlexBasisStretch(); + void setFlexDirection(YogaFlexDirection direction); void setFlexGrow(float flexGrow); diff --git a/java/com/facebook/yoga/YogaUnit.java b/java/com/facebook/yoga/YogaUnit.java index 3614ec1059..5731a040d9 100644 --- a/java/com/facebook/yoga/YogaUnit.java +++ b/java/com/facebook/yoga/YogaUnit.java @@ -13,7 +13,10 @@ public enum YogaUnit { UNDEFINED(0), POINT(1), PERCENT(2), - AUTO(3); + AUTO(3), + MAX_CONTENT(4), + FIT_CONTENT(5), + STRETCH(6); private final int mIntValue; @@ -31,6 +34,9 @@ public static YogaUnit fromInt(int value) { case 1: return POINT; case 2: return PERCENT; case 3: return AUTO; + case 4: return MAX_CONTENT; + case 5: return FIT_CONTENT; + case 6: return STRETCH; default: throw new IllegalArgumentException("Unknown enum value: " + value); } } diff --git a/java/jni/YGJNIVanilla.cpp b/java/jni/YGJNIVanilla.cpp index 6b8ed14bd6..95273836c2 100644 --- a/java/jni/YGJNIVanilla.cpp +++ b/java/jni/YGJNIVanilla.cpp @@ -429,6 +429,28 @@ static void jni_YGNodeCopyStyleJNI( YGNodeStyleSet##name##Auto(_jlong2YGNodeRef(nativePointer)); \ } +#define YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(name) \ + YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(name) \ + YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name) + +#define YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(name) \ + YG_NODE_JNI_STYLE_UNIT_PROP(name) \ + YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name) + +#define YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name) \ + static void jni_YGNodeStyleSet##name##MaxContentJNI( \ + JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { \ + YGNodeStyleSet##name##MaxContent(_jlong2YGNodeRef(nativePointer)); \ + } \ + static void jni_YGNodeStyleSet##name##FitContentJNI( \ + JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { \ + YGNodeStyleSet##name##FitContent(_jlong2YGNodeRef(nativePointer)); \ + } \ + static void jni_YGNodeStyleSet##name##StretchJNI( \ + JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) { \ + YGNodeStyleSet##name##Stretch(_jlong2YGNodeRef(nativePointer)); \ + } + #define YG_NODE_JNI_STYLE_EDGE_UNIT_PROP(name) \ static jlong jni_YGNodeStyleGet##name##JNI( \ JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer, jint edge) { \ @@ -483,13 +505,13 @@ YG_NODE_JNI_STYLE_PROP(jfloat, float, Flex); YG_NODE_JNI_STYLE_PROP(jfloat, float, FlexGrow); YG_NODE_JNI_STYLE_PROP(jfloat, float, FlexShrink); -YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(FlexBasis); -YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(Width); -YG_NODE_JNI_STYLE_UNIT_PROP(MinWidth); -YG_NODE_JNI_STYLE_UNIT_PROP(MaxWidth); -YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(Height); -YG_NODE_JNI_STYLE_UNIT_PROP(MinHeight); -YG_NODE_JNI_STYLE_UNIT_PROP(MaxHeight); +YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(FlexBasis); +YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(Width); +YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MinWidth); +YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MaxWidth); +YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(Height); +YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MinHeight); +YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MaxHeight); YG_NODE_JNI_STYLE_EDGE_UNIT_PROP_AUTO(Position); @@ -870,6 +892,15 @@ static JNINativeMethod methods[] = { {"jni_YGNodeStyleSetFlexBasisAutoJNI", "(J)V", (void*)jni_YGNodeStyleSetFlexBasisAutoJNI}, + {"jni_YGNodeStyleSetFlexBasisMaxContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetFlexBasisMaxContentJNI}, + {"jni_YGNodeStyleSetFlexBasisFitContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetFlexBasisFitContentJNI}, + {"jni_YGNodeStyleSetFlexBasisStretchJNI", + "(J)V", + (void*)jni_YGNodeStyleSetFlexBasisStretchJNI}, {"jni_YGNodeStyleGetMarginJNI", "(JI)J", (void*)jni_YGNodeStyleGetMarginJNI}, @@ -917,6 +948,15 @@ static JNINativeMethod methods[] = { {"jni_YGNodeStyleSetWidthAutoJNI", "(J)V", (void*)jni_YGNodeStyleSetWidthAutoJNI}, + {"jni_YGNodeStyleSetWidthMaxContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetWidthMaxContentJNI}, + {"jni_YGNodeStyleSetWidthFitContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetWidthFitContentJNI}, + {"jni_YGNodeStyleSetWidthStretchJNI", + "(J)V", + (void*)jni_YGNodeStyleSetWidthStretchJNI}, {"jni_YGNodeStyleGetHeightJNI", "(J)J", (void*)jni_YGNodeStyleGetHeightJNI}, {"jni_YGNodeStyleSetHeightJNI", "(JF)V", @@ -927,6 +967,15 @@ static JNINativeMethod methods[] = { {"jni_YGNodeStyleSetHeightAutoJNI", "(J)V", (void*)jni_YGNodeStyleSetHeightAutoJNI}, + {"jni_YGNodeStyleSetHeightMaxContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetHeightMaxContentJNI}, + {"jni_YGNodeStyleSetHeightFitContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetHeightFitContentJNI}, + {"jni_YGNodeStyleSetHeightStretchJNI", + "(J)V", + (void*)jni_YGNodeStyleSetHeightStretchJNI}, {"jni_YGNodeStyleGetMinWidthJNI", "(J)J", (void*)jni_YGNodeStyleGetMinWidthJNI}, @@ -936,6 +985,15 @@ static JNINativeMethod methods[] = { {"jni_YGNodeStyleSetMinWidthPercentJNI", "(JF)V", (void*)jni_YGNodeStyleSetMinWidthPercentJNI}, + {"jni_YGNodeStyleSetMinWidthMaxContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMinWidthMaxContentJNI}, + {"jni_YGNodeStyleSetMinWidthFitContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMinWidthFitContentJNI}, + {"jni_YGNodeStyleSetMinWidthStretchJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMinWidthStretchJNI}, {"jni_YGNodeStyleGetMinHeightJNI", "(J)J", (void*)jni_YGNodeStyleGetMinHeightJNI}, @@ -945,6 +1003,15 @@ static JNINativeMethod methods[] = { {"jni_YGNodeStyleSetMinHeightPercentJNI", "(JF)V", (void*)jni_YGNodeStyleSetMinHeightPercentJNI}, + {"jni_YGNodeStyleSetMinHeightMaxContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMinHeightMaxContentJNI}, + {"jni_YGNodeStyleSetMinHeightFitContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMinHeightFitContentJNI}, + {"jni_YGNodeStyleSetMinHeightStretchJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMinHeightStretchJNI}, {"jni_YGNodeStyleGetMaxWidthJNI", "(J)J", (void*)jni_YGNodeStyleGetMaxWidthJNI}, @@ -954,6 +1021,15 @@ static JNINativeMethod methods[] = { {"jni_YGNodeStyleSetMaxWidthPercentJNI", "(JF)V", (void*)jni_YGNodeStyleSetMaxWidthPercentJNI}, + {"jni_YGNodeStyleSetMaxWidthMaxContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMaxWidthMaxContentJNI}, + {"jni_YGNodeStyleSetMaxWidthFitContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMaxWidthFitContentJNI}, + {"jni_YGNodeStyleSetMaxWidthStretchJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMaxWidthStretchJNI}, {"jni_YGNodeStyleGetMaxHeightJNI", "(J)J", (void*)jni_YGNodeStyleGetMaxHeightJNI}, @@ -963,6 +1039,15 @@ static JNINativeMethod methods[] = { {"jni_YGNodeStyleSetMaxHeightPercentJNI", "(JF)V", (void*)jni_YGNodeStyleSetMaxHeightPercentJNI}, + {"jni_YGNodeStyleSetMaxHeightMaxContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMaxHeightMaxContentJNI}, + {"jni_YGNodeStyleSetMaxHeightFitContentJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMaxHeightFitContentJNI}, + {"jni_YGNodeStyleSetMaxHeightStretchJNI", + "(J)V", + (void*)jni_YGNodeStyleSetMaxHeightStretchJNI}, {"jni_YGNodeStyleGetAspectRatioJNI", "(J)F", (void*)jni_YGNodeStyleGetAspectRatioJNI}, diff --git a/javascript/src/Node.cpp b/javascript/src/Node.cpp index f5c6a86651..5284ddb5b0 100644 --- a/javascript/src/Node.cpp +++ b/javascript/src/Node.cpp @@ -160,6 +160,18 @@ void Node::setFlexBasisAuto() { YGNodeStyleSetFlexBasisAuto(m_node); } +void Node::setFlexBasisMaxContent() { + YGNodeStyleSetFlexBasisMaxContent(m_node); +} + +void Node::setFlexBasisFitContent() { + YGNodeStyleSetFlexBasisFitContent(m_node); +} + +void Node::setFlexBasisStretch() { + YGNodeStyleSetFlexBasisStretch(m_node); +} + void Node::setFlexGrow(double flexGrow) { YGNodeStyleSetFlexGrow(m_node, flexGrow); } @@ -180,6 +192,18 @@ void Node::setWidthAuto() { YGNodeStyleSetWidthAuto(m_node); } +void Node::setWidthMaxContent() { + YGNodeStyleSetWidthMaxContent(m_node); +} + +void Node::setWidthFitContent() { + YGNodeStyleSetWidthFitContent(m_node); +} + +void Node::setWidthStretch() { + YGNodeStyleSetWidthStretch(m_node); +} + void Node::setHeight(double height) { YGNodeStyleSetHeight(m_node, height); } @@ -192,6 +216,18 @@ void Node::setHeightAuto() { YGNodeStyleSetHeightAuto(m_node); } +void Node::setHeightMaxContent() { + YGNodeStyleSetHeightMaxContent(m_node); +} + +void Node::setHeightFitContent() { + YGNodeStyleSetHeightFitContent(m_node); +} + +void Node::setHeightStretch() { + YGNodeStyleSetHeightStretch(m_node); +} + void Node::setMinWidth(double minWidth) { YGNodeStyleSetMinWidth(m_node, minWidth); } @@ -200,6 +236,18 @@ void Node::setMinWidthPercent(double minWidth) { YGNodeStyleSetMinWidthPercent(m_node, minWidth); } +void Node::setMinWidthMaxContent() { + YGNodeStyleSetMinWidthMaxContent(m_node); +} + +void Node::setMinWidthFitContent() { + YGNodeStyleSetMinWidthFitContent(m_node); +} + +void Node::setMinWidthStretch() { + YGNodeStyleSetMinWidthStretch(m_node); +} + void Node::setMinHeight(double minHeight) { YGNodeStyleSetMinHeight(m_node, minHeight); } @@ -208,6 +256,18 @@ void Node::setMinHeightPercent(double minHeight) { YGNodeStyleSetMinHeightPercent(m_node, minHeight); } +void Node::setMinHeightMaxContent() { + YGNodeStyleSetMinHeightMaxContent(m_node); +} + +void Node::setMinHeightFitContent() { + YGNodeStyleSetMinHeightFitContent(m_node); +} + +void Node::setMinHeightStretch() { + YGNodeStyleSetMinHeightStretch(m_node); +} + void Node::setMaxWidth(double maxWidth) { YGNodeStyleSetMaxWidth(m_node, maxWidth); } @@ -216,6 +276,18 @@ void Node::setMaxWidthPercent(double maxWidth) { YGNodeStyleSetMaxWidthPercent(m_node, maxWidth); } +void Node::setMaxWidthMaxContent() { + YGNodeStyleSetMaxWidthMaxContent(m_node); +} + +void Node::setMaxWidthFitContent() { + YGNodeStyleSetMaxWidthFitContent(m_node); +} + +void Node::setMaxWidthStretch() { + YGNodeStyleSetMaxWidthStretch(m_node); +} + void Node::setMaxHeight(double maxHeight) { YGNodeStyleSetMaxHeight(m_node, maxHeight); } @@ -224,6 +296,18 @@ void Node::setMaxHeightPercent(double maxHeight) { YGNodeStyleSetMaxHeightPercent(m_node, maxHeight); } +void Node::setMaxHeightMaxContent() { + YGNodeStyleSetMaxHeightMaxContent(m_node); +} + +void Node::setMaxHeightFitContent() { + YGNodeStyleSetMaxHeightFitContent(m_node); +} + +void Node::setMaxHeightStretch() { + YGNodeStyleSetMaxHeightStretch(m_node); +} + void Node::setAspectRatio(double aspectRatio) { YGNodeStyleSetAspectRatio(m_node, aspectRatio); } diff --git a/javascript/src/Node.h b/javascript/src/Node.h index c30f1d2ded..0ed4d1d416 100644 --- a/javascript/src/Node.h +++ b/javascript/src/Node.h @@ -97,25 +97,46 @@ class Node { void setFlexBasis(double flexBasis); void setFlexBasisPercent(double flexBasis); void setFlexBasisAuto(); + void setFlexBasisMaxContent(); + void setFlexBasisFitContent(); + void setFlexBasisStretch(); void setFlexGrow(double flexGrow); void setFlexShrink(double flexShrink); void setWidth(double width); void setWidthPercent(double width); void setWidthAuto(); + void setWidthMaxContent(); + void setWidthFitContent(); + void setWidthStretch(); void setHeight(double height); void setHeightPercent(double height); void setHeightAuto(); + void setHeightMaxContent(); + void setHeightFitContent(); + void setHeightStretch(); void setMinWidth(double minWidth); void setMinWidthPercent(double minWidth); + void setMinWidthMaxContent(); + void setMinWidthFitContent(); + void setMinWidthStretch(); void setMinHeight(double minHeight); void setMinHeightPercent(double minHeight); + void setMinHeightMaxContent(); + void setMinHeightFitContent(); + void setMinHeightStretch(); void setMaxWidth(double maxWidth); void setMaxWidthPercent(double maxWidth); + void setMaxWidthMaxContent(); + void setMaxWidthFitContent(); + void setMaxWidthStretch(); void setMaxHeight(double maxHeight); void setMaxHeightPercent(double maxHeight); + void setMaxHeightMaxContent(); + void setMaxHeightFitContent(); + void setMaxHeightStretch(); void setAspectRatio(double aspectRatio); diff --git a/javascript/src/embind.cpp b/javascript/src/embind.cpp index d1789788cf..a2f7202961 100644 --- a/javascript/src/embind.cpp +++ b/javascript/src/embind.cpp @@ -90,25 +90,46 @@ EMSCRIPTEN_BINDINGS(YOGA_LAYOUT) { .function("setFlexBasis", &Node::setFlexBasis) .function("setFlexBasisPercent", &Node::setFlexBasisPercent) .function("setFlexBasisAuto", &Node::setFlexBasisAuto) + .function("setFlexBasisMaxContent", &Node::setFlexBasisMaxContent) + .function("setFlexBasisFitContent", &Node::setFlexBasisFitContent) + .function("setFlexBasisStretch", &Node::setFlexBasisStretch) .function("setFlexGrow", &Node::setFlexGrow) .function("setFlexShrink", &Node::setFlexShrink) .function("setWidth", &Node::setWidth) .function("setWidthPercent", &Node::setWidthPercent) .function("setWidthAuto", &Node::setWidthAuto) + .function("setWidthMaxContent", &Node::setWidthMaxContent) + .function("setWidthFitContent", &Node::setWidthFitContent) + .function("setWidthStretch", &Node::setWidthStretch) .function("setHeight", &Node::setHeight) .function("setHeightPercent", &Node::setHeightPercent) .function("setHeightAuto", &Node::setHeightAuto) + .function("setHeightMaxContent", &Node::setHeightMaxContent) + .function("setHeightFitContent", &Node::setHeightFitContent) + .function("setHeightStretch", &Node::setHeightStretch) .function("setMinWidth", &Node::setMinWidth) .function("setMinWidthPercent", &Node::setMinWidthPercent) + .function("setMinWidthMaxContent", &Node::setMinWidthMaxContent) + .function("setMinWidthFitContent", &Node::setMinWidthFitContent) + .function("setMinWidthStretch", &Node::setMinWidthStretch) .function("setMinHeight", &Node::setMinHeight) .function("setMinHeightPercent", &Node::setMinHeightPercent) + .function("setMinHeightMaxContent", &Node::setMinHeightMaxContent) + .function("setMinHeightFitContent", &Node::setMinHeightFitContent) + .function("setMinHeightStretch", &Node::setMinHeightStretch) .function("setMaxWidth", &Node::setMaxWidth) .function("setMaxWidthPercent", &Node::setMaxWidthPercent) + .function("setMaxWidthMaxContent", &Node::setMaxWidthMaxContent) + .function("setMaxWidthFitContent", &Node::setMaxWidthFitContent) + .function("setMaxWidthStretch", &Node::setMaxWidthStretch) .function("setMaxHeight", &Node::setMaxHeight) .function("setMaxHeightPercent", &Node::setMaxHeightPercent) + .function("setMaxHeightMaxContent", &Node::setMaxHeightMaxContent) + .function("setMaxHeightFitContent", &Node::setMaxHeightFitContent) + .function("setMaxHeightStretch", &Node::setMaxHeightStretch) .function("setBoxSizing", &Node::setBoxSizing) diff --git a/javascript/src/generated/YGEnums.ts b/javascript/src/generated/YGEnums.ts index 2aafc682ff..f389fe2fdf 100644 --- a/javascript/src/generated/YGEnums.ts +++ b/javascript/src/generated/YGEnums.ts @@ -125,6 +125,9 @@ export enum Unit { Point = 1, Percent = 2, Auto = 3, + MaxContent = 4, + FitContent = 5, + Stretch = 6, } export enum Wrap { @@ -203,6 +206,9 @@ const constants = { UNIT_POINT: Unit.Point, UNIT_PERCENT: Unit.Percent, UNIT_AUTO: Unit.Auto, + UNIT_MAX_CONTENT: Unit.MaxContent, + UNIT_FIT_CONTENT: Unit.FitContent, + UNIT_STRETCH: Unit.Stretch, WRAP_NO_WRAP: Wrap.NoWrap, WRAP_WRAP: Wrap.Wrap, WRAP_WRAP_REVERSE: Wrap.WrapReverse, diff --git a/javascript/src/wrapAssembly.ts b/javascript/src/wrapAssembly.ts index 3f91c160bf..9b2dc1e6ec 100644 --- a/javascript/src/wrapAssembly.ts +++ b/javascript/src/wrapAssembly.ts @@ -134,17 +134,41 @@ export type Node = { setDirection(direction: Direction): void; setDisplay(display: Display): void; setFlex(flex: number | undefined): void; - setFlexBasis(flexBasis: number | 'auto' | `${number}%` | undefined): void; + setFlexBasis( + flexBasis: + | number + | 'auto' + | 'fit-content' + | 'max-content' + | 'stretch' + | `${number}%` + | undefined, + ): void; setFlexBasisPercent(flexBasis: number | undefined): void; setFlexBasisAuto(): void; + setFlexBasisFitContent(): void; + setFlexBasisMaxContent(): void; + setFlexBasisStretch(): void; setFlexDirection(flexDirection: FlexDirection): void; setFlexGrow(flexGrow: number | undefined): void; setFlexShrink(flexShrink: number | undefined): void; setFlexWrap(flexWrap: Wrap): void; - setHeight(height: number | 'auto' | `${number}%` | undefined): void; + setHeight( + height: + | number + | 'auto' + | 'fit-content' + | 'max-content' + | 'stretch' + | `${number}%` + | undefined, + ): void; setIsReferenceBaseline(isReferenceBaseline: boolean): void; setHeightAuto(): void; + setHeightFitContent(): void; + setHeightMaxContent(): void; setHeightPercent(height: number | undefined): void; + setHeightStretch(): void; setJustifyContent(justifyContent: Justify): void; setGap(gutter: Gutter, gapLength: number | `${number}%` | undefined): Value; setGapPercent(gutter: Gutter, gapLength: number | undefined): Value; @@ -154,16 +178,60 @@ export type Node = { ): void; setMarginAuto(edge: Edge): void; setMarginPercent(edge: Edge, margin: number | undefined): void; - setMaxHeight(maxHeight: number | `${number}%` | undefined): void; + setMaxHeight( + maxHeight: + | number + | 'fit-content' + | 'max-content' + | 'stretch' + | `${number}%` + | undefined, + ): void; + setMaxHeightFitContent(): void; + setMaxHeightMaxContent(): void; setMaxHeightPercent(maxHeight: number | undefined): void; - setMaxWidth(maxWidth: number | `${number}%` | undefined): void; + setMaxHeightStretch(): void; + setMaxWidth( + maxWidth: + | number + | 'fit-content' + | 'max-content' + | 'stretch' + | `${number}%` + | undefined, + ): void; + setMaxWidthFitContent(): void; + setMaxWidthMaxContent(): void; setMaxWidthPercent(maxWidth: number | undefined): void; + setMaxWidthStretch(): void; setDirtiedFunc(dirtiedFunc: DirtiedFunction | null): void; setMeasureFunc(measureFunc: MeasureFunction | null): void; - setMinHeight(minHeight: number | `${number}%` | undefined): void; + setMinHeight( + minHeight: + | number + | 'fit-content' + | 'max-content' + | 'stretch' + | `${number}%` + | undefined, + ): void; + setMinHeightFitContent(): void; + setMinHeightMaxContent(): void; setMinHeightPercent(minHeight: number | undefined): void; - setMinWidth(minWidth: number | `${number}%` | undefined): void; + setMinHeightStretch(): void; + setMinWidth( + minWidth: + | number + | 'fit-content' + | 'max-content' + | 'stretch' + | `${number}%` + | undefined, + ): void; + setMinWidthFitContent(): void; + setMinWidthMaxContent(): void; setMinWidthPercent(minWidth: number | undefined): void; + setMinWidthStretch(): void; setOverflow(overflow: Overflow): void; setPadding(edge: Edge, padding: number | `${number}%` | undefined): void; setPaddingPercent(edge: Edge, padding: number | undefined): void; @@ -172,9 +240,21 @@ export type Node = { setPositionType(positionType: PositionType): void; setPositionAuto(edge: Edge): void; setBoxSizing(boxSizing: BoxSizing): void; - setWidth(width: number | 'auto' | `${number}%` | undefined): void; + setWidth( + width: + | number + | 'auto' + | 'fit-content' + | 'max-content' + | 'stretch' + | `${number}%` + | undefined, + ): void; setWidthAuto(): void; + setWidthFitContent(): void; + setWidthMaxContent(): void; setWidthPercent(width: number | undefined): void; + setWidthStretch(): void; unsetDirtiedFunc(): void; unsetMeasureFunc(): void; setAlwaysFormsContainingBlock(alwaysFormsContainingBlock: boolean): void; @@ -220,6 +300,9 @@ export default function wrapAssembly(lib: any): Yoga { [Unit.Point]: lib.Node.prototype[fnName], [Unit.Percent]: lib.Node.prototype[`${fnName}Percent`], [Unit.Auto]: lib.Node.prototype[`${fnName}Auto`], + [Unit.MaxContent]: lib.Node.prototype[`${fnName}MaxContent`], + [Unit.FitContent]: lib.Node.prototype[`${fnName}FitContent`], + [Unit.Stretch]: lib.Node.prototype[`${fnName}Stretch`], }; patch(lib.Node.prototype, fnName, function (original, ...args) { @@ -232,6 +315,15 @@ export default function wrapAssembly(lib: any): Yoga { if (value === 'auto') { unit = Unit.Auto; asNumber = undefined; + } else if (value == 'max-content') { + unit = Unit.MaxContent; + asNumber = undefined; + } else if (value == 'fit-content') { + unit = Unit.FitContent; + asNumber = undefined; + } else if (value == 'stretch') { + unit = Unit.Stretch; + asNumber = undefined; } else if (typeof value === 'object') { unit = value.unit; asNumber = value.valueOf(); diff --git a/tests/StyleValuePoolTest.cpp b/tests/StyleValuePoolTest.cpp index 0755059f35..ff38acff36 100644 --- a/tests/StyleValuePoolTest.cpp +++ b/tests/StyleValuePoolTest.cpp @@ -128,4 +128,19 @@ TEST(StyleValuePool, store_undefined_after_large_int) { EXPECT_EQ(pool.getLength(handle), StyleLength::undefined()); } +TEST(StyleValuePool, store_keywords) { + StyleValuePool pool; + StyleValueHandle handleMaxContent; + StyleValueHandle handleFitContent; + StyleValueHandle handleStretch; + + pool.store(handleMaxContent, StyleSizeLength::ofMaxContent()); + pool.store(handleFitContent, StyleSizeLength::ofFitContent()); + pool.store(handleStretch, StyleSizeLength::ofStretch()); + + EXPECT_EQ(pool.getSize(handleMaxContent), StyleSizeLength::ofMaxContent()); + EXPECT_EQ(pool.getSize(handleFitContent), StyleSizeLength::ofFitContent()); + EXPECT_EQ(pool.getSize(handleStretch), StyleSizeLength::ofStretch()); +} + } // namespace facebook::yoga diff --git a/yoga/YGEnums.cpp b/yoga/YGEnums.cpp index cddd5d5849..4bdace6b7a 100644 --- a/yoga/YGEnums.cpp +++ b/yoga/YGEnums.cpp @@ -245,6 +245,12 @@ const char* YGUnitToString(const YGUnit value) { return "percent"; case YGUnitAuto: return "auto"; + case YGUnitMaxContent: + return "max-content"; + case YGUnitFitContent: + return "fit-content"; + case YGUnitStretch: + return "stretch"; } return "unknown"; } diff --git a/yoga/YGEnums.h b/yoga/YGEnums.h index 27f0426f45..bb83bcfac9 100644 --- a/yoga/YGEnums.h +++ b/yoga/YGEnums.h @@ -131,7 +131,10 @@ YG_ENUM_DECL( YGUnitUndefined, YGUnitPoint, YGUnitPercent, - YGUnitAuto) + YGUnitAuto, + YGUnitMaxContent, + YGUnitFitContent, + YGUnitStretch) YG_ENUM_DECL( YGWrap, diff --git a/yoga/YGNodeStyle.cpp b/yoga/YGNodeStyle.cpp index 8664b53ec8..3f1be42e46 100644 --- a/yoga/YGNodeStyle.cpp +++ b/yoga/YGNodeStyle.cpp @@ -177,19 +177,34 @@ float YGNodeStyleGetFlexShrink(const YGNodeConstRef nodeRef) { void YGNodeStyleSetFlexBasis(const YGNodeRef node, const float flexBasis) { updateStyle<&Style::flexBasis, &Style::setFlexBasis>( - node, StyleLength::points(flexBasis)); + node, StyleSizeLength::points(flexBasis)); } void YGNodeStyleSetFlexBasisPercent( const YGNodeRef node, const float flexBasisPercent) { updateStyle<&Style::flexBasis, &Style::setFlexBasis>( - node, StyleLength::percent(flexBasisPercent)); + node, StyleSizeLength::percent(flexBasisPercent)); } void YGNodeStyleSetFlexBasisAuto(const YGNodeRef node) { updateStyle<&Style::flexBasis, &Style::setFlexBasis>( - node, StyleLength::ofAuto()); + node, StyleSizeLength::ofAuto()); +} + +void YGNodeStyleSetFlexBasisMaxContent(const YGNodeRef node) { + updateStyle<&Style::flexBasis, &Style::setFlexBasis>( + node, StyleSizeLength::ofMaxContent()); +} + +void YGNodeStyleSetFlexBasisFitContent(const YGNodeRef node) { + updateStyle<&Style::flexBasis, &Style::setFlexBasis>( + node, StyleSizeLength::ofFitContent()); +} + +void YGNodeStyleSetFlexBasisStretch(const YGNodeRef node) { + updateStyle<&Style::flexBasis, &Style::setFlexBasis>( + node, StyleSizeLength::ofStretch()); } YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) { @@ -308,17 +323,32 @@ YGBoxSizing YGNodeStyleGetBoxSizing(const YGNodeConstRef node) { void YGNodeStyleSetWidth(YGNodeRef node, float points) { updateStyle<&Style::dimension, &Style::setDimension>( - node, Dimension::Width, StyleLength::points(points)); + node, Dimension::Width, StyleSizeLength::points(points)); } void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) { updateStyle<&Style::dimension, &Style::setDimension>( - node, Dimension::Width, StyleLength::percent(percent)); + node, Dimension::Width, StyleSizeLength::percent(percent)); } void YGNodeStyleSetWidthAuto(YGNodeRef node) { updateStyle<&Style::dimension, &Style::setDimension>( - node, Dimension::Width, StyleLength::ofAuto()); + node, Dimension::Width, StyleSizeLength::ofAuto()); +} + +void YGNodeStyleSetWidthMaxContent(YGNodeRef node) { + updateStyle<&Style::dimension, &Style::setDimension>( + node, Dimension::Width, StyleSizeLength::ofMaxContent()); +} + +void YGNodeStyleSetWidthFitContent(YGNodeRef node) { + updateStyle<&Style::dimension, &Style::setDimension>( + node, Dimension::Width, StyleSizeLength::ofFitContent()); +} + +void YGNodeStyleSetWidthStretch(YGNodeRef node) { + updateStyle<&Style::dimension, &Style::setDimension>( + node, Dimension::Width, StyleSizeLength::ofStretch()); } YGValue YGNodeStyleGetWidth(YGNodeConstRef node) { @@ -327,17 +357,32 @@ YGValue YGNodeStyleGetWidth(YGNodeConstRef node) { void YGNodeStyleSetHeight(YGNodeRef node, float points) { updateStyle<&Style::dimension, &Style::setDimension>( - node, Dimension::Height, StyleLength::points(points)); + node, Dimension::Height, StyleSizeLength::points(points)); } void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) { updateStyle<&Style::dimension, &Style::setDimension>( - node, Dimension::Height, StyleLength::percent(percent)); + node, Dimension::Height, StyleSizeLength::percent(percent)); } void YGNodeStyleSetHeightAuto(YGNodeRef node) { updateStyle<&Style::dimension, &Style::setDimension>( - node, Dimension::Height, StyleLength::ofAuto()); + node, Dimension::Height, StyleSizeLength::ofAuto()); +} + +void YGNodeStyleSetHeightMaxContent(YGNodeRef node) { + updateStyle<&Style::dimension, &Style::setDimension>( + node, Dimension::Height, StyleSizeLength::ofMaxContent()); +} + +void YGNodeStyleSetHeightFitContent(YGNodeRef node) { + updateStyle<&Style::dimension, &Style::setDimension>( + node, Dimension::Height, StyleSizeLength::ofFitContent()); +} + +void YGNodeStyleSetHeightStretch(YGNodeRef node) { + updateStyle<&Style::dimension, &Style::setDimension>( + node, Dimension::Height, StyleSizeLength::ofStretch()); } YGValue YGNodeStyleGetHeight(YGNodeConstRef node) { @@ -346,12 +391,27 @@ YGValue YGNodeStyleGetHeight(YGNodeConstRef node) { void YGNodeStyleSetMinWidth(const YGNodeRef node, const float minWidth) { updateStyle<&Style::minDimension, &Style::setMinDimension>( - node, Dimension::Width, StyleLength::points(minWidth)); + node, Dimension::Width, StyleSizeLength::points(minWidth)); } void YGNodeStyleSetMinWidthPercent(const YGNodeRef node, const float minWidth) { updateStyle<&Style::minDimension, &Style::setMinDimension>( - node, Dimension::Width, StyleLength::percent(minWidth)); + node, Dimension::Width, StyleSizeLength::percent(minWidth)); +} + +void YGNodeStyleSetMinWidthMaxContent(const YGNodeRef node) { + updateStyle<&Style::minDimension, &Style::setMinDimension>( + node, Dimension::Width, StyleSizeLength::ofMaxContent()); +} + +void YGNodeStyleSetMinWidthFitContent(const YGNodeRef node) { + updateStyle<&Style::minDimension, &Style::setMinDimension>( + node, Dimension::Width, StyleSizeLength::ofFitContent()); +} + +void YGNodeStyleSetMinWidthStretch(const YGNodeRef node) { + updateStyle<&Style::minDimension, &Style::setMinDimension>( + node, Dimension::Width, StyleSizeLength::ofStretch()); } YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) { @@ -360,14 +420,29 @@ YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) { void YGNodeStyleSetMinHeight(const YGNodeRef node, const float minHeight) { updateStyle<&Style::minDimension, &Style::setMinDimension>( - node, Dimension::Height, StyleLength::points(minHeight)); + node, Dimension::Height, StyleSizeLength::points(minHeight)); } void YGNodeStyleSetMinHeightPercent( const YGNodeRef node, const float minHeight) { updateStyle<&Style::minDimension, &Style::setMinDimension>( - node, Dimension::Height, StyleLength::percent(minHeight)); + node, Dimension::Height, StyleSizeLength::percent(minHeight)); +} + +void YGNodeStyleSetMinHeightMaxContent(const YGNodeRef node) { + updateStyle<&Style::minDimension, &Style::setMinDimension>( + node, Dimension::Height, StyleSizeLength::ofMaxContent()); +} + +void YGNodeStyleSetMinHeightFitContent(const YGNodeRef node) { + updateStyle<&Style::minDimension, &Style::setMinDimension>( + node, Dimension::Height, StyleSizeLength::ofFitContent()); +} + +void YGNodeStyleSetMinHeightStretch(const YGNodeRef node) { + updateStyle<&Style::minDimension, &Style::setMinDimension>( + node, Dimension::Height, StyleSizeLength::ofStretch()); } YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) { @@ -376,12 +451,27 @@ YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) { void YGNodeStyleSetMaxWidth(const YGNodeRef node, const float maxWidth) { updateStyle<&Style::maxDimension, &Style::setMaxDimension>( - node, Dimension::Width, StyleLength::points(maxWidth)); + node, Dimension::Width, StyleSizeLength::points(maxWidth)); } void YGNodeStyleSetMaxWidthPercent(const YGNodeRef node, const float maxWidth) { updateStyle<&Style::maxDimension, &Style::setMaxDimension>( - node, Dimension::Width, StyleLength::percent(maxWidth)); + node, Dimension::Width, StyleSizeLength::percent(maxWidth)); +} + +void YGNodeStyleSetMaxWidthMaxContent(const YGNodeRef node) { + updateStyle<&Style::maxDimension, &Style::setMaxDimension>( + node, Dimension::Width, StyleSizeLength::ofMaxContent()); +} + +void YGNodeStyleSetMaxWidthFitContent(const YGNodeRef node) { + updateStyle<&Style::maxDimension, &Style::setMaxDimension>( + node, Dimension::Width, StyleSizeLength::ofFitContent()); +} + +void YGNodeStyleSetMaxWidthStretch(const YGNodeRef node) { + updateStyle<&Style::maxDimension, &Style::setMaxDimension>( + node, Dimension::Width, StyleSizeLength::ofStretch()); } YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) { @@ -390,14 +480,29 @@ YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) { void YGNodeStyleSetMaxHeight(const YGNodeRef node, const float maxHeight) { updateStyle<&Style::maxDimension, &Style::setMaxDimension>( - node, Dimension::Height, StyleLength::points(maxHeight)); + node, Dimension::Height, StyleSizeLength::points(maxHeight)); } void YGNodeStyleSetMaxHeightPercent( const YGNodeRef node, const float maxHeight) { updateStyle<&Style::maxDimension, &Style::setMaxDimension>( - node, Dimension::Height, StyleLength::percent(maxHeight)); + node, Dimension::Height, StyleSizeLength::percent(maxHeight)); +} + +void YGNodeStyleSetMaxHeightMaxContent(const YGNodeRef node) { + updateStyle<&Style::maxDimension, &Style::setMaxDimension>( + node, Dimension::Height, StyleSizeLength::ofMaxContent()); +} + +void YGNodeStyleSetMaxHeightFitContent(const YGNodeRef node) { + updateStyle<&Style::maxDimension, &Style::setMaxDimension>( + node, Dimension::Height, StyleSizeLength::ofFitContent()); +} + +void YGNodeStyleSetMaxHeightStretch(const YGNodeRef node) { + updateStyle<&Style::maxDimension, &Style::setMaxDimension>( + node, Dimension::Height, StyleSizeLength::ofStretch()); } YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) { diff --git a/yoga/YGNodeStyle.h b/yoga/YGNodeStyle.h index 2746a4a00a..a971138bb9 100644 --- a/yoga/YGNodeStyle.h +++ b/yoga/YGNodeStyle.h @@ -64,6 +64,9 @@ YG_EXPORT float YGNodeStyleGetFlexShrink(YGNodeConstRef node); YG_EXPORT void YGNodeStyleSetFlexBasis(YGNodeRef node, float flexBasis); YG_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis); YG_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetFlexBasisMaxContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetFlexBasisFitContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetFlexBasisStretch(YGNodeRef node); YG_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node); YG_EXPORT void @@ -101,27 +104,45 @@ YG_EXPORT YGBoxSizing YGNodeStyleGetBoxSizing(YGNodeConstRef node); YG_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float width); YG_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float width); YG_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetWidthMaxContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetWidthFitContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetWidthStretch(YGNodeRef node); YG_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node); YG_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float height); YG_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, float height); YG_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetHeightMaxContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetHeightFitContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetHeightStretch(YGNodeRef node); YG_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node); YG_EXPORT void YGNodeStyleSetMinWidth(YGNodeRef node, float minWidth); YG_EXPORT void YGNodeStyleSetMinWidthPercent(YGNodeRef node, float minWidth); +YG_EXPORT void YGNodeStyleSetMinWidthMaxContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetMinWidthFitContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetMinWidthStretch(YGNodeRef node); YG_EXPORT YGValue YGNodeStyleGetMinWidth(YGNodeConstRef node); YG_EXPORT void YGNodeStyleSetMinHeight(YGNodeRef node, float minHeight); YG_EXPORT void YGNodeStyleSetMinHeightPercent(YGNodeRef node, float minHeight); +YG_EXPORT void YGNodeStyleSetMinHeightMaxContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetMinHeightFitContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetMinHeightStretch(YGNodeRef node); YG_EXPORT YGValue YGNodeStyleGetMinHeight(YGNodeConstRef node); YG_EXPORT void YGNodeStyleSetMaxWidth(YGNodeRef node, float maxWidth); YG_EXPORT void YGNodeStyleSetMaxWidthPercent(YGNodeRef node, float maxWidth); +YG_EXPORT void YGNodeStyleSetMaxWidthMaxContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetMaxWidthFitContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetMaxWidthStretch(YGNodeRef node); YG_EXPORT YGValue YGNodeStyleGetMaxWidth(YGNodeConstRef node); YG_EXPORT void YGNodeStyleSetMaxHeight(YGNodeRef node, float maxHeight); YG_EXPORT void YGNodeStyleSetMaxHeightPercent(YGNodeRef node, float maxHeight); +YG_EXPORT void YGNodeStyleSetMaxHeightMaxContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetMaxHeightFitContent(YGNodeRef node); +YG_EXPORT void YGNodeStyleSetMaxHeightStretch(YGNodeRef node); YG_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeConstRef node); YG_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, float aspectRatio); diff --git a/yoga/YGValue.h b/yoga/YGValue.h index 7fa6fd918e..63c82f3da8 100644 --- a/yoga/YGValue.h +++ b/yoga/YGValue.h @@ -65,6 +65,9 @@ inline bool operator==(const YGValue& lhs, const YGValue& rhs) { switch (lhs.unit) { case YGUnitUndefined: case YGUnitAuto: + case YGUnitFitContent: + case YGUnitMaxContent: + case YGUnitStretch: return true; case YGUnitPoint: case YGUnitPercent: diff --git a/yoga/algorithm/CalculateLayout.cpp b/yoga/algorithm/CalculateLayout.cpp index f9e6f6e8f5..31841e35b0 100644 --- a/yoga/algorithm/CalculateLayout.cpp +++ b/yoga/algorithm/CalculateLayout.cpp @@ -741,7 +741,7 @@ static float distributeFreeSpaceSecondPass( marginCross; const bool isLoosePercentageMeasurement = currentLineChild->getProcessedDimension(dimension(crossAxis)) - .unit() == Unit::Percent && + .isPercent() && sizingModeCrossDim != SizingMode::StretchFit; childCrossSizingMode = yoga::isUndefined(childCrossSize) || isLoosePercentageMeasurement diff --git a/yoga/enums/Unit.h b/yoga/enums/Unit.h index 57bd196970..685b1caece 100644 --- a/yoga/enums/Unit.h +++ b/yoga/enums/Unit.h @@ -20,11 +20,14 @@ enum class Unit : uint8_t { Point = YGUnitPoint, Percent = YGUnitPercent, Auto = YGUnitAuto, + MaxContent = YGUnitMaxContent, + FitContent = YGUnitFitContent, + Stretch = YGUnitStretch, }; template <> constexpr int32_t ordinalCount() { - return 4; + return 7; } constexpr Unit scopedEnum(YGUnit unscoped) { diff --git a/yoga/node/Node.cpp b/yoga/node/Node.cpp index 1bb5e8aad0..dce42fb165 100644 --- a/yoga/node/Node.cpp +++ b/yoga/node/Node.cpp @@ -314,16 +314,16 @@ void Node::setPosition( crossAxisTrailingEdge); } -Style::Length Node::processFlexBasis() const { - Style::Length flexBasis = style_.flexBasis(); - if (flexBasis.unit() != Unit::Auto && flexBasis.unit() != Unit::Undefined) { +Style::SizeLength Node::processFlexBasis() const { + Style::SizeLength flexBasis = style_.flexBasis(); + if (!flexBasis.isAuto() && !flexBasis.isUndefined()) { return flexBasis; } if (style_.flex().isDefined() && style_.flex().unwrap() > 0.0f) { - return config_->useWebDefaults() ? StyleLength::ofAuto() - : StyleLength::points(0); + return config_->useWebDefaults() ? StyleSizeLength::ofAuto() + : StyleSizeLength::points(0); } - return StyleLength::ofAuto(); + return StyleSizeLength::ofAuto(); } FloatOptional Node::resolveFlexBasis( diff --git a/yoga/node/Node.h b/yoga/node/Node.h index a36e3e6882..5ae7d432eb 100644 --- a/yoga/node/Node.h +++ b/yoga/node/Node.h @@ -172,7 +172,7 @@ class YG_EXPORT Node : public ::YGNode { return isDirty_; } - Style::Length getProcessedDimension(Dimension dimension) const { + Style::SizeLength getProcessedDimension(Dimension dimension) const { return processedDimensions_[static_cast(dimension)]; } @@ -268,7 +268,7 @@ class YG_EXPORT Node : public ::YGNode { void setPosition(Direction direction, float ownerWidth, float ownerHeight); // Other methods - Style::Length processFlexBasis() const; + Style::SizeLength processFlexBasis() const; FloatOptional resolveFlexBasis( Direction direction, FlexDirection flexDirection, @@ -322,8 +322,8 @@ class YG_EXPORT Node : public ::YGNode { Node* owner_ = nullptr; std::vector children_; const Config* config_; - std::array processedDimensions_{ - {StyleLength::undefined(), StyleLength::undefined()}}; + std::array processedDimensions_{ + {StyleSizeLength::undefined(), StyleSizeLength::undefined()}}; }; inline Node* resolveRef(const YGNodeRef ref) { diff --git a/yoga/style/Style.h b/yoga/style/Style.h index 73203e6cca..923b268bf8 100644 --- a/yoga/style/Style.h +++ b/yoga/style/Style.h @@ -30,6 +30,7 @@ #include #include #include +#include #include namespace facebook::yoga { @@ -37,6 +38,7 @@ namespace facebook::yoga { class YG_EXPORT Style { public: using Length = StyleLength; + using SizeLength = StyleSizeLength; static constexpr float DefaultFlexGrow = 0.0f; static constexpr float DefaultFlexShrink = 0.0f; @@ -133,10 +135,10 @@ class YG_EXPORT Style { pool_.store(flexShrink_, value); } - Style::Length flexBasis() const { - return pool_.getLength(flexBasis_); + Style::SizeLength flexBasis() const { + return pool_.getSize(flexBasis_); } - void setFlexBasis(Style::Length value) { + void setFlexBasis(Style::SizeLength value) { pool_.store(flexBasis_, value); } @@ -175,17 +177,17 @@ class YG_EXPORT Style { pool_.store(gap_[yoga::to_underlying(gutter)], value); } - Style::Length dimension(Dimension axis) const { - return pool_.getLength(dimensions_[yoga::to_underlying(axis)]); + Style::SizeLength dimension(Dimension axis) const { + return pool_.getSize(dimensions_[yoga::to_underlying(axis)]); } - void setDimension(Dimension axis, Style::Length value) { + void setDimension(Dimension axis, Style::SizeLength value) { pool_.store(dimensions_[yoga::to_underlying(axis)], value); } - Style::Length minDimension(Dimension axis) const { - return pool_.getLength(minDimensions_[yoga::to_underlying(axis)]); + Style::SizeLength minDimension(Dimension axis) const { + return pool_.getSize(minDimensions_[yoga::to_underlying(axis)]); } - void setMinDimension(Dimension axis, Style::Length value) { + void setMinDimension(Dimension axis, Style::SizeLength value) { pool_.store(minDimensions_[yoga::to_underlying(axis)], value); } @@ -207,10 +209,10 @@ class YG_EXPORT Style { : FloatOptional{0.0}); } - Style::Length maxDimension(Dimension axis) const { - return pool_.getLength(maxDimensions_[yoga::to_underlying(axis)]); + Style::SizeLength maxDimension(Dimension axis) const { + return pool_.getSize(maxDimensions_[yoga::to_underlying(axis)]); } - void setMaxDimension(Dimension axis, Style::Length value) { + void setMaxDimension(Dimension axis, Style::SizeLength value) { pool_.store(maxDimensions_[yoga::to_underlying(axis)], value); } diff --git a/yoga/style/StyleLength.h b/yoga/style/StyleLength.h index 7cc42d9eb5..01e69718b2 100644 --- a/yoga/style/StyleLength.h +++ b/yoga/style/StyleLength.h @@ -19,13 +19,11 @@ namespace facebook::yoga { * 3. A CSS value: * a. value (e.g. 10px) * b. value of a reference - * 4. (soon) A math function which returns a value * * References: * 1. https://www.w3.org/TR/css-values-4/#lengths * 2. https://www.w3.org/TR/css-values-4/#percentage-value * 3. https://www.w3.org/TR/css-values-4/#mixed-percentages - * 4. https://www.w3.org/TR/css-values-4/#math */ class StyleLength { public: @@ -59,6 +57,14 @@ class StyleLength { return unit_ == Unit::Undefined; } + constexpr bool isPoints() const { + return unit_ == Unit::Point; + } + + constexpr bool isPercent() const { + return unit_ == Unit::Percent; + } + constexpr bool isDefined() const { return !isUndefined(); } @@ -67,10 +73,6 @@ class StyleLength { return value_; } - constexpr Unit unit() const { - return unit_; - } - constexpr FloatOptional resolve(float referenceLength) { switch (unit_) { case Unit::Point: @@ -90,6 +92,11 @@ class StyleLength { return value_ == rhs.value_ && unit_ == rhs.unit_; } + constexpr bool inexactEquals(const StyleLength& other) const { + return unit_ == other.unit_ && + facebook::yoga::inexactEquals(value_, other.value_); + } + private: // We intentionally do not allow direct construction using value and unit, to // avoid invalid, or redundant combinations. @@ -101,7 +108,7 @@ class StyleLength { }; inline bool inexactEquals(const StyleLength& a, const StyleLength& b) { - return a.unit() == b.unit() && inexactEquals(a.value(), b.value()); + return a.inexactEquals(b); } } // namespace facebook::yoga diff --git a/yoga/style/StyleSizeLength.h b/yoga/style/StyleSizeLength.h new file mode 100644 index 0000000000..8dc4f24013 --- /dev/null +++ b/yoga/style/StyleSizeLength.h @@ -0,0 +1,139 @@ +/* + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#pragma once + +#include +#include + +namespace facebook::yoga { + +/** + * This class represents a CSS Value for sizes (e.g. width, height, min-width, + * etc.). It may be one of: + * 1. Undefined + * 2. A keyword (e.g. auto, max-content, stretch, etc.) + * 3. A CSS value: + * a. value (e.g. 10px) + * b. value of a reference + * + * References: + * 1. https://www.w3.org/TR/css-values-4/#lengths + * 2. https://www.w3.org/TR/css-values-4/#percentage-value + * 3. https://www.w3.org/TR/css-values-4/#mixed-percentages + */ +class StyleSizeLength { + public: + constexpr StyleSizeLength() = default; + + constexpr static StyleSizeLength points(float value) { + return yoga::isUndefined(value) || yoga::isinf(value) + ? undefined() + : StyleSizeLength{FloatOptional{value}, Unit::Point}; + } + + constexpr static StyleSizeLength percent(float value) { + return yoga::isUndefined(value) || yoga::isinf(value) + ? undefined() + : StyleSizeLength{FloatOptional{value}, Unit::Percent}; + } + + constexpr static StyleSizeLength ofAuto() { + return StyleSizeLength{{}, Unit::Auto}; + } + + constexpr static StyleSizeLength ofMaxContent() { + return StyleSizeLength{{}, Unit::MaxContent}; + } + + constexpr static StyleSizeLength ofFitContent() { + return StyleSizeLength{{}, Unit::FitContent}; + } + + constexpr static StyleSizeLength ofStretch() { + return StyleSizeLength{{}, Unit::Stretch}; + } + + constexpr static StyleSizeLength undefined() { + return StyleSizeLength{{}, Unit::Undefined}; + } + + constexpr bool isAuto() const { + return unit_ == Unit::Auto; + } + + constexpr bool isMaxContent() const { + return unit_ == Unit::MaxContent; + } + + constexpr bool isFitContent() const { + return unit_ == Unit::FitContent; + } + + constexpr bool isStretch() const { + return unit_ == Unit::Stretch; + } + + constexpr bool isUndefined() const { + return unit_ == Unit::Undefined; + } + + constexpr bool isDefined() const { + return !isUndefined(); + } + + constexpr bool isPoints() const { + return unit_ == Unit::Point; + } + + constexpr bool isPercent() const { + return unit_ == Unit::Percent; + } + + constexpr FloatOptional value() const { + return value_; + } + + constexpr FloatOptional resolve(float referenceLength) { + switch (unit_) { + case Unit::Point: + return value_; + case Unit::Percent: + return FloatOptional{value_.unwrap() * referenceLength * 0.01f}; + default: + return FloatOptional{}; + } + } + + explicit constexpr operator YGValue() const { + return YGValue{value_.unwrap(), unscopedEnum(unit_)}; + } + + constexpr bool operator==(const StyleSizeLength& rhs) const { + return value_ == rhs.value_ && unit_ == rhs.unit_; + } + + constexpr bool inexactEquals(const StyleSizeLength& other) const { + return unit_ == other.unit_ && + facebook::yoga::inexactEquals(value_, other.value_); + } + + private: + // We intentionally do not allow direct construction using value and unit, to + // avoid invalid, or redundant combinations. + constexpr StyleSizeLength(FloatOptional value, Unit unit) + : value_(value), unit_(unit) {} + + FloatOptional value_{}; + Unit unit_{Unit::Undefined}; +}; + +inline bool inexactEquals(const StyleSizeLength& a, const StyleSizeLength& b) { + return a.inexactEquals(b); +} + +} // namespace facebook::yoga diff --git a/yoga/style/StyleValueHandle.h b/yoga/style/StyleValueHandle.h index f4b97f0a9f..d9c6ae0579 100644 --- a/yoga/style/StyleValueHandle.h +++ b/yoga/style/StyleValueHandle.h @@ -62,8 +62,16 @@ class StyleValueHandle { Percent, Number, Auto, + Keyword }; + // Intentionally leaving out auto as a fast path + enum class Keyword : uint8_t { MaxContent, FitContent, Stretch }; + + constexpr bool isKeyword(Keyword keyword) const { + return type() == Type::Keyword && value() == static_cast(keyword); + } + constexpr Type type() const { return static_cast(repr_ & kHandleTypeMask); } diff --git a/yoga/style/StyleValuePool.h b/yoga/style/StyleValuePool.h index 597eae4c43..dfee30ade9 100644 --- a/yoga/style/StyleValuePool.h +++ b/yoga/style/StyleValuePool.h @@ -13,6 +13,7 @@ #include #include #include +#include #include namespace facebook::yoga { @@ -32,13 +33,30 @@ class StyleValuePool { } else if (length.isAuto()) { handle.setType(StyleValueHandle::Type::Auto); } else { - auto type = length.unit() == Unit::Point - ? StyleValueHandle::Type::Point - : StyleValueHandle::Type::Percent; + auto type = length.isPoints() ? StyleValueHandle::Type::Point + : StyleValueHandle::Type::Percent; storeValue(handle, length.value().unwrap(), type); } } + void store(StyleValueHandle& handle, StyleSizeLength sizeValue) { + if (sizeValue.isUndefined()) { + handle.setType(StyleValueHandle::Type::Undefined); + } else if (sizeValue.isAuto()) { + handle.setType(StyleValueHandle::Type::Auto); + } else if (sizeValue.isMaxContent()) { + storeKeyword(handle, StyleValueHandle::Keyword::MaxContent); + } else if (sizeValue.isStretch()) { + storeKeyword(handle, StyleValueHandle::Keyword::Stretch); + } else if (sizeValue.isFitContent()) { + storeKeyword(handle, StyleValueHandle::Keyword::FitContent); + } else { + auto type = sizeValue.isPoints() ? StyleValueHandle::Type::Point + : StyleValueHandle::Type::Percent; + storeValue(handle, sizeValue.value().unwrap(), type); + } + } + void store(StyleValueHandle& handle, FloatOptional number) { if (number.isUndefined()) { handle.setType(StyleValueHandle::Type::Undefined); @@ -66,6 +84,31 @@ class StyleValuePool { } } + StyleSizeLength getSize(StyleValueHandle handle) const { + if (handle.isUndefined()) { + return StyleSizeLength::undefined(); + } else if (handle.isAuto()) { + return StyleSizeLength::ofAuto(); + } else if (handle.isKeyword(StyleValueHandle::Keyword::MaxContent)) { + return StyleSizeLength::ofMaxContent(); + } else if (handle.isKeyword(StyleValueHandle::Keyword::FitContent)) { + return StyleSizeLength::ofFitContent(); + } else if (handle.isKeyword(StyleValueHandle::Keyword::Stretch)) { + return StyleSizeLength::ofStretch(); + } else { + assert( + handle.type() == StyleValueHandle::Type::Point || + handle.type() == StyleValueHandle::Type::Percent); + float value = (handle.isValueIndexed()) + ? std::bit_cast(buffer_.get32(handle.value())) + : unpackInlineInteger(handle.value()); + + return handle.type() == StyleValueHandle::Type::Point + ? StyleSizeLength::points(value) + : StyleSizeLength::percent(value); + } + } + FloatOptional getNumber(StyleValueHandle handle) const { if (handle.isUndefined()) { return FloatOptional{}; @@ -98,6 +141,20 @@ class StyleValuePool { } } + void storeKeyword( + StyleValueHandle& handle, + StyleValueHandle::Keyword keyword) { + handle.setType(StyleValueHandle::Type::Keyword); + + if (handle.isValueIndexed()) { + auto newIndex = + buffer_.replace(handle.value(), static_cast(keyword)); + handle.setValue(newIndex); + } else { + handle.setValue(static_cast(keyword)); + } + } + static constexpr bool isIntegerPackable(float f) { constexpr uint16_t kMaxInlineAbsValue = (1 << 11) - 1;