react-native-0.30.0-rc.0.zip

/** * Copyright (c) 2014-present, Facebook, Inc. * All rights reserved. * This source code is licensed under the BSD-style license found in the * LICENSE file in the root directory of this source tree. An additional grant * of patent rights can be found in the PATENTS file in the same directory. */ // NOTE: this file is auto-copied from https://github.com/facebook/css-layout // @generated SignedSource<<c5a4eadcd6d93bc6d989cba73caa12a7>> package com.facebook.csslayout; import com.facebook.infer.annotation.Assertions; import static com.facebook.csslayout.CSSLayout.DIMENSION_HEIGHT; import static com.facebook.csslayout.CSSLayout.DIMENSION_WIDTH; import static com.facebook.csslayout.CSSLayout.POSITION_BOTTOM; import static com.facebook.csslayout.CSSLayout.POSITION_LEFT; import static com.facebook.csslayout.CSSLayout.POSITION_RIGHT; import static com.facebook.csslayout.CSSLayout.POSITION_TOP; /** * Calculates layouts based on CSS style. See {@link #layoutNode(CSSNode, float, float)}. */ public class LayoutEngine { private static final boolean POSITIVE_FLEX_IS_AUTO = false; private static final int CSS_FLEX_DIRECTION_COLUMN = CSSFlexDirection.COLUMN.ordinal(); private static final int CSS_FLEX_DIRECTION_COLUMN_REVERSE = CSSFlexDirection.COLUMN_REVERSE.ordinal(); private static final int CSS_FLEX_DIRECTION_ROW = CSSFlexDirection.ROW.ordinal(); private static final int CSS_FLEX_DIRECTION_ROW_REVERSE = CSSFlexDirection.ROW_REVERSE.ordinal(); private static final int CSS_POSITION_RELATIVE = CSSPositionType.RELATIVE.ordinal(); private static final int CSS_POSITION_ABSOLUTE = CSSPositionType.ABSOLUTE.ordinal(); private static final int[] leading = { POSITION_TOP, POSITION_BOTTOM, POSITION_LEFT, POSITION_RIGHT, }; private static final int[] trailing = { POSITION_BOTTOM, POSITION_TOP, POSITION_RIGHT, POSITION_LEFT, }; private static final int[] pos = { POSITION_TOP, POSITION_BOTTOM, POSITION_LEFT, POSITION_RIGHT, }; private static final int[] dim = { DIMENSION_HEIGHT, DIMENSION_HEIGHT, DIMENSION_WIDTH, DIMENSION_WIDTH, }; private static final int[] leadingSpacing = { Spacing.TOP, Spacing.BOTTOM, Spacing.START, Spacing.START }; private static final int[] trailingSpacing = { Spacing.BOTTOM, Spacing.TOP, Spacing.END, Spacing.END }; private static boolean isFlexBasisAuto(CSSNode node) { if (POSITIVE_FLEX_IS_AUTO) { // All flex values are auto. return true; } else { // A flex value > 0 implies a basis of zero. return node.style.flex <= 0; } } private static float getFlexGrowFactor(CSSNode node) { // Flex grow is implied by positive values for flex. if (node.style.flex > 0) { return node.style.flex; } return 0; } private static float getFlexShrinkFactor(CSSNode node) { if (POSITIVE_FLEX_IS_AUTO) { // A flex shrink factor of 1 is implied by non-zero values for flex. if (node.style.flex != 0) { return 1; } } else { // A flex shrink factor of 1 is implied by negative values for flex. if (node.style.flex < 0) { return 1; } } return 0; } private static float boundAxisWithinMinAndMax(CSSNode node, int axis, float value) { float min = CSSConstants.UNDEFINED; float max = CSSConstants.UNDEFINED; if (axis == CSS_FLEX_DIRECTION_COLUMN || axis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) { min = node.style.minHeight; max = node.style.maxHeight; } else if (axis == CSS_FLEX_DIRECTION_ROW || axis == CSS_FLEX_DIRECTION_ROW_REVERSE) { min = node.style.minWidth; max = node.style.maxWidth; } float boundValue = value; if (!Float.isNaN(max) && max >= 0.0 && boundValue > max) { boundValue = max; } if (!Float.isNaN(min) && min >= 0.0 && boundValue < min) { boundValue = min; } return boundValue; } private static float boundAxis(CSSNode node, int axis, float value) { float paddingAndBorderAxis = node.style.padding.getWithFallback(leadingSpacing[axis], leading[axis]) + node.style.border.getWithFallback(leadingSpacing[axis], leading[axis]) + node.style.padding.getWithFallback(trailingSpacing[axis], trailing[axis]) + node.style.border.getWithFallback(trailingSpacing[axis], trailing[axis]); return Math.max(boundAxisWithinMinAndMax(node, axis, value), paddingAndBorderAxis); } private static float getRelativePosition(CSSNode node, int axis) { float lead = node.style.position[leading[axis]]; if (!Float.isNaN(lead)) { return lead; } float trailingPos = node.style.position[trailing[axis]]; return Float.isNaN(trailingPos) ? 0 : -trailingPos; } private static void setPosition(CSSNode node, CSSDirection direction) { int mainAxis = resolveAxis(getFlexDirection(node), direction); int crossAxis = getCrossFlexDirection(mainAxis, direction); node.layout.position[leading[mainAxis]] = node.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + getRelativePosition(node, mainAxis); node.layout.position[trailing[mainAxis]] = node.style.margin.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + getRelativePosition(node, mainAxis); node.layout.position[leading[crossAxis]] = node.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + getRelativePosition(node, crossAxis); node.layout.position[trailing[crossAxis]] = node.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]) + getRelativePosition(node, crossAxis); } private static int resolveAxis( int axis, CSSDirection direction) { if (direction == CSSDirection.RTL) { if (axis == CSS_FLEX_DIRECTION_ROW) { return CSS_FLEX_DIRECTION_ROW_REVERSE; } else if (axis == CSS_FLEX_DIRECTION_ROW_REVERSE) { return CSS_FLEX_DIRECTION_ROW; } } return axis; } private static CSSDirection resolveDirection(CSSNode node, CSSDirection parentDirection) { CSSDirection direction = node.style.direction; if (direction == CSSDirection.INHERIT) { direction = (parentDirection == null ? CSSDirection.LTR : parentDirection); } return direction; } private static int getFlexDirection(CSSNode node) { return node.style.flexDirection.ordinal(); } private static int getCrossFlexDirection( int axis, CSSDirection direction) { if (axis == CSS_FLEX_DIRECTION_COLUMN || axis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) { return resolveAxis(CSS_FLEX_DIRECTION_ROW, direction); } else { return CSS_FLEX_DIRECTION_COLUMN; } } private static CSSAlign getAlignItem(CSSNode node, CSSNode child) { if (child.style.alignSelf != CSSAlign.AUTO) { return child.style.alignSelf; } return node.style.alignItems; } private static boolean isMeasureDefined(CSSNode node) { return node.isMeasureDefined(); } /*package*/ static void layoutNode( CSSLayoutContext layoutContext, CSSNode node, float availableWidth, float availableHeight, CSSDirection parentDirection) { // Increment the generation count. This will force the recursive routine to visit // all dirty nodes at least once. Subsequent visits will be skipped if the input // parameters don't change. layoutContext.currentGenerationCount++; // If the caller didn't specify a height/width, use the dimensions // specified in the style. if (Float.isNaN(availableWidth) && node.style.dimensions[DIMENSION_WIDTH] >= 0.0) { float marginAxisRow = (node.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + node.style.margin.getWithFallback(trai