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

Remove deprecated java code

Browse Source 
Summary: Remove deprecated java code and make use of CSSEdge instead of the now removed Spacing class.

Reviewed By: AaaChiuuu

Differential Revision: D4233198

fbshipit-source-id: 736d79be266e1b9f2d62e5fe6d901de47123cdc1
This commit is contained in:
Emil Sjolander
2016-11-29 12:23:02 -08:00
committed by Facebook Github Bot
parent 5fa42cd1b0
commit b32b6029de
26 changed files with 285 additions and 2716 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
java/com/facebook/csslayout/CSSCachedMeasurement.java
View File

@@ -1,20 +0,0 @@
/**
* 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.
*/
package com.facebook.csslayout;
public class CSSCachedMeasurement {
public float availableWidth;
public float availableHeight;
public CSSMeasureMode widthMeasureMode = null;
public CSSMeasureMode heightMeasureMode = null;
public float computedWidth;
public float computedHeight;
}

77
java/com/facebook/csslayout/CSSLayout.java
View File

@@ -1,77 +0,0 @@
/**
* 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.
*/
package com.facebook.csslayout;
import java.util.Arrays;
/**
* Where the output of {@link LayoutEngine#layoutNode(CSSNodeDEPRECATED, float)} will go in the CSSNodeDEPRECATED.
*/
public class CSSLayout {
// This value was chosen based on empiracle data. Even the most complicated
// layouts should not require more than 16 entries to fit within the cache.
public static final int MAX_CACHED_RESULT_COUNT = 16;
public static final int POSITION_LEFT = 0;
public static final int POSITION_TOP = 1;
public static final int POSITION_RIGHT = 2;
public static final int POSITION_BOTTOM = 3;
public static final int DIMENSION_WIDTH = 0;
public static final int DIMENSION_HEIGHT = 1;
public float[] position = new float[4];
public float[] dimensions = new float[2];
public CSSDirection direction = CSSDirection.LTR;
public float computedFlexBasis;
public int generationCount;
public CSSDirection lastParentDirection;
public int nextCachedMeasurementsIndex;
public CSSCachedMeasurement[] cachedMeasurements = new CSSCachedMeasurement[MAX_CACHED_RESULT_COUNT];
public float[] measuredDimensions = new float[2];
public CSSCachedMeasurement cachedLayout = new CSSCachedMeasurement();
CSSLayout() {
resetResult();
}
public void resetResult() {
Arrays.fill(position, 0);
Arrays.fill(dimensions, CSSConstants.UNDEFINED);
direction = CSSDirection.LTR;
computedFlexBasis = CSSConstants.UNDEFINED;
generationCount = 0;
lastParentDirection = null;
nextCachedMeasurementsIndex = 0;
measuredDimensions[DIMENSION_WIDTH] = CSSConstants.UNDEFINED;
measuredDimensions[DIMENSION_HEIGHT] = CSSConstants.UNDEFINED;
cachedLayout.widthMeasureMode = null;
cachedLayout.heightMeasureMode = null;
}
@Override
public String toString() {
return "layout: {" +
"left: " + position[POSITION_LEFT] + ", " +
"top: " + position[POSITION_TOP] + ", " +
"width: " + dimensions[DIMENSION_WIDTH] + ", " +
"height: " + dimensions[DIMENSION_HEIGHT] + ", " +
"direction: " + direction +
"}";
}
}

22
java/com/facebook/csslayout/CSSLayoutContext.java
View File

@@ -1,22 +0,0 @@
/**
* 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.
*/
package com.facebook.csslayout;
/**
* A context for holding values local to a given instance of layout computation.
*
* This is necessary for making layout thread-safe. A separate instance should
* be used when {@link CSSNodeDEPRECATED#calculateLayout} is called concurrently on
* different node hierarchies.
*/
public class CSSLayoutContext {
/*package*/ final MeasureOutput measureOutput = new MeasureOutput();
int currentGenerationCount;
}

