From b721c125163fa2cb422c3eec08a671254c98f07c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felix=20Oghin=C4=83?= Date: Tue, 13 Oct 2015 06:45:18 -0700 Subject: [PATCH] import latest changes from github Differential Revision: D2536028 fb-gh-sync-id: 2d28b10f06b4ab3a9113b7870e58faf6debba9b6 --- .../com/facebook/csslayout/CSSLayout.java | 2 +- .../java/com/facebook/csslayout/CSSNode.java | 40 ++-- .../java/com/facebook/csslayout/CSSStyle.java | 62 ++++-- .../com/facebook/csslayout/LayoutEngine.java | 191 +++++++++--------- .../main/java/com/facebook/csslayout/README | 2 +- .../com/facebook/csslayout/README.facebook | 2 +- .../java/com/facebook/csslayout/Spacing.java | 15 +- 7 files changed, 180 insertions(+), 134 deletions(-) diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayout.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayout.java index 8c3af63ad..165c5f96d 100644 --- a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayout.java +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayout.java @@ -7,7 +7,7 @@ */ // NOTE: this file is auto-copied from https://github.com/facebook/css-layout -// @generated SignedSource<<638f16255d86b878b0377e1070cc2b44>> +// @generated SignedSource<<1e547b3af02a275fe73089e5a0a172c5>> package com.facebook.csslayout; diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java index e2a563818..4fc69668a 100644 --- a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java @@ -7,7 +7,7 @@ */ // NOTE: this file is auto-copied from https://github.com/facebook/css-layout -// @generated SignedSource<<560f2fd13ec8e1100a71958529146055>> +// @generated SignedSource<> package com.facebook.csslayout; @@ -118,7 +118,7 @@ public class CSSNode { } public void setMeasureFunction(MeasureFunction measureFunction) { - if (!valuesEqual(mMeasureFunction, measureFunction)) { + if (mMeasureFunction != measureFunction) { mMeasureFunction = measureFunction; dirty(); } @@ -224,57 +224,50 @@ public class CSSNode { return FloatUtil.floatsEqual(f1, f2); } - protected boolean valuesEqual(@Nullable T o1, @Nullable T o2) { - if (o1 == null) { - return o2 == null; - } - return o1.equals(o2); - } - public void setDirection(CSSDirection direction) { - if (!valuesEqual(style.direction, direction)) { + if (style.direction != direction) { style.direction = direction; dirty(); } } public void setFlexDirection(CSSFlexDirection flexDirection) { - if (!valuesEqual(style.flexDirection, flexDirection)) { + if (style.flexDirection != flexDirection) { style.flexDirection = flexDirection; dirty(); } } public void setJustifyContent(CSSJustify justifyContent) { - if (!valuesEqual(style.justifyContent, justifyContent)) { + if (style.justifyContent != justifyContent) { style.justifyContent = justifyContent; dirty(); } } public void setAlignItems(CSSAlign alignItems) { - if (!valuesEqual(style.alignItems, alignItems)) { + if (style.alignItems != alignItems) { style.alignItems = alignItems; dirty(); } } public void setAlignSelf(CSSAlign alignSelf) { - if (!valuesEqual(style.alignSelf, alignSelf)) { + if (style.alignSelf != alignSelf) { style.alignSelf = alignSelf; dirty(); } } public void setPositionType(CSSPositionType positionType) { - if (!valuesEqual(style.positionType, positionType)) { + if (style.positionType != positionType) { style.positionType = positionType; dirty(); } } public void setWrap(CSSWrap flexWrap) { - if (!valuesEqual(style.flexWrap, flexWrap)) { + if (style.flexWrap != flexWrap) { style.flexWrap = flexWrap; dirty(); } @@ -403,4 +396,19 @@ public class CSSNode { dirty(); } } + + /** + * Resets this instance to its default state. This method is meant to be used when + * recycling {@link CSSNode} instances. + */ + public void reset() { + if (mParent != null || (mChildren != null && mChildren.size() > 0)) { + throw new IllegalStateException("You should not reset an attached CSSNode"); + } + + style.reset(); + layout.resetResult(); + lineIndex = 0; + mLayoutState = LayoutState.DIRTY; + } } diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSStyle.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSStyle.java index 9d16a11f3..6170720ce 100644 --- a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSStyle.java +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSStyle.java @@ -7,44 +7,66 @@ */ // NOTE: this file is auto-copied from https://github.com/facebook/css-layout -// @generated SignedSource<<2fc400ad927a17e1b13430210531ce86>> +// @generated SignedSource<<4c7c75ffd4800aee843a5f5828f3e3ab>> package com.facebook.csslayout; +import java.util.Arrays; + /** * The CSS style definition for a {@link CSSNode}. */ public class CSSStyle { - public CSSDirection direction = CSSDirection.INHERIT; - public CSSFlexDirection flexDirection = CSSFlexDirection.COLUMN; - public CSSJustify justifyContent = CSSJustify.FLEX_START; - public CSSAlign alignContent = CSSAlign.FLEX_START; - public CSSAlign alignItems = CSSAlign.STRETCH; - public CSSAlign alignSelf = CSSAlign.AUTO; - public CSSPositionType positionType = CSSPositionType.RELATIVE; - public CSSWrap flexWrap = CSSWrap.NOWRAP; + public CSSDirection direction; + public CSSFlexDirection flexDirection; + public CSSJustify justifyContent; + public CSSAlign alignContent; + public CSSAlign alignItems; + public CSSAlign alignSelf; + public CSSPositionType positionType; + public CSSWrap flexWrap; public float flex; public Spacing margin = new Spacing(); public Spacing padding = new Spacing(); public Spacing border = new Spacing(); - public float[] position = { - CSSConstants.UNDEFINED, - CSSConstants.UNDEFINED, - CSSConstants.UNDEFINED, - CSSConstants.UNDEFINED, - }; - - public float[] dimensions = { - CSSConstants.UNDEFINED, - CSSConstants.UNDEFINED, - }; + public float[] position = new float[4]; + public float[] dimensions = new float[2]; public float minWidth = CSSConstants.UNDEFINED; public float minHeight = CSSConstants.UNDEFINED; public float maxWidth = CSSConstants.UNDEFINED; public float maxHeight = CSSConstants.UNDEFINED; + + CSSStyle() { + reset(); + } + + void reset() { + direction = CSSDirection.INHERIT; + flexDirection = CSSFlexDirection.COLUMN; + justifyContent = CSSJustify.FLEX_START; + alignContent = CSSAlign.FLEX_START; + alignItems = CSSAlign.STRETCH; + alignSelf = CSSAlign.AUTO; + positionType = CSSPositionType.RELATIVE; + flexWrap = CSSWrap.NOWRAP; + flex = 0f; + + margin.reset();; + padding.reset(); + border.reset(); + + Arrays.fill(position, CSSConstants.UNDEFINED); + Arrays.fill(dimensions, CSSConstants.UNDEFINED); + + minWidth = CSSConstants.UNDEFINED; + minHeight = CSSConstants.UNDEFINED; + + maxWidth = CSSConstants.UNDEFINED; + maxHeight = CSSConstants.UNDEFINED; + } } diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/LayoutEngine.java b/ReactAndroid/src/main/java/com/facebook/csslayout/LayoutEngine.java index 344131d06..30e14f052 100644 --- a/ReactAndroid/src/main/java/com/facebook/csslayout/LayoutEngine.java +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/LayoutEngine.java @@ -7,7 +7,7 @@ */ // NOTE: this file is auto-copied from https://github.com/facebook/css-layout -// @generated SignedSource<> +// @generated SignedSource<> package com.facebook.csslayout; @@ -109,7 +109,7 @@ public class LayoutEngine { return; } // We only run if there's a width or height defined - if (Float.isNaN(node.style.dimensions[dim[axis]]) || + if (Float.isNaN(node.style.dimensions[dim[axis]]) || node.style.dimensions[dim[axis]] <= 0.0) { return; } @@ -223,19 +223,19 @@ public class LayoutEngine { } /** START_GENERATED **/ - + CSSDirection direction = resolveDirection(node, parentDirection); int mainAxis = resolveAxis(getFlexDirection(node), direction); int crossAxis = getCrossFlexDirection(mainAxis, direction); int resolvedRowAxis = resolveAxis(CSS_FLEX_DIRECTION_ROW, direction); - + // Handle width and height style attributes setDimensionFromStyle(node, mainAxis); setDimensionFromStyle(node, crossAxis); - + // Set the resolved resolution in the node's layout node.layout.direction = direction; - + // The position is set by the parent, but we need to complete it with a // delta composed of the margin and left/top/right/bottom node.layout.position[leading[mainAxis]] += node.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + @@ -246,15 +246,15 @@ public class LayoutEngine { getRelativePosition(node, crossAxis); node.layout.position[trailing[crossAxis]] += node.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]) + getRelativePosition(node, crossAxis); - + // Inline immutable values from the target node to avoid excessive method // invocations during the layout calculation. int childCount = node.getChildCount(); float paddingAndBorderAxisResolvedRow = ((node.style.padding.getWithFallback(leadingSpacing[resolvedRowAxis], leading[resolvedRowAxis]) + node.style.border.getWithFallback(leadingSpacing[resolvedRowAxis], leading[resolvedRowAxis])) + (node.style.padding.getWithFallback(trailingSpacing[resolvedRowAxis], trailing[resolvedRowAxis]) + node.style.border.getWithFallback(trailingSpacing[resolvedRowAxis], trailing[resolvedRowAxis]))); - + if (isMeasureDefined(node)) { boolean isResolvedRowDimDefined = !Float.isNaN(node.layout.dimensions[dim[resolvedRowAxis]]); - + float width = CSSConstants.UNDEFINED; if ((!Float.isNaN(node.style.dimensions[dim[resolvedRowAxis]]) && node.style.dimensions[dim[resolvedRowAxis]] >= 0.0)) { width = node.style.dimensions[DIMENSION_WIDTH]; @@ -265,18 +265,18 @@ public class LayoutEngine { (node.style.margin.getWithFallback(leadingSpacing[resolvedRowAxis], leading[resolvedRowAxis]) + node.style.margin.getWithFallback(trailingSpacing[resolvedRowAxis], trailing[resolvedRowAxis])); } width -= paddingAndBorderAxisResolvedRow; - + // We only need to give a dimension for the text if we haven't got any // for it computed yet. It can either be from the style attribute or because // the element is flexible. boolean isRowUndefined = !(!Float.isNaN(node.style.dimensions[dim[resolvedRowAxis]]) && node.style.dimensions[dim[resolvedRowAxis]] >= 0.0) && !isResolvedRowDimDefined; boolean isColumnUndefined = !(!Float.isNaN(node.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]]) && node.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] >= 0.0) && Float.isNaN(node.layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]]); - + // Let's not measure the text if we already know both dimensions if (isRowUndefined || isColumnUndefined) { MeasureOutput measureDim = node.measure( - + layoutContext.measureOutput, width ); @@ -293,33 +293,33 @@ public class LayoutEngine { return; } } - + boolean isNodeFlexWrap = (node.style.flexWrap == CSSWrap.WRAP); - + CSSJustify justifyContent = node.style.justifyContent; - + float leadingPaddingAndBorderMain = (node.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + node.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis])); float leadingPaddingAndBorderCross = (node.style.padding.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + node.style.border.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis])); float paddingAndBorderAxisMain = ((node.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + node.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis])) + (node.style.padding.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + node.style.border.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]))); float paddingAndBorderAxisCross = ((node.style.padding.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + node.style.border.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis])) + (node.style.padding.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]) + node.style.border.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]))); - + boolean isMainDimDefined = !Float.isNaN(node.layout.dimensions[dim[mainAxis]]); boolean isCrossDimDefined = !Float.isNaN(node.layout.dimensions[dim[crossAxis]]); boolean isMainRowDirection = (mainAxis == CSS_FLEX_DIRECTION_ROW || mainAxis == CSS_FLEX_DIRECTION_ROW_REVERSE); - + int i; int ii; CSSNode child; int axis; - + CSSNode firstAbsoluteChild = null; CSSNode currentAbsoluteChild = null; - + float definedMainDim = CSSConstants.UNDEFINED; if (isMainDimDefined) { definedMainDim = node.layout.dimensions[dim[mainAxis]] - paddingAndBorderAxisMain; } - + // We want to execute the next two loops one per line with flex-wrap int startLine = 0; int endLine = 0; @@ -331,19 +331,19 @@ public class LayoutEngine { int linesCount = 0; while (endLine < childCount) { // Layout non flexible children and count children by type - + // mainContentDim is accumulation of the dimensions and margin of all the // non flexible children. This will be used in order to either set the // dimensions of the node if none already exist, or to compute the // remaining space left for the flexible children. float mainContentDim = 0; - + // There are three kind of children, non flexible, flexible and absolute. // We need to know how many there are in order to distribute the space. int flexibleChildrenCount = 0; float totalFlexible = 0; int nonFlexibleChildrenCount = 0; - + // Use the line loop to position children in the main axis for as long // as they are using a simple stacking behaviour. Children that are // immediately stacked in the initial loop will not be touched again @@ -352,30 +352,30 @@ public class LayoutEngine { (isMainDimDefined && justifyContent == CSSJustify.FLEX_START) || (!isMainDimDefined && justifyContent != CSSJustify.CENTER); int firstComplexMain = (isSimpleStackMain ? childCount : startLine); - + // Use the initial line loop to position children in the cross axis for // as long as they are relatively positioned with alignment STRETCH or // FLEX_START. Children that are immediately stacked in the initial loop // will not be touched again in . boolean isSimpleStackCross = true; int firstComplexCross = childCount; - + CSSNode firstFlexChild = null; CSSNode currentFlexChild = null; - + float mainDim = leadingPaddingAndBorderMain; float crossDim = 0; - + float maxWidth; for (i = startLine; i < childCount; ++i) { child = node.getChildAt(i); child.lineIndex = linesCount; - + child.nextAbsoluteChild = null; child.nextFlexChild = null; - + CSSAlign alignItem = getAlignItem(node, child); - + // Pre-fill cross axis dimensions when the child is using stretch before // we call the recursive layout pass if (alignItem == CSSAlign.STRETCH && @@ -398,7 +398,7 @@ public class LayoutEngine { currentAbsoluteChild.nextAbsoluteChild = child; } currentAbsoluteChild = child; - + // Pre-fill dimensions when using absolute position and both offsets for the axis are defined (either both // left and right or top and bottom). for (ii = 0; ii < 2; ii++) { @@ -419,15 +419,15 @@ public class LayoutEngine { } } } - + float nextContentDim = 0; - + // It only makes sense to consider a child flexible if we have a computed // dimension for the node. if (isMainDimDefined && (child.style.positionType == CSSPositionType.RELATIVE && child.style.flex > 0)) { flexibleChildrenCount++; totalFlexible += child.style.flex; - + // Store a private linked list of flexible children so that we can // efficiently traverse them later. if (firstFlexChild == null) { @@ -437,14 +437,14 @@ public class LayoutEngine { currentFlexChild.nextFlexChild = child; } currentFlexChild = child; - + // Even if we don't know its exact size yet, we already know the padding, // border and margin. We'll use this partial information, which represents // the smallest possible size for the child, to compute the remaining // available space. nextContentDim = ((child.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis])) + (child.style.padding.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + child.style.border.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]))) + (child.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.margin.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis])); - + } else { maxWidth = CSSConstants.UNDEFINED; if (!isMainRowDirection) { @@ -457,12 +457,12 @@ public class LayoutEngine { paddingAndBorderAxisResolvedRow; } } - + // This is the main recursive call. We layout non flexible children. if (alreadyComputedNextLayout == 0) { layoutNode(layoutContext, child, maxWidth, direction); } - + // Absolute positioned elements do not take part of the layout, so we // don't use them to compute mainContentDim if (child.style.positionType == CSSPositionType.RELATIVE) { @@ -471,7 +471,7 @@ public class LayoutEngine { nextContentDim = (child.layout.dimensions[dim[mainAxis]] + child.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.margin.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis])); } } - + // The element we are about to add would make us go to the next line if (isNodeFlexWrap && isMainDimDefined && @@ -483,7 +483,7 @@ public class LayoutEngine { alreadyComputedNextLayout = 1; break; } - + // Disable simple stacking in the main axis for the current line as // we found a non-trivial child. The remaining children will be laid out // in . @@ -492,7 +492,7 @@ public class LayoutEngine { isSimpleStackMain = false; firstComplexMain = i; } - + // Disable simple stacking in the cross axis for the current line as // we found a non-trivial child. The remaining children will be laid out // in . @@ -503,37 +503,37 @@ public class LayoutEngine { isSimpleStackCross = false; firstComplexCross = i; } - + if (isSimpleStackMain) { child.layout.position[pos[mainAxis]] += mainDim; if (isMainDimDefined) { child.layout.position[trailing[mainAxis]] = node.layout.dimensions[dim[mainAxis]] - child.layout.dimensions[dim[mainAxis]] - child.layout.position[pos[mainAxis]]; } - + mainDim += (child.layout.dimensions[dim[mainAxis]] + child.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.margin.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis])); crossDim = Math.max(crossDim, boundAxis(child, crossAxis, (child.layout.dimensions[dim[crossAxis]] + child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + child.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis])))); } - + if (isSimpleStackCross) { child.layout.position[pos[crossAxis]] += linesCrossDim + leadingPaddingAndBorderCross; if (isCrossDimDefined) { child.layout.position[trailing[crossAxis]] = node.layout.dimensions[dim[crossAxis]] - child.layout.dimensions[dim[crossAxis]] - child.layout.position[pos[crossAxis]]; } } - + alreadyComputedNextLayout = 0; mainContentDim += nextContentDim; endLine = i + 1; } - + // Layout flexible children and allocate empty space - + // In order to position the elements in the main axis, we have two // controls. The space between the beginning and the first element // and the space between each two elements. float leadingMainDim = 0; float betweenMainDim = 0; - + // The remaining available space that needs to be allocated float remainingMainDim = 0; if (isMainDimDefined) { @@ -541,14 +541,14 @@ public class LayoutEngine { } else { remainingMainDim = Math.max(mainContentDim, 0) - mainContentDim; } - + // If there are flexible children in the mix, they are going to fill the // remaining space if (flexibleChildrenCount != 0) { float flexibleMainDim = remainingMainDim / totalFlexible; float baseMainDim; float boundMainDim; - + // If the flex share of remaining space doesn't meet min/max bounds, // remove this child from flex calculations. currentFlexChild = firstFlexChild; @@ -556,22 +556,22 @@ public class LayoutEngine { baseMainDim = flexibleMainDim * currentFlexChild.style.flex + ((currentFlexChild.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + currentFlexChild.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis])) + (currentFlexChild.style.padding.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + currentFlexChild.style.border.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]))); boundMainDim = boundAxis(currentFlexChild, mainAxis, baseMainDim); - + if (baseMainDim != boundMainDim) { remainingMainDim -= boundMainDim; totalFlexible -= currentFlexChild.style.flex; } - + currentFlexChild = currentFlexChild.nextFlexChild; } flexibleMainDim = remainingMainDim / totalFlexible; - + // The non flexible children can overflow the container, in this case // we should just assume that there is no space available. if (flexibleMainDim < 0) { flexibleMainDim = 0; } - + currentFlexChild = firstFlexChild; while (currentFlexChild != null) { // At this point we know the final size of the element in the main @@ -580,7 +580,7 @@ public class LayoutEngine { flexibleMainDim * currentFlexChild.style.flex + ((currentFlexChild.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + currentFlexChild.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis])) + (currentFlexChild.style.padding.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + currentFlexChild.style.border.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]))) ); - + maxWidth = CSSConstants.UNDEFINED; if ((!Float.isNaN(node.style.dimensions[dim[resolvedRowAxis]]) && node.style.dimensions[dim[resolvedRowAxis]] >= 0.0)) { maxWidth = node.layout.dimensions[dim[resolvedRowAxis]] - @@ -590,15 +590,15 @@ public class LayoutEngine { (node.style.margin.getWithFallback(leadingSpacing[resolvedRowAxis], leading[resolvedRowAxis]) + node.style.margin.getWithFallback(trailingSpacing[resolvedRowAxis], trailing[resolvedRowAxis])) - paddingAndBorderAxisResolvedRow; } - + // And we recursively call the layout algorithm for this child layoutNode(layoutContext, currentFlexChild, maxWidth, direction); - + child = currentFlexChild; currentFlexChild = currentFlexChild.nextFlexChild; child.nextFlexChild = null; } - + // We use justifyContent to figure out how to allocate the remaining // space available } else if (justifyContent != CSSJustify.FLEX_START) { @@ -621,18 +621,18 @@ public class LayoutEngine { leadingMainDim = betweenMainDim / 2; } } - + // Position elements in the main axis and compute dimensions - + // At this point, all the children have their dimensions set. We need to // find their position. In order to do that, we accumulate data in // variables that are also useful to compute the total dimensions of the // container! mainDim += leadingMainDim; - + for (i = firstComplexMain; i < endLine; ++i) { child = node.getChildAt(i); - + if (child.style.positionType == CSSPositionType.ABSOLUTE && !Float.isNaN(child.style.position[leading[mainAxis]])) { // In case the child is position absolute and has left/top being @@ -645,12 +645,12 @@ public class LayoutEngine { // If the child is position absolute (without top/left) or relative, // we put it at the current accumulated offset. child.layout.position[pos[mainAxis]] += mainDim; - + // Define the trailing position accordingly. if (isMainDimDefined) { child.layout.position[trailing[mainAxis]] = node.layout.dimensions[dim[mainAxis]] - child.layout.dimensions[dim[mainAxis]] - child.layout.position[pos[mainAxis]]; } - + // Now that we placed the element, we need to update the variables // We only need to do that for relative elements. Absolute elements // do not take part in that phase. @@ -664,7 +664,7 @@ public class LayoutEngine { } } } - + float containerCrossAxis = node.layout.dimensions[dim[crossAxis]]; if (!isCrossDimDefined) { containerCrossAxis = Math.max( @@ -675,11 +675,11 @@ public class LayoutEngine { paddingAndBorderAxisCross ); } - + // Position elements in the cross axis for (i = firstComplexCross; i < endLine; ++i) { child = node.getChildAt(i); - + if (child.style.positionType == CSSPositionType.ABSOLUTE && !Float.isNaN(child.style.position[leading[crossAxis]])) { // In case the child is absolutely positionned and has a @@ -688,18 +688,21 @@ public class LayoutEngine { child.layout.position[pos[crossAxis]] = (Float.isNaN(child.style.position[leading[crossAxis]]) ? 0 : child.style.position[leading[crossAxis]]) + node.style.border.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]); - + } else { float leadingCrossDim = leadingPaddingAndBorderCross; - + // For a relative children, we're either using alignItems (parent) or // alignSelf (child) in order to determine the position in the cross axis if (child.style.positionType == CSSPositionType.RELATIVE) { + /*eslint-disable */ + // This variable is intentionally re-defined as the code is transpiled to a block scope language CSSAlign alignItem = getAlignItem(node, child); + /*eslint-enable */ if (alignItem == CSSAlign.STRETCH) { // You can only stretch if the dimension has not already been set // previously. - if (!(!Float.isNaN(child.style.dimensions[dim[crossAxis]]) && child.style.dimensions[dim[crossAxis]] > 0.0)) { + if (Float.isNaN(child.layout.dimensions[dim[crossAxis]])) { child.layout.dimensions[dim[crossAxis]] = Math.max( boundAxis(child, crossAxis, containerCrossAxis - paddingAndBorderAxisCross - (child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + child.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]))), @@ -712,7 +715,7 @@ public class LayoutEngine { // dimensions+margin. float remainingCrossDim = containerCrossAxis - paddingAndBorderAxisCross - (child.layout.dimensions[dim[crossAxis]] + child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + child.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis])); - + if (alignItem == CSSAlign.CENTER) { leadingCrossDim += remainingCrossDim / 2; } else { // CSSAlign.FLEX_END @@ -720,23 +723,23 @@ public class LayoutEngine { } } } - + // And we apply the position child.layout.position[pos[crossAxis]] += linesCrossDim + leadingCrossDim; - + // Define the trailing position accordingly. if (isCrossDimDefined) { child.layout.position[trailing[crossAxis]] = node.layout.dimensions[dim[crossAxis]] - child.layout.dimensions[dim[crossAxis]] - child.layout.position[pos[crossAxis]]; } } } - + linesCrossDim += crossDim; linesMainDim = Math.max(linesMainDim, mainDim); linesCount += 1; startLine = endLine; } - + // // // Note(prenaux): More than one line, we need to layout the crossAxis @@ -754,10 +757,10 @@ public class LayoutEngine { float nodeCrossAxisInnerSize = node.layout.dimensions[dim[crossAxis]] - paddingAndBorderAxisCross; float remainingAlignContentDim = nodeCrossAxisInnerSize - linesCrossDim; - + float crossDimLead = 0; float currentLead = leadingPaddingAndBorderCross; - + CSSAlign alignContent = node.style.alignContent; if (alignContent == CSSAlign.FLEX_END) { currentLead += remainingAlignContentDim; @@ -768,11 +771,11 @@ public class LayoutEngine { crossDimLead = (remainingAlignContentDim / linesCount); } } - + int endIndex = 0; for (i = 0; i < linesCount; ++i) { int startIndex = endIndex; - + // compute the line's height and find the endIndex float lineHeight = 0; for (ii = startIndex; ii < childCount; ++ii) { @@ -792,13 +795,13 @@ public class LayoutEngine { } endIndex = ii; lineHeight += crossDimLead; - + for (ii = startIndex; ii < endIndex; ++ii) { child = node.getChildAt(ii); if (child.style.positionType != CSSPositionType.RELATIVE) { continue; } - + CSSAlign alignContentAlignItem = getAlignItem(node, child); if (alignContentAlignItem == CSSAlign.FLEX_START) { child.layout.position[pos[crossAxis]] = currentLead + child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]); @@ -813,14 +816,14 @@ public class LayoutEngine { // (auto) crossAxis dimension. } } - + currentLead += lineHeight; } } - + boolean needsMainTrailingPos = false; boolean needsCrossTrailingPos = false; - + // If the user didn't specify a width or height, and it has not been set // by the container, then we set it via the children. if (!isMainDimDefined) { @@ -831,13 +834,13 @@ public class LayoutEngine { // We can never assign a width smaller than the padding and borders paddingAndBorderAxisMain ); - + if (mainAxis == CSS_FLEX_DIRECTION_ROW_REVERSE || mainAxis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) { needsMainTrailingPos = true; } } - + if (!isCrossDimDefined) { node.layout.dimensions[dim[crossAxis]] = Math.max( // For the cross dim, we add both sides at the end because the value @@ -846,28 +849,28 @@ public class LayoutEngine { boundAxis(node, crossAxis, linesCrossDim + paddingAndBorderAxisCross), paddingAndBorderAxisCross ); - + if (crossAxis == CSS_FLEX_DIRECTION_ROW_REVERSE || crossAxis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) { needsCrossTrailingPos = true; } } - + // Set trailing position if necessary if (needsMainTrailingPos || needsCrossTrailingPos) { for (i = 0; i < childCount; ++i) { child = node.getChildAt(i); - + if (needsMainTrailingPos) { child.layout.position[trailing[mainAxis]] = node.layout.dimensions[dim[mainAxis]] - child.layout.dimensions[dim[mainAxis]] - child.layout.position[pos[mainAxis]]; } - + if (needsCrossTrailingPos) { child.layout.position[trailing[crossAxis]] = node.layout.dimensions[dim[crossAxis]] - child.layout.dimensions[dim[crossAxis]] - child.layout.position[pos[crossAxis]]; } } } - + // Calculate dimensions for absolutely positioned elements currentAbsoluteChild = firstAbsoluteChild; while (currentAbsoluteChild != null) { @@ -875,7 +878,7 @@ public class LayoutEngine { // the axis are defined (either both left and right or top and bottom). for (ii = 0; ii < 2; ii++) { axis = (ii != 0) ? CSS_FLEX_DIRECTION_ROW : CSS_FLEX_DIRECTION_COLUMN; - + if (!Float.isNaN(node.layout.dimensions[dim[axis]]) && !(!Float.isNaN(currentAbsoluteChild.style.dimensions[dim[axis]]) && currentAbsoluteChild.style.dimensions[dim[axis]] >= 0.0) && !Float.isNaN(currentAbsoluteChild.style.position[leading[axis]]) && @@ -891,7 +894,7 @@ public class LayoutEngine { ((currentAbsoluteChild.style.padding.getWithFallback(leadingSpacing[axis], leading[axis]) + currentAbsoluteChild.style.border.getWithFallback(leadingSpacing[axis], leading[axis])) + (currentAbsoluteChild.style.padding.getWithFallback(trailingSpacing[axis], trailing[axis]) + currentAbsoluteChild.style.border.getWithFallback(trailingSpacing[axis], trailing[axis]))) ); } - + if (!Float.isNaN(currentAbsoluteChild.style.position[trailing[axis]]) && !!Float.isNaN(currentAbsoluteChild.style.position[leading[axis]])) { currentAbsoluteChild.layout.position[leading[axis]] = @@ -900,7 +903,7 @@ public class LayoutEngine { (Float.isNaN(currentAbsoluteChild.style.position[trailing[axis]]) ? 0 : currentAbsoluteChild.style.position[trailing[axis]]); } } - + child = currentAbsoluteChild; currentAbsoluteChild = currentAbsoluteChild.nextAbsoluteChild; child.nextAbsoluteChild = null; diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/README b/ReactAndroid/src/main/java/com/facebook/csslayout/README index 5828ad873..17aba774e 100644 --- a/ReactAndroid/src/main/java/com/facebook/csslayout/README +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/README @@ -1,7 +1,7 @@ The source of truth for css-layout is: https://github.com/facebook/css-layout The code here should be kept in sync with GitHub. -HEAD at the time this code was synced: https://github.com/facebook/css-layout/commit/f51c2d004de7744f9cefb98aa2a9c1c22168d49c +HEAD at the time this code was synced: https://github.com/facebook/css-layout/commit/4b4cd06be2f0cd2aea476e893c60443082826fb8 There is generated code in: - README (this file) diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/README.facebook b/ReactAndroid/src/main/java/com/facebook/csslayout/README.facebook index d7ed4ff5e..88a6140e2 100644 --- a/ReactAndroid/src/main/java/com/facebook/csslayout/README.facebook +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/README.facebook @@ -1,7 +1,7 @@ The source of truth for css-layout is: https://github.com/facebook/css-layout The code here should be kept in sync with GitHub. -HEAD at the time this code was synced: https://github.com/facebook/css-layout/commit/f51c2d004de7744f9cefb98aa2a9c1c22168d49c +HEAD at the time this code was synced: https://github.com/facebook/css-layout/commit/4b4cd06be2f0cd2aea476e893c60443082826fb8 There is generated code in: - README.facebook (this file) diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/Spacing.java b/ReactAndroid/src/main/java/com/facebook/csslayout/Spacing.java index d916044c3..eaab77eb4 100644 --- a/ReactAndroid/src/main/java/com/facebook/csslayout/Spacing.java +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/Spacing.java @@ -7,12 +7,14 @@ */ // NOTE: this file is auto-copied from https://github.com/facebook/css-layout -// @generated SignedSource<> +// @generated SignedSource<<3177826257fea8b5ac1fc9d1d514935a>> package com.facebook.csslayout; import javax.annotation.Nullable; +import java.util.Arrays; + /** * Class representing CSS spacing (padding, margin, and borders). This is mostly necessary to * properly implement interactions and updates for properties like margin, marginLeft, and @@ -164,6 +166,17 @@ public class Spacing { return mSpacing[spacingType]; } + /** + * Resets the spacing instance to its default state. This method is meant to be used when + * recycling {@link Spacing} instances. + */ + void reset() { + Arrays.fill(mSpacing, CSSConstants.UNDEFINED); + mDefaultSpacing = null; + mHasAliasesSet = false; + mValueFlags = 0; + } + /** * Try to get start value and fallback to given type if not defined. This is used privately * by the layout engine as a more efficient way to fetch direction-aware values by