Java bindings for setAlwaysFormsContainingBlock

java/com/facebook/yoga/YogaNative.java

@@ -114,4 +114,5 @@ public class YogaNative {
   static native void jni_YGNodePrintJNI(long nativePointer);
   static native void jni_YGNodeSetStyleInputsJNI(long nativePointer, float[] styleInputsArray, int size);
   static native long jni_YGNodeCloneJNI(long nativePointer);
+  static native void jni_YGNodeSetAlwaysFormsContainingBlockJNI(long nativePointer, boolean alwaysFormContainingBlock);
 }

java/com/facebook/yoga/YogaNode.java

@@ -226,4 +226,6 @@ public interface Inputs {
   public abstract YogaNode cloneWithoutChildren();
 
   public abstract YogaNode cloneWithChildren();
+
+  public abstract void setAlwaysFormsContainingBlock(boolean alwaysFormsContainingBlock);
 }

java/com/facebook/yoga/YogaNodeJNIBase.java

@@ -504,6 +504,11 @@ public void setMeasureFunction(YogaMeasureFunction measureFunction) {
     YogaNative.jni_YGNodeSetHasMeasureFuncJNI(mNativePointer, measureFunction != null);
   }
 
+  @Override
+  public void setAlwaysFormsContainingBlock(boolean alwaysFormsContainingBlock) {
+    YogaNative.jni_YGNodeSetAlwaysFormsContainingBlockJNI(mNativePointer, alwaysFormsContainingBlock);
+  }
+
   // Implementation Note: Why this method needs to stay final
   //
   // We cache the jmethodid for this method in Yoga code. This means that even if a subclass

java/jni/YGJNIVanilla.cpp

@@ -681,6 +681,15 @@ static void jni_YGNodeSetHasBaselineFuncJNI(
       hasBaselineFunc ? YGJNIBaselineFunc : nullptr);
 }
 
+static void jni_YGNodeSetAlwaysFormsContainingBlockJNI(
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
+    jlong nativePointer,
+    jboolean alwaysFormsContainingBlock) {
+  YGNodeSetAlwaysFormsContainingBlock(
+      _jlong2YGNodeRef(nativePointer), alwaysFormsContainingBlock);
+}
+
 static void
 jni_YGNodePrintJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
 #ifdef DEBUG
@@ -958,6 +967,9 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeSetHasBaselineFuncJNI",
      "(JZ)V",
      (void*)jni_YGNodeSetHasBaselineFuncJNI},
+    {"jni_YGNodeSetAlwaysFormsContainingBlockJNI",
+     "(JZ)V",
+     (void*)jni_YGNodeSetAlwaysFormsContainingBlockJNI},
     {"jni_YGNodePrintJNI", "(J)V", (void*)jni_YGNodePrintJNI},
     {"jni_YGNodeCloneJNI", "(J)J", (void*)jni_YGNodeCloneJNI},
 };

yoga/YGNode.cpp

@@ -328,6 +328,12 @@ void YGNodeSetPrintFunc(YGNodeRef node, YGPrintFunc printFunc) {
   resolveRef(node)->setPrintFunc(printFunc);
 }
 
+void YGNodeSetAlwaysFormsContainingBlock(
+    YGNodeRef node,
+    bool alwaysFormsContainingBlock) {
+  resolveRef(node)->setAlwaysFormsContainingBlock(alwaysFormsContainingBlock);
+}
+
 #ifdef DEBUG
 void YGNodePrint(const YGNodeConstRef node, const YGPrintOptions options) {
   yoga::print(resolveRef(node), scopedEnum(options));

yoga/YGNode.h

@@ -270,6 +270,17 @@ typedef void (*YGPrintFunc)(YGNodeConstRef node);
  */
 YG_EXPORT void YGNodeSetPrintFunc(YGNodeRef node, YGPrintFunc printFunc);
 
+/**
+ * Make it so that this node will always form a containing block for any
+ * descendant nodes. This is useful for when a node has a property outside of
+ * of Yoga that will form a containing block. For example, transforms or some of
+ * the others listed in
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block
+ */
+YG_EXPORT void YGNodeSetAlwaysFormsContainingBlock(
+    YGNodeRef node,
+    bool alwaysFormsContainingBlock);
+
 /**
  * Print a node to log output.
  */

yoga/algorithm/AbsoluteLayout.cpp

@@ -528,7 +528,9 @@ void layoutAbsoluteDescendants(
       if (needsTrailingPosition(crossAxis)) {
         setChildTrailingPosition(currentNode, child, crossAxis);
       }
-    } else if (child->getStyle().positionType() == PositionType::Static) {
+    } else if (
+        child->getStyle().positionType() == PositionType::Static &&
+        !child->alwaysFormsContainingBlock()) {
       const Direction childDirection =
           child->resolveDirection(currentNodeDirection);
       const float childMainOffsetFromContainingBlock =

yoga/algorithm/CalculateLayout.cpp

@@ -2034,7 +2034,7 @@ static void calculateLayoutImpl(
       // Let the containing block layout its absolute descendants. By definition
       // the containing block will not be static unless we are at the root.
       if (node->getStyle().positionType() != PositionType::Static ||
-          depth == 1) {
+          node->alwaysFormsContainingBlock() || depth == 1) {
         layoutAbsoluteDescendants(
             node,
             node,

yoga/node/Node.h

@@ -48,6 +48,10 @@ class YG_EXPORT Node : public ::YGNode {
     return context_;
   }
 
+  bool alwaysFormsContainingBlock() const {
+    return alwaysFormsContainingBlock_;
+  }
+
   void print();
 
   bool getHasNewLayout() const {
@@ -242,6 +246,10 @@ class YG_EXPORT Node : public ::YGNode {
     context_ = context;
   }
 
+  void setAlwaysFormsContainingBlock(bool alwaysFormsContainingBlock) {
+    alwaysFormsContainingBlock_ = alwaysFormsContainingBlock;
+  }
+
   void setPrintFunc(YGPrintFunc printFunc) {
     printFunc_ = printFunc;
   }
@@ -369,6 +377,7 @@ class YG_EXPORT Node : public ::YGNode {
   bool hasNewLayout_ : 1 = true;
   bool isReferenceBaseline_ : 1 = false;
   bool isDirty_ : 1 = false;
+  bool alwaysFormsContainingBlock_ : 1 = false;
   NodeType nodeType_ : bitCount<NodeType>() = NodeType::Default;
   void* context_ = nullptr;
   YGMeasureFunc measureFunc_ = {nullptr};