45
java/com/facebook/csslayout/CSSNode.java
View File

@@ -157,7 +157,7 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
private native void jni_CSSNodeCalculateLayout(long nativePointer);
@Override
public void calculateLayout(CSSLayoutContext layoutContext) {
public void calculateLayout() {
jni_CSSNodeCalculateLayout(mNativePointer);
}
@@ -337,66 +337,66 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
private native float jni_CSSNodeStyleGetMargin(long nativePointer, int edge);
@Override
public float getMargin(int spacingType) {
public float getMargin(CSSEdge edge) {
if (!mHasSetMargin) {
return spacingType < Spacing.START ? 0 : CSSConstants.UNDEFINED;
return edge.intValue() < CSSEdge.START.intValue() ? 0 : CSSConstants.UNDEFINED;
}
return jni_CSSNodeStyleGetMargin(mNativePointer, spacingType);
return jni_CSSNodeStyleGetMargin(mNativePointer, edge.intValue());
}
private native void jni_CSSNodeStyleSetMargin(long nativePointer, int edge, float margin);
@Override
public void setMargin(int spacingType, float margin) {
public void setMargin(CSSEdge edge, float margin) {
mHasSetMargin = true;
jni_CSSNodeStyleSetMargin(mNativePointer, spacingType, margin);
jni_CSSNodeStyleSetMargin(mNativePointer, edge.intValue(), margin);
}
private native float jni_CSSNodeStyleGetPadding(long nativePointer, int edge);
@Override
public float getPadding(int spacingType) {
public float getPadding(CSSEdge edge) {
if (!mHasSetPadding) {
return spacingType < Spacing.START ? 0 : CSSConstants.UNDEFINED;
return edge.intValue() < CSSEdge.START.intValue() ? 0 : CSSConstants.UNDEFINED;
}
return jni_CSSNodeStyleGetPadding(mNativePointer, spacingType);
return jni_CSSNodeStyleGetPadding(mNativePointer, edge.intValue());
}
private native void jni_CSSNodeStyleSetPadding(long nativePointer, int edge, float padding);
@Override
public void setPadding(int spacingType, float padding) {
public void setPadding(CSSEdge edge, float padding) {
mHasSetPadding = true;
jni_CSSNodeStyleSetPadding(mNativePointer, spacingType, padding);
jni_CSSNodeStyleSetPadding(mNativePointer, edge.intValue(), padding);
}
private native float jni_CSSNodeStyleGetBorder(long nativePointer, int edge);
@Override
public float getBorder(int spacingType) {
public float getBorder(CSSEdge edge) {
if (!mHasSetBorder) {
return spacingType < Spacing.START ? 0 : CSSConstants.UNDEFINED;
return edge.intValue() < CSSEdge.START.intValue() ? 0 : CSSConstants.UNDEFINED;
}
return jni_CSSNodeStyleGetBorder(mNativePointer, spacingType);
return jni_CSSNodeStyleGetBorder(mNativePointer, edge.intValue());
}
private native void jni_CSSNodeStyleSetBorder(long nativePointer, int edge, float border);
@Override
public void setBorder(int spacingType, float border) {
public void setBorder(CSSEdge edge, float border) {
mHasSetBorder = true;
jni_CSSNodeStyleSetBorder(mNativePointer, spacingType, border);
jni_CSSNodeStyleSetBorder(mNativePointer, edge.intValue(), border);
}
private native float jni_CSSNodeStyleGetPosition(long nativePointer, int edge);
@Override
public float getPosition(int spacingType) {
public float getPosition(CSSEdge edge) {
if (!mHasSetPosition) {
return CSSConstants.UNDEFINED;
}
return jni_CSSNodeStyleGetPosition(mNativePointer, spacingType);
return jni_CSSNodeStyleGetPosition(mNativePointer, edge.intValue());
}
private native void jni_CSSNodeStyleSetPosition(long nativePointer, int edge, float position);
@Override
public void setPosition(int spacingType, float position) {
public void setPosition(CSSEdge edge, float position) {
mHasSetPosition = true;
jni_CSSNodeStyleSetPosition(mNativePointer, spacingType, position);
jni_CSSNodeStyleSetPosition(mNativePointer, edge.intValue(), position);
}
private native float jni_CSSNodeStyleGetWidth(long nativePointer);
@@ -537,11 +537,6 @@ public class CSSNode implements CSSNodeAPI<CSSNode> {
return mMeasureFunction != null;
}
@Override
public boolean valuesEqual(float f1, float f2) {
return FloatUtil.floatsEqual(f1, f2);
}
@Override
public void setData(Object data) {
mData = data;

19
java/com/facebook/csslayout/CSSNodeAPI.java
View File

@@ -31,12 +31,11 @@ public interface CSSNodeAPI<CSSNodeType extends CSSNodeAPI> {
int indexOf(CSSNodeType child);
void setMeasureFunction(MeasureFunction measureFunction);
boolean isMeasureDefined();
void calculateLayout(CSSLayoutContext layoutContext);
void calculateLayout();
boolean isDirty();
boolean hasNewLayout();
void dirty();
void markLayoutSeen();
boolean valuesEqual(float f1, float f2);
void copyStyle(CSSNodeType srcNode);
CSSDirection getStyleDirection();
void setDirection(CSSDirection direction);
@@ -60,14 +59,14 @@ public interface CSSNodeAPI<CSSNodeType extends CSSNodeAPI> {
void setFlexShrink(float flexShrink);
float getFlexBasis();
void setFlexBasis(float flexBasis);
float getMargin(int spacingType);
void setMargin(int spacingType, float margin);
float getPadding(int spacingType);
void setPadding(int spacingType, float padding);
float getBorder(int spacingType);
void setBorder(int spacingType, float border);
float getPosition(int spacingType);
void setPosition(int spacingType, float position);
float getMargin(CSSEdge edge);
void setMargin(CSSEdge edge, float margin);
float getPadding(CSSEdge edge);
void setPadding(CSSEdge edge, float padding);
float getBorder(CSSEdge edge);
void setBorder(CSSEdge edge, float border);
float getPosition(CSSEdge edge);
void setPosition(CSSEdge edge, float position);
float getWidth();
void setWidth(float width);
float getHeight();

626
java/com/facebook/csslayout/CSSNodeDEPRECATED.java
View File

@@ -1,626 +0,0 @@
/**
* 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.
*/
package com.facebook.csslayout;
import javax.annotation.Nullable;
import java.util.ArrayList;
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_LEFT;
import static com.facebook.csslayout.CSSLayout.POSITION_TOP;
/**
* A CSS Node. It has a style object you can manipulate at {@link #style}. After calling
* {@link #calculateLayout()}, {@link #layout} will be filled with the results of the layout.
*/
public class CSSNodeDEPRECATED implements CSSNodeAPI<CSSNodeDEPRECATED> {
private enum LayoutState {
/**
* Some property of this node or its children has changes and the current values in
* {@link #layout} are not valid.
*/
DIRTY,
/**
* This node has a new layout relative to the last time {@link #markLayoutSeen()} was called.
*/
HAS_NEW_LAYOUT,
/**
* {@link #layout} is valid for the node's properties and this layout has been marked as
* having been seen.
*/
UP_TO_DATE,
}
// VisibleForTesting
final CSSStyle style = new CSSStyle();
final CSSLayout layout = new CSSLayout();
final CachedCSSLayout lastLayout = new CachedCSSLayout();
public int lineIndex = 0;
CSSNodeDEPRECATED nextChild;
private @Nullable ArrayList<CSSNodeDEPRECATED> mChildren;
private @Nullable CSSNodeDEPRECATED mParent;
private @Nullable MeasureFunction mMeasureFunction = null;
private LayoutState mLayoutState = LayoutState.DIRTY;
private Object mData;
@Override
public int getChildCount() {
return mChildren == null ? 0 : mChildren.size();
}
@Override
public CSSNodeDEPRECATED getChildAt(int i) {
Assertions.assertNotNull(mChildren);
return mChildren.get(i);
}
@Override
public void addChildAt(CSSNodeDEPRECATED child, int i) {
if (child.mParent != null) {
throw new IllegalStateException("Child already has a parent, it must be removed first.");
}
if (mChildren == null) {
// 4 is kinda arbitrary, but the default of 10 seems really high for an average View.
mChildren = new ArrayList<>(4);
}
mChildren.add(i, child);
child.mParent = this;
dirty();
}
@Override
public CSSNodeDEPRECATED removeChildAt(int i) {
Assertions.assertNotNull(mChildren);
CSSNodeDEPRECATED removed = mChildren.remove(i);
removed.mParent = null;
dirty();
return removed;
}
@Override
public @Nullable
CSSNodeDEPRECATED getParent() {
return mParent;
}
/**
* @return the index of the given child, or -1 if the child doesn't exist in this node.
*/
@Override
public int indexOf(CSSNodeDEPRECATED child) {
Assertions.assertNotNull(mChildren);
return mChildren.indexOf(child);
}
@Override
public void setMeasureFunction(MeasureFunction measureFunction) {
if (mMeasureFunction != measureFunction) {
mMeasureFunction = measureFunction;
dirty();
}
}
@Override
public boolean isMeasureDefined() {
return mMeasureFunction != null;
}
long measure(float width, CSSMeasureMode widthMode, float height, CSSMeasureMode heightMode) {
if (!isMeasureDefined()) {
throw new RuntimeException("Measure function isn't defined!");
}
return Assertions.assertNotNull(mMeasureFunction).measure(this, width, widthMode, height, heightMode);
}
/**
* Performs the actual layout and saves the results in {@link #layout}
*/
@Override
public void calculateLayout(CSSLayoutContext layoutContext) {
LayoutEngine.layoutNode(layoutContext, this, CSSConstants.UNDEFINED, CSSConstants.UNDEFINED, null);
}
/**
* See {@link LayoutState#DIRTY}.
*/
@Override
public boolean isDirty() {
return mLayoutState == LayoutState.DIRTY;
}
/**
* See {@link LayoutState#HAS_NEW_LAYOUT}.
*/
@Override
public boolean hasNewLayout() {
return mLayoutState == LayoutState.HAS_NEW_LAYOUT;
}
@Override
public void dirty() {
if (mLayoutState == LayoutState.DIRTY) {
return;
} else if (mLayoutState == LayoutState.HAS_NEW_LAYOUT) {
throw new IllegalStateException("Previous layout was ignored! markLayoutSeen() never called");
}
mLayoutState = LayoutState.DIRTY;
layout.computedFlexBasis = CSSConstants.UNDEFINED;
if (mParent != null) {
mParent.dirty();
}
}
void markHasNewLayout() {
mLayoutState = LayoutState.HAS_NEW_LAYOUT;
}
/**
* Tells the node that the current values in {@link #layout} have been seen. Subsequent calls
* to {@link #hasNewLayout()} will return false until this node is laid out with new parameters.
* You must call this each time the layout is generated if the node has a new layout.
*/
@Override
public void markLayoutSeen() {
if (!hasNewLayout()) {
throw new IllegalStateException("Expected node to have a new layout to be seen!");
}
mLayoutState = LayoutState.UP_TO_DATE;
}
private void toStringWithIndentation(StringBuilder result, int level) {
// Spaces and tabs are dropped by IntelliJ logcat integration, so rely on __ instead.
StringBuilder indentation = new StringBuilder();
for (int i = 0; i < level; ++i) {
indentation.append("__");
}
result.append(indentation.toString());
result.append(layout.toString());
if (getChildCount() == 0) {
return;
}
result.append(", children: [\n");
for (int i = 0; i < getChildCount(); i++) {
getChildAt(i).toStringWithIndentation(result, level + 1);
result.append("\n");
}
result.append(indentation + "]");
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
this.toStringWithIndentation(sb, 0);
return sb.toString();
}
@Override
public boolean valuesEqual(float f1, float f2) {
return FloatUtil.floatsEqual(f1, f2);
}
@Override
public void copyStyle(CSSNodeDEPRECATED srcNode) {
throw new UnsupportedOperationException("copyStyle is not implemented");
}
/**
* Get this node's direction, as defined in the style.
*/
@Override
public CSSDirection getStyleDirection() {
return style.direction;
}
@Override
public void setDirection(CSSDirection direction) {
if (style.direction != direction) {
style.direction = direction;
dirty();
}
}
/**
* Get this node's flex direction, as defined by style.
*/
@Override
public CSSFlexDirection getFlexDirection() {
return style.flexDirection;
}
@Override
public void setFlexDirection(CSSFlexDirection flexDirection) {
if (style.flexDirection != flexDirection) {
style.flexDirection = flexDirection;
dirty();
}
}
/**
* Get this node's justify content, as defined by style.
*/
@Override
public CSSJustify getJustifyContent() {
return style.justifyContent;
}
@Override
public void setJustifyContent(CSSJustify justifyContent) {
if (style.justifyContent != justifyContent) {
style.justifyContent = justifyContent;
dirty();
}
}
/**
* Get this node's align items, as defined by style.
*/
@Override
public CSSAlign getAlignItems() {
return style.alignItems;
}
@Override
public void setAlignItems(CSSAlign alignItems) {
if (style.alignItems != alignItems) {
style.alignItems = alignItems;
dirty();
}
}
/**
* Get this node's align items, as defined by style.
*/
@Override
public CSSAlign getAlignSelf() {
return style.alignSelf;
}
@Override
public void setAlignSelf(CSSAlign alignSelf) {
if (style.alignSelf != alignSelf) {
style.alignSelf = alignSelf;
dirty();
}
}
@Override
public CSSAlign getAlignContent() {
return style.alignContent;
}
@Override
public void setAlignContent(CSSAlign alignContent) {
if (style.alignContent != alignContent) {
style.alignContent = alignContent;
dirty();
}
}
/**
* Get this node's position type, as defined by style.
*/
@Override
public CSSPositionType getPositionType() {
return style.positionType;
}
@Override
public void setPositionType(CSSPositionType positionType) {
if (style.positionType != positionType) {
style.positionType = positionType;
dirty();
}
}
@Override
public void setWrap(CSSWrap flexWrap) {
if (style.flexWrap != flexWrap) {
style.flexWrap = flexWrap;
dirty();
}
}
@Override
public void setFlex(float flex) {
if (CSSConstants.isUndefined(flex) || flex == 0) {
setFlexGrow(0);
setFlexShrink(0);
setFlexBasis(CSSConstants.UNDEFINED);
} else if (flex > 0) {
setFlexGrow(flex);
setFlexShrink(0);
setFlexBasis(0);
} else {
setFlexGrow(0);
setFlexShrink(-flex);
setFlexBasis(CSSConstants.UNDEFINED);
}
}
@Override
public float getFlexGrow() {
return style.flexGrow;
}
@Override
public void setFlexGrow(float flexGrow) {
if (!valuesEqual(style.flexGrow, flexGrow)) {
style.flexGrow = flexGrow;
dirty();
}
}
@Override
public float getFlexShrink() {
return style.flexShrink;
}
@Override
public void setFlexShrink(float flexShrink) {
if (!valuesEqual(style.flexShrink, flexShrink)) {
style.flexShrink = flexShrink;
dirty();
}
}
@Override
public float getFlexBasis() {
return style.flexBasis;
}
@Override
public void setFlexBasis(float flexBasis) {
if (!valuesEqual(style.flexBasis, flexBasis)) {
style.flexBasis = flexBasis;
dirty();
}
}
/**
* Get this node's margin, as defined by style + default margin.
*/
@Override
public float getMargin(int spacingType) {
return style.margin.get(spacingType);
}
@Override
public void setMargin(int spacingType, float margin) {
if (style.margin.set(spacingType, margin)) {
dirty();
}
}
/**
* Get this node's padding, as defined by style + default padding.
*/
@Override
public float getPadding(int spacingType) {
return style.padding.get(spacingType);
}
@Override
public void setPadding(int spacingType, float padding) {
if (style.padding.set(spacingType, padding)) {
dirty();
}
}
/**
* Get this node's border, as defined by style.
*/
@Override
public float getBorder(int spacingType) {
return style.border.get(spacingType);
}
@Override
public void setBorder(int spacingType, float border) {
if (style.border.set(spacingType, border)) {
dirty();
}
}
/**
* Get this node's position, as defined by style.
*/
@Override
public float getPosition(int spacingType) {
return style.position.get(spacingType);
}
@Override
public void setPosition(int spacingType, float position) {
if (style.position.set(spacingType, position)) {
dirty();
}
}
/**
* Get this node's width, as defined in the style.
*/
@Override
public float getWidth() {
return style.dimensions[DIMENSION_WIDTH];
}
@Override
public void setWidth(float width) {
if (!valuesEqual(style.dimensions[DIMENSION_WIDTH], width)) {
style.dimensions[DIMENSION_WIDTH] = width;
dirty();
}
}
/**
* Get this node's height, as defined in the style.
*/
@Override
public float getHeight() {
return style.dimensions[DIMENSION_HEIGHT];
}
@Override
public void setHeight(float height) {
if (!valuesEqual(style.dimensions[DIMENSION_HEIGHT], height)) {
style.dimensions[DIMENSION_HEIGHT] = height;
dirty();
}
}
/**
* Get this node's max width, as defined in the style
*/
@Override
public float getMaxWidth() {
return style.maxWidth;
}
@Override
public void setMaxWidth(float maxWidth) {
if (!valuesEqual(style.maxWidth, maxWidth)) {
style.maxWidth = maxWidth;
dirty();
}
}
/**
* Get this node's min width, as defined in the style
*/
@Override
public float getMinWidth() {
return style.minWidth;
}
@Override
public void setMinWidth(float minWidth) {
if (!valuesEqual(style.minWidth, minWidth)) {
style.minWidth = minWidth;
dirty();
}
}
/**
* Get this node's max height, as defined in the style
*/
@Override
public float getMaxHeight() {
return style.maxHeight;
}
@Override
public void setMaxHeight(float maxHeight) {
if (!valuesEqual(style.maxHeight, maxHeight)) {
style.maxHeight = maxHeight;
dirty();
}
}
/**
* Get this node's min height, as defined in the style
*/
@Override
public float getMinHeight() {
return style.minHeight;
}
@Override
public void setMinHeight(float minHeight) {
if (!valuesEqual(style.minHeight, minHeight)) {
style.minHeight = minHeight;
dirty();
}
}
@Override
public float getLayoutX() {
return layout.position[POSITION_LEFT];
}
@Override
public float getLayoutY() {
return layout.position[POSITION_TOP];
}
@Override
public float getLayoutWidth() {
return layout.dimensions[DIMENSION_WIDTH];
}
@Override
public float getLayoutHeight() {
return layout.dimensions[DIMENSION_HEIGHT];
}
@Override
public CSSDirection getLayoutDirection() {
return layout.direction;
}
/**
* Get this node's overflow property, as defined in the style
*/
@Override
public CSSOverflow getOverflow() {
return style.overflow;
}
@Override
public void setOverflow(CSSOverflow overflow) {
if (style.overflow != overflow) {
style.overflow = overflow;
dirty();
}
}
@Override
public void setData(Object data) {
mData = data;
}
@Override
public Object getData() {
return mData;
}
/**
* Resets this instance to its default state. This method is meant to be used when
* recycling {@link CSSNodeDEPRECATED} instances.
*/
@Override
public void reset() {
if (mParent != null || (mChildren != null && mChildren.size() > 0)) {
throw new IllegalStateException("You should not free an attached CSSNodeDEPRECATED");
}
style.reset();
layout.resetResult();
lineIndex = 0;
mLayoutState = LayoutState.DIRTY;
mMeasureFunction = null;
}
}

76
java/com/facebook/csslayout/CSSStyle.java
View File

@@ -1,76 +0,0 @@
/**
* 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.
*/
package com.facebook.csslayout;
import java.util.Arrays;
/**
* The CSS style definition for a {@link CSSNodeDEPRECATED}.
*/
public class CSSStyle {
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 CSSOverflow overflow;
public float flexGrow;
public float flexShrink;
public float flexBasis;
public Spacing margin = new Spacing();
public Spacing padding = new Spacing();
public Spacing border = new Spacing();
public Spacing position = new Spacing(CSSConstants.UNDEFINED);
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.NO_WRAP;
overflow = CSSOverflow.VISIBLE;
flexGrow = 0;
flexShrink = 0;
flexBasis = CSSConstants.UNDEFINED;
margin.reset();
padding.reset();
border.reset();
position.reset();
Arrays.fill(dimensions, CSSConstants.UNDEFINED);
minWidth = CSSConstants.UNDEFINED;
minHeight = CSSConstants.UNDEFINED;
maxWidth = CSSConstants.UNDEFINED;
maxHeight = CSSConstants.UNDEFINED;
}
}

23
java/com/facebook/csslayout/CachedCSSLayout.java
View File

@@ -1,23 +0,0 @@
/**
* 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.
*/
package com.facebook.csslayout;
/**
* CSSLayout with additional information about the conditions under which it was generated.
* {@link #requestedWidth} and {@link #requestedHeight} are the width and height the parent set on
* this node before calling layout visited us.
*/
public class CachedCSSLayout extends CSSLayout {
public float requestedWidth = CSSConstants.UNDEFINED;
public float requestedHeight = CSSConstants.UNDEFINED;
public float parentMaxWidth = CSSConstants.UNDEFINED;
public float parentMaxHeight = CSSConstants.UNDEFINED;
}

22
java/com/facebook/csslayout/FloatUtil.java
View File

@@ -1,22 +0,0 @@
/**
* 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.
*/
package com.facebook.csslayout;
public class FloatUtil {
private static final float EPSILON = .00001f;
public static boolean floatsEqual(float f1, float f2) {
if (Float.isNaN(f1) || Float.isNaN(f2)) {
return Float.isNaN(f1) && Float.isNaN(f2);
}
return Math.abs(f2 - f1) < EPSILON;
}
}

1369
java/com/facebook/csslayout/LayoutEngine.java
View File

File diff suppressed because it is too large Load Diff

190
java/com/facebook/csslayout/Spacing.java
View File

@@ -1,190 +0,0 @@
/**
* 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.
*/
package com.facebook.csslayout;
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
* marginHorizontal.
*/
public class Spacing {
/**
* Spacing type that represents the left direction. E.g. {@code marginLeft}.
*/
public static final int LEFT = 0;
/**
* Spacing type that represents the top direction. E.g. {@code marginTop}.
*/
public static final int TOP = 1;
/**
* Spacing type that represents the right direction. E.g. {@code marginRight}.
*/
public static final int RIGHT = 2;
/**
* Spacing type that represents the bottom direction. E.g. {@code marginBottom}.
*/
public static final int BOTTOM = 3;
/**
* Spacing type that represents start direction e.g. left in left-to-right, right in right-to-left.
*/
public static final int START = 4;
/**
* Spacing type that represents end direction e.g. right in left-to-right, left in right-to-left.
*/
public static final int END = 5;
/**
* Spacing type that represents horizontal direction (left and right). E.g.
* {@code marginHorizontal}.
*/
public static final int HORIZONTAL = 6;
/**
* Spacing type that represents vertical direction (top and bottom). E.g. {@code marginVertical}.
*/
public static final int VERTICAL = 7;
/**
* Spacing type that represents all directions (left, top, right, bottom). E.g. {@code margin}.
*/
public static final int ALL = 8;
private static final int[] sFlagsMap = {
1, /*LEFT*/
2, /*TOP*/
4, /*RIGHT*/
8, /*BOTTOM*/
16, /*START*/
32, /*END*/
64, /*HORIZONTAL*/
128, /*VERTICAL*/
256, /*ALL*/
};
private final float[] mSpacing = newFullSpacingArray();
private int mValueFlags = 0;
private float mDefaultValue;
private boolean mHasAliasesSet;
public Spacing() {
this(0);
}
public Spacing(float defaultValue) {
mDefaultValue = defaultValue;
}
/**
* Set a spacing value.
*
* @param spacingType one of {@link #LEFT}, {@link #TOP}, {@link #RIGHT}, {@link #BOTTOM},
* {@link #VERTICAL}, {@link #HORIZONTAL}, {@link #ALL}
* @param value the value for this direction
* @return {@code true} if the spacing has changed, or {@code false} if the same value was already
* set
*/
public boolean set(int spacingType, float value) {
if (!FloatUtil.floatsEqual(mSpacing[spacingType], value)) {
mSpacing[spacingType] = value;
if (CSSConstants.isUndefined(value)) {
mValueFlags &= ~sFlagsMap[spacingType];
} else {
mValueFlags |= sFlagsMap[spacingType];
}
mHasAliasesSet =
(mValueFlags & sFlagsMap[ALL]) != 0 ||
(mValueFlags & sFlagsMap[VERTICAL]) != 0 ||
(mValueFlags & sFlagsMap[HORIZONTAL]) != 0;
return true;
}
return false;
}
/**
* Get the spacing for a direction. This takes into account any default values that have been set.
*
* @param spacingType one of {@link #LEFT}, {@link #TOP}, {@link #RIGHT}, {@link #BOTTOM}
*/
public float get(int spacingType) {
float defaultValue = (spacingType == START || spacingType == END
? CSSConstants.UNDEFINED
: mDefaultValue);
if (mValueFlags == 0) {
return defaultValue;
}
if ((mValueFlags & sFlagsMap[spacingType]) != 0) {
return mSpacing[spacingType];
}
if (mHasAliasesSet) {
int secondType = spacingType == TOP || spacingType == BOTTOM ? VERTICAL : HORIZONTAL;
if ((mValueFlags & sFlagsMap[secondType]) != 0) {
return mSpacing[secondType];
} else if ((mValueFlags & sFlagsMap[ALL]) != 0) {
return mSpacing[ALL];
}
}
return defaultValue;
}
/**
* Get the raw value (that was set using {@link #set(int, float)}), without taking into account
* any default values.
*
* @param spacingType one of {@link #LEFT}, {@link #TOP}, {@link #RIGHT}, {@link #BOTTOM},
* {@link #VERTICAL}, {@link #HORIZONTAL}, {@link #ALL}
*/
public float getRaw(int spacingType) {
return mSpacing[spacingType];
}
/**
* Resets the spacing instance to its default state. This method is meant to be used when
* recycling {@link Spacing} instances.
*/
public void reset() {
Arrays.fill(mSpacing, CSSConstants.UNDEFINED);
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
* avoid extra method invocations.
*/
float getWithFallback(int spacingType, int fallbackType) {
return
(mValueFlags & sFlagsMap[spacingType]) != 0
? mSpacing[spacingType]
: get(fallbackType);
}
private static float[] newFullSpacingArray() {
return new float[] {
CSSConstants.UNDEFINED,
CSSConstants.UNDEFINED,
CSSConstants.UNDEFINED,
CSSConstants.UNDEFINED,
CSSConstants.UNDEFINED,
CSSConstants.UNDEFINED,
CSSConstants.UNDEFINED,
CSSConstants.UNDEFINED,
CSSConstants.UNDEFINED,
};
}
}