diff --git a/React/CSSLayout/CSSLayout.c b/React/CSSLayout/CSSLayout.c index 31b752e44..20c55fe10 100644 --- a/React/CSSLayout/CSSLayout.c +++ b/React/CSSLayout/CSSLayout.c @@ -27,7 +27,7 @@ __forceinline const float fmaxf(const float a, const float b) { CSSNodeRef CSSNodeNew() { CSSNodeRef node = calloc(1, sizeof(CSSNode)); - CSS_ASSERT(node != NULL, "Could not allocate memory for node"); + CSS_ASSERT(node, "Could not allocate memory for node"); CSSNodeInit(node); return node; @@ -123,6 +123,10 @@ void CSSNodeMarkDirty(CSSNodeRef node) { _CSSNodeMarkDirty(node); } +bool CSSNodeIsDirty(CSSNodeRef node) { + return node->isDirty; +} + #define CSS_NODE_PROPERTY_IMPL(type, name, paramName, instanceName) \ void CSSNodeSet##name(CSSNodeRef node, type paramName) { \ node->instanceName = paramName; \ @@ -130,7 +134,7 @@ void CSSNodeSet##name(CSSNodeRef node, type paramName) { \ \ type CSSNodeGet##name(CSSNodeRef node) { \ return node->instanceName; \ -} \ +} #define CSS_NODE_STYLE_PROPERTY_IMPL(type, name, paramName, instanceName) \ void CSSNodeStyleSet##name(CSSNodeRef node, type paramName) { \ @@ -142,12 +146,12 @@ void CSSNodeStyleSet##name(CSSNodeRef node, type paramName) { \ \ type CSSNodeStyleGet##name(CSSNodeRef node) { \ return node->style.instanceName; \ -} \ +} #define CSS_NODE_LAYOUT_PROPERTY_IMPL(type, name, instanceName) \ type CSSNodeLayoutGet##name(CSSNodeRef node) { \ return node->layout.instanceName; \ -} \ +} CSS_NODE_PROPERTY_IMPL(void*, Context, context, context); CSS_NODE_PROPERTY_IMPL(CSSMeasureFunc, MeasureFunc, measureFunc, measure); @@ -211,8 +215,15 @@ CSS_NODE_LAYOUT_PROPERTY_IMPL(CSSDirection, Direction, direction); uint32_t gCurrentGenerationCount = 0; -bool layoutNodeInternal(CSSNode* node, float availableWidth, float availableHeight, CSSDirection parentDirection, - CSSMeasureMode widthMeasureMode, CSSMeasureMode heightMeasureMode, bool performLayout, char* reason); +bool layoutNodeInternal( + CSSNode* node, + float availableWidth, + float availableHeight, + CSSDirection parentDirection, + CSSMeasureMode widthMeasureMode, + CSSMeasureMode heightMeasureMode, + bool performLayout, + char* reason); bool isUndefined(float value) { return isnan(value); diff --git a/React/CSSLayout/CSSLayout.h b/React/CSSLayout/CSSLayout.h index 9d5af32a0..8c46cea30 100644 --- a/React/CSSLayout/CSSLayout.h +++ b/React/CSSLayout/CSSLayout.h @@ -136,6 +136,7 @@ void CSSNodeCalculateLayout( // CSSLayout knows when to mark all other nodes as dirty but because nodes with measure functions // depends on information not known to CSSLayout they must perform this dirty marking manually. void CSSNodeMarkDirty(CSSNodeRef node); +bool CSSNodeIsDirty(CSSNodeRef node); void CSSNodePrint(CSSNodeRef node, CSSPrintOptions options); diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java index a06639aec..3ea3b2c54 100644 --- a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java @@ -28,9 +28,9 @@ import static com.facebook.csslayout.Spacing.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 CSSNode { +public class CSSNode implements CSSNodeAPI { - private static enum LayoutState { + private enum LayoutState { /** * Some property of this node or its children has changes and the current values in * {@link #layout} are not valid. @@ -49,24 +49,14 @@ public class CSSNode { UP_TO_DATE, } - public static interface MeasureFunction { - - /** - * Should measure the given node and put the result in the given MeasureOutput. - * - * NB: measure is NOT guaranteed to be threadsafe/re-entrant safe! - */ - public void measure(CSSNode node, float width, CSSMeasureMode widthMode, float height, CSSMeasureMode heightMode, MeasureOutput measureOutput); - } - // VisibleForTesting - /*package*/ final CSSStyle style = new CSSStyle(); - /*package*/ final CSSLayout layout = new CSSLayout(); - /*package*/ final CachedCSSLayout lastLayout = new CachedCSSLayout(); + final CSSStyle style = new CSSStyle(); + final CSSLayout layout = new CSSLayout(); + final CachedCSSLayout lastLayout = new CachedCSSLayout(); public int lineIndex = 0; - /*package*/ CSSNode nextChild; + CSSNode nextChild; private @Nullable ArrayList mChildren; private @Nullable CSSNode mParent; @@ -74,15 +64,23 @@ public class CSSNode { private LayoutState mLayoutState = LayoutState.DIRTY; private boolean mIsTextNode = false; + @Override + public void init() { + reset(); + } + + @Override public int getChildCount() { return mChildren == null ? 0 : mChildren.size(); } + @Override public CSSNode getChildAt(int i) { Assertions.assertNotNull(mChildren); return mChildren.get(i); } + @Override public void addChildAt(CSSNode child, int i) { if (child.mParent != null) { throw new IllegalStateException("Child already has a parent, it must be removed first."); @@ -97,6 +95,7 @@ public class CSSNode { dirty(); } + @Override public CSSNode removeChildAt(int i) { Assertions.assertNotNull(mChildren); CSSNode removed = mChildren.remove(i); @@ -105,6 +104,7 @@ public class CSSNode { return removed; } + @Override public @Nullable CSSNode getParent() { return mParent; } @@ -112,11 +112,13 @@ public class CSSNode { /** * @return the index of the given child, or -1 if the child doesn't exist in this node. */ + @Override public int indexOf(CSSNode child) { Assertions.assertNotNull(mChildren); return mChildren.indexOf(child); } + @Override public void setMeasureFunction(MeasureFunction measureFunction) { if (mMeasureFunction != measureFunction) { mMeasureFunction = measureFunction; @@ -124,19 +126,22 @@ public class CSSNode { } } + @Override public boolean isMeasureDefined() { return mMeasureFunction != null; } + @Override public void setIsTextNode(boolean isTextNode) { mIsTextNode = isTextNode; } + @Override public boolean isTextNode() { return mIsTextNode; } - /*package*/ MeasureOutput measure(MeasureOutput measureOutput, float width, CSSMeasureMode widthMode, float height, CSSMeasureMode heightMode) { + MeasureOutput measure(MeasureOutput measureOutput, float width, CSSMeasureMode widthMode, float height, CSSMeasureMode heightMode) { if (!isMeasureDefined()) { throw new RuntimeException("Measure function isn't defined!"); } @@ -149,6 +154,7 @@ public class CSSNode { /** * 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); } @@ -156,18 +162,21 @@ public class CSSNode { /** * See {@link LayoutState#DIRTY}. */ - protected boolean isDirty() { + @Override + public boolean isDirty() { return mLayoutState == LayoutState.DIRTY; } /** * See {@link LayoutState#HAS_NEW_LAYOUT}. */ + @Override public boolean hasNewLayout() { return mLayoutState == LayoutState.HAS_NEW_LAYOUT; } - protected void dirty() { + @Override + public void dirty() { if (mLayoutState == LayoutState.DIRTY) { return; } else if (mLayoutState == LayoutState.HAS_NEW_LAYOUT) { @@ -181,7 +190,7 @@ public class CSSNode { } } - /*package*/ void markHasNewLayout() { + void markHasNewLayout() { mLayoutState = LayoutState.HAS_NEW_LAYOUT; } @@ -190,6 +199,7 @@ public class CSSNode { * 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!"); @@ -227,17 +237,20 @@ public class CSSNode { return sb.toString(); } - protected boolean valuesEqual(float f1, float f2) { + @Override + public boolean valuesEqual(float f1, float f2) { return FloatUtil.floatsEqual(f1, f2); } /** * 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; @@ -248,10 +261,12 @@ public class CSSNode { /** * 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; @@ -262,10 +277,12 @@ public class CSSNode { /** * 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; @@ -276,10 +293,12 @@ public class CSSNode { /** * 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; @@ -290,10 +309,12 @@ public class CSSNode { /** * 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; @@ -304,10 +325,12 @@ public class CSSNode { /** * 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; @@ -315,6 +338,7 @@ public class CSSNode { } } + @Override public void setWrap(CSSWrap flexWrap) { if (style.flexWrap != flexWrap) { style.flexWrap = flexWrap; @@ -325,10 +349,12 @@ public class CSSNode { /** * Get this node's flex, as defined by style. */ + @Override public float getFlex() { return style.flex; } + @Override public void setFlex(float flex) { if (!valuesEqual(style.flex, flex)) { style.flex = flex; @@ -339,10 +365,12 @@ public class CSSNode { /** * Get this node's margin, as defined by style + default margin. */ + @Override public Spacing getMargin() { return style.margin; } + @Override public void setMargin(int spacingType, float margin) { if (style.margin.set(spacingType, margin)) { dirty(); @@ -352,10 +380,12 @@ public class CSSNode { /** * Get this node's padding, as defined by style + default padding. */ + @Override public Spacing getPadding() { return style.padding; } + @Override public void setPadding(int spacingType, float padding) { if (style.padding.set(spacingType, padding)) { dirty(); @@ -365,10 +395,12 @@ public class CSSNode { /** * Get this node's border, as defined by style. */ + @Override public Spacing getBorder() { return style.border; } + @Override public void setBorder(int spacingType, float border) { if (style.border.set(spacingType, border)) { dirty(); @@ -378,10 +410,12 @@ public class CSSNode { /** * Get this node's position, as defined by style. */ - public Spacing getPositionValue() { + @Override + public Spacing getPositionValue() { return style.position; } + @Override public void setPositionValue(int spacingType, float position) { if (style.position.set(spacingType, position)) { dirty(); @@ -391,10 +425,12 @@ public class CSSNode { /** * Get this node's position top, as defined by style. */ + @Override public float getPositionTop() { return style.position.get(TOP); } + @Override public void setPositionTop(float positionTop) { setPositionValue(TOP, positionTop); } @@ -402,10 +438,12 @@ public class CSSNode { /** * Get this node's position bottom, as defined by style. */ + @Override public float getPositionBottom() { return style.position.get(BOTTOM); } + @Override public void setPositionBottom(float positionBottom) { setPositionValue(BOTTOM, positionBottom); } @@ -413,10 +451,12 @@ public class CSSNode { /** * Get this node's position left, as defined by style. */ + @Override public float getPositionLeft() { return style.position.get(LEFT); } + @Override public void setPositionLeft(float positionLeft) { setPositionValue(LEFT, positionLeft); } @@ -424,10 +464,12 @@ public class CSSNode { /** * Get this node's position right, as defined by style. */ + @Override public float getPositionRight() { return style.position.get(RIGHT); } + @Override public void setPositionRight(float positionRight) { setPositionValue(RIGHT, positionRight); } @@ -435,10 +477,12 @@ public class CSSNode { /** * Get this node's width, as defined in the style. */ + @Override public float getStyleWidth() { return style.dimensions[DIMENSION_WIDTH]; } + @Override public void setStyleWidth(float width) { if (!valuesEqual(style.dimensions[DIMENSION_WIDTH], width)) { style.dimensions[DIMENSION_WIDTH] = width; @@ -449,10 +493,12 @@ public class CSSNode { /** * Get this node's height, as defined in the style. */ + @Override public float getStyleHeight() { return style.dimensions[DIMENSION_HEIGHT]; } + @Override public void setStyleHeight(float height) { if (!valuesEqual(style.dimensions[DIMENSION_HEIGHT], height)) { style.dimensions[DIMENSION_HEIGHT] = height; @@ -463,10 +509,12 @@ public class CSSNode { /** * Get this node's max width, as defined in the style */ + @Override public float getStyleMaxWidth() { return style.maxWidth; } + @Override public void setStyleMaxWidth(float maxWidth) { if (!valuesEqual(style.maxWidth, maxWidth)) { style.maxWidth = maxWidth; @@ -477,10 +525,12 @@ public class CSSNode { /** * Get this node's min width, as defined in the style */ + @Override public float getStyleMinWidth() { return style.minWidth; } + @Override public void setStyleMinWidth(float minWidth) { if (!valuesEqual(style.minWidth, minWidth)) { style.minWidth = minWidth; @@ -491,10 +541,12 @@ public class CSSNode { /** * Get this node's max height, as defined in the style */ + @Override public float getStyleMaxHeight() { return style.maxHeight; } + @Override public void setStyleMaxHeight(float maxHeight) { if (!valuesEqual(style.maxHeight, maxHeight)) { style.maxHeight = maxHeight; @@ -505,10 +557,12 @@ public class CSSNode { /** * Get this node's min height, as defined in the style */ + @Override public float getStyleMinHeight() { return style.minHeight; } + @Override public void setStyleMinHeight(float minHeight) { if (!valuesEqual(style.minHeight, minHeight)) { style.minHeight = minHeight; @@ -516,22 +570,27 @@ public class CSSNode { } } + @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; } @@ -539,6 +598,7 @@ public class CSSNode { /** * Set a default padding (left/top/right/bottom) for this node. */ + @Override public void setDefaultPadding(int spacingType, float padding) { if (style.padding.setDefault(spacingType, padding)) { dirty(); @@ -548,10 +608,12 @@ public class CSSNode { /** * 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; @@ -563,6 +625,7 @@ public class CSSNode { * Resets this instance to its default state. This method is meant to be used when * recycling {@link CSSNode} instances. */ + @Override public void reset() { if (mParent != null || (mChildren != null && mChildren.size() > 0)) { throw new IllegalStateException("You should not reset an attached CSSNode"); diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeAPI.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeAPI.java new file mode 100644 index 000000000..765b135b3 --- /dev/null +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeAPI.java @@ -0,0 +1,93 @@ +/** + * 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 interface CSSNodeAPI { + + interface MeasureFunction { + void measure( + CSSNodeAPI node, + float width, + CSSMeasureMode widthMode, + float height, + CSSMeasureMode heightMode, + MeasureOutput measureOutput); + } + + int getChildCount(); + CSSNodeType getChildAt(int i); + void addChildAt(CSSNodeType child, int i); + CSSNodeType removeChildAt(int i); + CSSNodeType getParent(); + int indexOf(CSSNodeType child); + void setMeasureFunction(MeasureFunction measureFunction); + boolean isMeasureDefined(); + void setIsTextNode(boolean isTextNode); + boolean isTextNode(); + void calculateLayout(CSSLayoutContext layoutContext); + boolean isDirty(); + boolean hasNewLayout(); + void dirty(); + void markLayoutSeen(); + boolean valuesEqual(float f1, float f2); + CSSDirection getStyleDirection(); + void setDirection(CSSDirection direction); + CSSFlexDirection getFlexDirection(); + void setFlexDirection(CSSFlexDirection flexDirection); + CSSJustify getJustifyContent(); + void setJustifyContent(CSSJustify justifyContent); + CSSAlign getAlignItems(); + void setAlignItems(CSSAlign alignItems); + CSSAlign getAlignSelf(); + void setAlignSelf(CSSAlign alignSelf); + CSSPositionType getPositionType(); + void setPositionType(CSSPositionType positionType); + void setWrap(CSSWrap flexWrap); + float getFlex(); + void setFlex(float flex); + Spacing getMargin(); + void setMargin(int spacingType, float margin); + Spacing getPadding(); + void setPadding(int spacingType, float padding); + Spacing getBorder(); + void setBorder(int spacingType, float border); + Spacing getPositionValue(); + void setPositionValue(int spacingType, float position); + float getPositionTop(); + void setPositionTop(float positionTop); + float getPositionBottom(); + void setPositionBottom(float positionBottom); + float getPositionLeft(); + void setPositionLeft(float positionLeft); + float getPositionRight(); + void setPositionRight(float positionRight); + float getStyleWidth(); + void setStyleWidth(float width); + float getStyleHeight(); + void setStyleHeight(float height); + float getStyleMaxWidth(); + void setStyleMaxWidth(float maxWidth); + float getStyleMinWidth(); + void setStyleMinWidth(float minWidth); + float getStyleMaxHeight(); + void setStyleMaxHeight(float maxHeight); + float getStyleMinHeight(); + void setStyleMinHeight(float minHeight); + float getLayoutX(); + float getLayoutY(); + float getLayoutWidth(); + float getLayoutHeight(); + CSSDirection getLayoutDirection(); + void setDefaultPadding(int spacingType, float padding); + CSSOverflow getOverflow(); + void setOverflow(CSSOverflow overflow); + void init(); + void reset(); +} diff --git a/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeJNI.java b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeJNI.java new file mode 100644 index 000000000..b6a37fe5e --- /dev/null +++ b/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNodeJNI.java @@ -0,0 +1,715 @@ +/** + * 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.List; +import java.util.ArrayList; + +import com.facebook.proguard.annotations.DoNotStrip; +import com.facebook.soloader.SoLoader; + +public class CSSNodeJNI implements CSSNodeAPI { + + static { + SoLoader.loadLibrary("csslayout"); + } + + private CSSNodeJNI mParent; + private List mChildren; + private MeasureFunction mMeasureFunction; + private int mNativePointer; + + private void assertNativeInstance() { + if (mNativePointer == 0) { + throw new IllegalStateException("Null native pointer"); + } + } + + private native int jni_CSSNodeNew(); + @Override + public void init() { + if (mNativePointer != 0) { + throw new IllegalStateException("Allready initialized node"); + } + + mNativePointer = jni_CSSNodeNew(); + mChildren = new ArrayList<>(4); + } + + private native void jni_CSSNodeFree(int nativePointer); + @Override + public void reset() { + assertNativeInstance(); + + jni_CSSNodeFree(mNativePointer); + mNativePointer = 0; + mChildren = null; + mParent = null; + mMeasureFunction = null; + } + + @Override + public int getChildCount() { + return mChildren.size(); + } + + @Override + public CSSNodeJNI getChildAt(int i) { + return mChildren.get(i); + } + + private native void jni_CSSNodeInsertChild(int nativePointer, int childPointer, int index); + @Override + public void addChildAt(CSSNodeJNI child, int i) { + assertNativeInstance(); + + mChildren.add(i, child); + child.mParent = this; + jni_CSSNodeInsertChild(mNativePointer, child.mNativePointer, i); + } + + private native void jni_CSSNodeRemoveChild(int nativePointer, int childPointer); + @Override + public CSSNodeJNI removeChildAt(int i) { + assertNativeInstance(); + + final CSSNodeJNI child = mChildren.remove(i); + child.mParent = null; + jni_CSSNodeRemoveChild(mNativePointer, child.mNativePointer); + return child; + } + + @Override + public @Nullable CSSNodeJNI getParent() { + return mParent; + } + + @Override + public int indexOf(CSSNodeJNI child) { + return mChildren.indexOf(child); + } + + private native void jni_CSSNodeSetIsTextNode(int nativePointer, boolean isTextNode); + @Override + public void setIsTextNode(boolean isTextNode) { + assertNativeInstance(); + jni_CSSNodeSetIsTextNode(mNativePointer, isTextNode); + } + + private native boolean jni_CSSNodeGetIsTextNode(int nativePointer); + @Override + public boolean isTextNode() { + assertNativeInstance(); + return jni_CSSNodeGetIsTextNode(mNativePointer); + } + + private native void jni_CSSNodeCalculateLayout(int nativePointer); + @Override + public void calculateLayout(CSSLayoutContext layoutContext) { + assertNativeInstance(); + jni_CSSNodeCalculateLayout(mNativePointer); + } + + private native boolean jni_CSSNodeHasNewLayout(int nativePointer); + @Override + public boolean hasNewLayout() { + assertNativeInstance(); + return jni_CSSNodeHasNewLayout(mNativePointer); + } + + private native void jni_CSSNodeMarkDirty(int nativePointer); + @Override + public void dirty() { + assertNativeInstance(); + jni_CSSNodeMarkDirty(mNativePointer); + } + + private native boolean jni_CSSNodeIsDirty(int nativePointer); + @Override + public boolean isDirty() { + return jni_CSSNodeIsDirty(mNativePointer); + } + + private native void jni_CSSNodeMarkLayoutSeen(int nativePointer); + @Override + public void markLayoutSeen() { + assertNativeInstance(); + jni_CSSNodeMarkLayoutSeen(mNativePointer); + } + + private native int jni_CSSNodeStyleGetDirection(int nativePointer); + @Override + public CSSDirection getStyleDirection() { + assertNativeInstance(); + return CSSDirection.values()[jni_CSSNodeStyleGetDirection(mNativePointer)]; + } + + private native void jni_CSSNodeStyleSetDirection(int nativePointer, int direction); + @Override + public void setDirection(CSSDirection direction) { + assertNativeInstance(); + jni_CSSNodeStyleSetDirection(mNativePointer, direction.ordinal()); + } + + private native int jni_CSSNodeLayoutGetDirection(int nativePointer); + @Override + public CSSDirection getLayoutDirection() { + assertNativeInstance(); + return CSSDirection.values()[jni_CSSNodeLayoutGetDirection(mNativePointer)]; + } + + private native int jni_CSSNodeStyleGetFlexDirection(int nativePointer); + @Override + public CSSFlexDirection getFlexDirection() { + assertNativeInstance(); + return CSSFlexDirection.values()[jni_CSSNodeStyleGetFlexDirection(mNativePointer)]; + } + + private native void jni_CSSNodeStyleSetFlexDirection(int nativePointer, int flexDirection); + @Override + public void setFlexDirection(CSSFlexDirection flexDirection) { + assertNativeInstance(); + jni_CSSNodeStyleSetFlexDirection(mNativePointer, flexDirection.ordinal()); + } + + private native int jni_CSSNodeStyleGetJustifyContent(int nativePointer); + @Override + public CSSJustify getJustifyContent() { + assertNativeInstance(); + return CSSJustify.values()[jni_CSSNodeStyleGetJustifyContent(mNativePointer)]; + } + + private native void jni_CSSNodeStyleSetJustifyContent(int nativePointer, int justifyContent); + @Override + public void setJustifyContent(CSSJustify justifyContent) { + assertNativeInstance(); + jni_CSSNodeStyleSetJustifyContent(mNativePointer, justifyContent.ordinal()); + } + + private native int jni_CSSNodeStyleGetAlignItems(int nativePointer); + @Override + public CSSAlign getAlignItems() { + assertNativeInstance(); + return CSSAlign.values()[jni_CSSNodeStyleGetAlignItems(mNativePointer)]; + } + + private native void jni_CSSNodeStyleSetAlignItems(int nativePointer, int alignItems); + @Override + public void setAlignItems(CSSAlign alignItems) { + assertNativeInstance(); + jni_CSSNodeStyleSetAlignItems(mNativePointer, alignItems.ordinal()); + } + + private native int jni_CSSNodeStyleGetAlignSelf(int nativePointer); + @Override + public CSSAlign getAlignSelf() { + assertNativeInstance(); + return CSSAlign.values()[jni_CSSNodeStyleGetAlignSelf(mNativePointer)]; + } + + private native void jni_CSSNodeStyleSetAlignSelf(int nativePointer, int alignSelf); + @Override + public void setAlignSelf(CSSAlign alignSelf) { + assertNativeInstance(); + jni_CSSNodeStyleSetAlignSelf(mNativePointer, alignSelf.ordinal()); + } + + private native int jni_CSSNodeStyleGetPositionType(int nativePointer); + @Override + public CSSPositionType getPositionType() { + assertNativeInstance(); + return CSSPositionType.values()[jni_CSSNodeStyleGetPositionType(mNativePointer)]; + } + + private native void jni_CSSNodeStyleSetPositionType(int nativePointer, int positionType); + @Override + public void setPositionType(CSSPositionType positionType) { + assertNativeInstance(); + jni_CSSNodeStyleSetPositionType(mNativePointer, positionType.ordinal()); + } + + private native void jni_CSSNodeStyleSetFlexWrap(int nativePointer, int wrapType); + @Override + public void setWrap(CSSWrap flexWrap) { + assertNativeInstance(); + jni_CSSNodeStyleSetFlexWrap(mNativePointer, flexWrap.ordinal()); + } + + private native int jni_CSSNodeStyleGetOverflow(int nativePointer); + @Override + public CSSOverflow getOverflow() { + assertNativeInstance(); + return CSSOverflow.values()[jni_CSSNodeStyleGetOverflow(mNativePointer)]; + } + + private native void jni_CSSNodeStyleSetOverflow(int nativePointer, int overflow); + @Override + public void setOverflow(CSSOverflow overflow) { + assertNativeInstance(); + jni_CSSNodeStyleSetOverflow(mNativePointer, overflow.ordinal()); + } + + private native float jni_CSSNodeStyleGetFlex(int nativePointer); + @Override + public float getFlex() { + assertNativeInstance(); + return jni_CSSNodeStyleGetFlex(mNativePointer); + } + + private native void jni_CSSNodeStyleSetFlex(int nativePointer, float flex); + @Override + public void setFlex(float flex) { + assertNativeInstance(); + jni_CSSNodeStyleSetFlex(mNativePointer, flex); + } + + private native float jni_CSSNodeStyleGetMarginLeft(int nativePointer); + private native float jni_CSSNodeStyleGetMarginTop(int nativePointer); + private native float jni_CSSNodeStyleGetMarginRight(int nativePointer); + private native float jni_CSSNodeStyleGetMarginBottom(int nativePointer); + private native float jni_CSSNodeStyleGetMarginStart(int nativePointer); + private native float jni_CSSNodeStyleGetMarginEnd(int nativePointer); + @Override + public Spacing getMargin() { + assertNativeInstance(); + Spacing margin = new Spacing(); + margin.set(Spacing.LEFT, jni_CSSNodeStyleGetMarginLeft(mNativePointer)); + margin.set(Spacing.TOP, jni_CSSNodeStyleGetMarginTop(mNativePointer)); + margin.set(Spacing.RIGHT, jni_CSSNodeStyleGetMarginRight(mNativePointer)); + margin.set(Spacing.BOTTOM, jni_CSSNodeStyleGetMarginBottom(mNativePointer)); + margin.set(Spacing.START, jni_CSSNodeStyleGetMarginStart(mNativePointer)); + margin.set(Spacing.END, jni_CSSNodeStyleGetMarginEnd(mNativePointer)); + return margin; + } + + private native void jni_CSSNodeStyleSetMarginLeft(int nativePointer, float marginLeft); + private native void jni_CSSNodeStyleSetMarginTop(int nativePointer, float marginTop); + private native void jni_CSSNodeStyleSetMarginRight(int nativePointer, float marginRight); + private native void jni_CSSNodeStyleSetMarginBottom(int nativePointer, float marginBottom); + private native void jni_CSSNodeStyleSetMarginStart(int nativePointer, float marginStart); + private native void jni_CSSNodeStyleSetMarginEnd(int nativePointer, float marginEnd); + @Override + public void setMargin(int spacingType, float margin) { + assertNativeInstance(); + switch (spacingType) { + case Spacing.LEFT: + jni_CSSNodeStyleSetMarginLeft(mNativePointer, margin); + break; + case Spacing.TOP: + jni_CSSNodeStyleSetMarginTop(mNativePointer, margin); + break; + case Spacing.RIGHT: + jni_CSSNodeStyleSetMarginRight(mNativePointer, margin); + break; + case Spacing.BOTTOM: + jni_CSSNodeStyleSetMarginBottom(mNativePointer, margin); + break; + case Spacing.START: + jni_CSSNodeStyleSetMarginStart(mNativePointer, margin); + break; + case Spacing.END: + jni_CSSNodeStyleSetMarginEnd(mNativePointer, margin); + break; + case Spacing.HORIZONTAL: + jni_CSSNodeStyleSetMarginLeft(mNativePointer, margin); + jni_CSSNodeStyleSetMarginRight(mNativePointer, margin); + jni_CSSNodeStyleSetMarginStart(mNativePointer, margin); + jni_CSSNodeStyleSetMarginEnd(mNativePointer, margin); + break; + case Spacing.VERTICAL: + jni_CSSNodeStyleSetMarginTop(mNativePointer, margin); + jni_CSSNodeStyleSetMarginBottom(mNativePointer, margin); + break; + case Spacing.ALL: + jni_CSSNodeStyleSetMarginLeft(mNativePointer, margin); + jni_CSSNodeStyleSetMarginRight(mNativePointer, margin); + jni_CSSNodeStyleSetMarginStart(mNativePointer, margin); + jni_CSSNodeStyleSetMarginEnd(mNativePointer, margin); + jni_CSSNodeStyleSetMarginTop(mNativePointer, margin); + jni_CSSNodeStyleSetMarginBottom(mNativePointer, margin); + break; + } + } + + private native float jni_CSSNodeStyleGetPaddingLeft(int nativePointer); + private native float jni_CSSNodeStyleGetPaddingTop(int nativePointer); + private native float jni_CSSNodeStyleGetPaddingRight(int nativePointer); + private native float jni_CSSNodeStyleGetPaddingBottom(int nativePointer); + private native float jni_CSSNodeStyleGetPaddingStart(int nativePointer); + private native float jni_CSSNodeStyleGetPaddingEnd(int nativePointer); + @Override + public Spacing getPadding() { + assertNativeInstance(); + Spacing padding = new Spacing(); + padding.set(Spacing.LEFT, jni_CSSNodeStyleGetPaddingLeft(mNativePointer)); + padding.set(Spacing.TOP, jni_CSSNodeStyleGetPaddingTop(mNativePointer)); + padding.set(Spacing.RIGHT, jni_CSSNodeStyleGetPaddingRight(mNativePointer)); + padding.set(Spacing.BOTTOM, jni_CSSNodeStyleGetPaddingBottom(mNativePointer)); + padding.set(Spacing.START, jni_CSSNodeStyleGetPaddingStart(mNativePointer)); + padding.set(Spacing.END, jni_CSSNodeStyleGetPaddingEnd(mNativePointer)); + return padding; + } + + private native void jni_CSSNodeStyleSetPaddingLeft(int nativePointer, float paddingLeft); + private native void jni_CSSNodeStyleSetPaddingTop(int nativePointer, float paddingTop); + private native void jni_CSSNodeStyleSetPaddingRight(int nativePointer, float paddingRight); + private native void jni_CSSNodeStyleSetPaddingBottom(int nativePointer, float paddingBottom); + private native void jni_CSSNodeStyleSetPaddingStart(int nativePointer, float paddingStart); + private native void jni_CSSNodeStyleSetPaddingEnd(int nativePointer, float paddingEnd); + @Override + public void setPadding(int spacingType, float padding) { + assertNativeInstance(); + switch (spacingType) { + case Spacing.LEFT: + jni_CSSNodeStyleSetPaddingLeft(mNativePointer, padding); + break; + case Spacing.TOP: + jni_CSSNodeStyleSetPaddingTop(mNativePointer, padding); + break; + case Spacing.RIGHT: + jni_CSSNodeStyleSetPaddingRight(mNativePointer, padding); + break; + case Spacing.BOTTOM: + jni_CSSNodeStyleSetPaddingBottom(mNativePointer, padding); + break; + case Spacing.START: + jni_CSSNodeStyleSetPaddingStart(mNativePointer, padding); + break; + case Spacing.END: + jni_CSSNodeStyleSetPaddingEnd(mNativePointer, padding); + break; + case Spacing.HORIZONTAL: + jni_CSSNodeStyleSetPaddingLeft(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingRight(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingStart(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingEnd(mNativePointer, padding); + break; + case Spacing.VERTICAL: + jni_CSSNodeStyleSetPaddingTop(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingBottom(mNativePointer, padding); + break; + case Spacing.ALL: + jni_CSSNodeStyleSetPaddingLeft(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingRight(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingStart(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingEnd(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingTop(mNativePointer, padding); + jni_CSSNodeStyleSetPaddingBottom(mNativePointer, padding); + break; + } + } + + @Override + public void setDefaultPadding(int spacingType, float padding) { + // TODO + } + + private native float jni_CSSNodeStyleGetBorderLeft(int nativePointer); + private native float jni_CSSNodeStyleGetBorderTop(int nativePointer); + private native float jni_CSSNodeStyleGetBorderRight(int nativePointer); + private native float jni_CSSNodeStyleGetBorderBottom(int nativePointer); + private native float jni_CSSNodeStyleGetBorderStart(int nativePointer); + private native float jni_CSSNodeStyleGetBorderEnd(int nativePointer); + @Override + public Spacing getBorder() { + assertNativeInstance(); + Spacing border = new Spacing(); + border.set(Spacing.LEFT, jni_CSSNodeStyleGetBorderLeft(mNativePointer)); + border.set(Spacing.TOP, jni_CSSNodeStyleGetBorderTop(mNativePointer)); + border.set(Spacing.RIGHT, jni_CSSNodeStyleGetBorderRight(mNativePointer)); + border.set(Spacing.BOTTOM, jni_CSSNodeStyleGetBorderBottom(mNativePointer)); + border.set(Spacing.START, jni_CSSNodeStyleGetBorderStart(mNativePointer)); + border.set(Spacing.END, jni_CSSNodeStyleGetBorderEnd(mNativePointer)); + return border; + } + + private native void jni_CSSNodeStyleSetBorderLeft(int nativePointer, float borderLeft); + private native void jni_CSSNodeStyleSetBorderTop(int nativePointer, float borderTop); + private native void jni_CSSNodeStyleSetBorderRight(int nativePointer, float borderRight); + private native void jni_CSSNodeStyleSetBorderBottom(int nativePointer, float borderBottom); + private native void jni_CSSNodeStyleSetBorderStart(int nativePointer, float borderStart); + private native void jni_CSSNodeStyleSetBorderEnd(int nativePointer, float borderEnd); + @Override + public void setBorder(int spacingType, float border) { + assertNativeInstance(); + switch (spacingType) { + case Spacing.LEFT: + jni_CSSNodeStyleSetBorderLeft(mNativePointer, border); + break; + case Spacing.TOP: + jni_CSSNodeStyleSetBorderTop(mNativePointer, border); + break; + case Spacing.RIGHT: + jni_CSSNodeStyleSetBorderRight(mNativePointer, border); + break; + case Spacing.BOTTOM: + jni_CSSNodeStyleSetBorderBottom(mNativePointer, border); + break; + case Spacing.START: + jni_CSSNodeStyleSetBorderStart(mNativePointer, border); + break; + case Spacing.END: + jni_CSSNodeStyleSetBorderEnd(mNativePointer, border); + break; + case Spacing.HORIZONTAL: + jni_CSSNodeStyleSetBorderLeft(mNativePointer, border); + jni_CSSNodeStyleSetBorderRight(mNativePointer, border); + jni_CSSNodeStyleSetBorderStart(mNativePointer, border); + jni_CSSNodeStyleSetBorderEnd(mNativePointer, border); + break; + case Spacing.VERTICAL: + jni_CSSNodeStyleSetBorderTop(mNativePointer, border); + jni_CSSNodeStyleSetBorderBottom(mNativePointer, border); + break; + case Spacing.ALL: + jni_CSSNodeStyleSetBorderLeft(mNativePointer, border); + jni_CSSNodeStyleSetBorderRight(mNativePointer, border); + jni_CSSNodeStyleSetBorderStart(mNativePointer, border); + jni_CSSNodeStyleSetBorderEnd(mNativePointer, border); + jni_CSSNodeStyleSetBorderTop(mNativePointer, border); + jni_CSSNodeStyleSetBorderBottom(mNativePointer, border); + break; + } + } + + @Override + public Spacing getPositionValue() { + Spacing position = new Spacing(); + position.set(Spacing.LEFT, getPositionLeft()); + position.set(Spacing.TOP, getPositionTop()); + position.set(Spacing.RIGHT, getPositionRight()); + position.set(Spacing.BOTTOM, getPositionBottom()); + return position; + } + + @Override + public void setPositionValue(int spacingType, float position) { + switch (spacingType) { + case Spacing.LEFT: + setPositionLeft(position); + break; + case Spacing.TOP: + setPositionTop(position); + break; + case Spacing.RIGHT: + setPositionRight(position); + break; + case Spacing.BOTTOM: + setPositionBottom(position); + break; + } + } + + private native float jni_CSSNodeStyleGetPositionTop(int nativePointer); + @Override + public float getPositionTop() { + assertNativeInstance(); + return jni_CSSNodeStyleGetPositionTop(mNativePointer); + } + + private native void jni_CSSNodeStyleSetPositionTop(int nativePointer, float positionTop); + @Override + public void setPositionTop(float positionTop) { + assertNativeInstance(); + jni_CSSNodeStyleSetPositionTop(mNativePointer, positionTop); + } + + private native float jni_CSSNodeStyleGetPositionBottom(int nativePointer); + @Override + public float getPositionBottom() { + assertNativeInstance(); + return jni_CSSNodeStyleGetPositionBottom(mNativePointer); + } + + private native void jni_CSSNodeStyleSetPositionBottom(int nativePointer, float positionBottom); + @Override + public void setPositionBottom(float positionBottom) { + assertNativeInstance(); + jni_CSSNodeStyleSetPositionBottom(mNativePointer, positionBottom); + } + + private native float jni_CSSNodeStyleGetPositionLeft(int nativePointer); + @Override + public float getPositionLeft() { + assertNativeInstance(); + return jni_CSSNodeStyleGetPositionLeft(mNativePointer); + } + + private native void jni_CSSNodeStyleSetPositionLeft(int nativePointer, float positionLeft); + @Override + public void setPositionLeft(float positionLeft) { + assertNativeInstance(); + jni_CSSNodeStyleSetPositionLeft(mNativePointer, positionLeft); + } + + private native float jni_CSSNodeStyleGetPositionRight(int nativePointer); + @Override + public float getPositionRight() { + assertNativeInstance(); + return jni_CSSNodeStyleGetPositionRight(mNativePointer); + } + + private native void jni_CSSNodeStyleSetPositionRight(int nativePointer, float positionRight); + @Override + public void setPositionRight(float positionRight) { + assertNativeInstance(); + jni_CSSNodeStyleSetPositionRight(mNativePointer, positionRight); + } + + private native float jni_CSSNodeStyleGetWidth(int nativePointer); + @Override + public float getStyleWidth() { + assertNativeInstance(); + return jni_CSSNodeStyleGetWidth(mNativePointer); + } + + private native void jni_CSSNodeStyleSetWidth(int nativePointer, float width); + @Override + public void setStyleWidth(float width) { + assertNativeInstance(); + jni_CSSNodeStyleSetWidth(mNativePointer, width); + } + + private native float jni_CSSNodeStyleGetHeight(int nativePointer); + @Override + public float getStyleHeight() { + assertNativeInstance(); + return jni_CSSNodeStyleGetHeight(mNativePointer); + } + + private native void jni_CSSNodeStyleSetHeight(int nativePointer, float height); + @Override + public void setStyleHeight(float height) { + assertNativeInstance(); + jni_CSSNodeStyleSetHeight(mNativePointer, height); + } + + private native float jni_CSSNodeStyleGetMinWidth(int nativePointer); + @Override + public float getStyleMinWidth() { + assertNativeInstance(); + return jni_CSSNodeStyleGetMinWidth(mNativePointer); + } + + private native void jni_CSSNodeStyleSetMinWidth(int nativePointer, float minWidth); + @Override + public void setStyleMinWidth(float minWidth) { + assertNativeInstance(); + jni_CSSNodeStyleSetMinWidth(mNativePointer, minWidth); + } + + private native float jni_CSSNodeStyleGetMinHeight(int nativePointer); + @Override + public float getStyleMinHeight() { + assertNativeInstance(); + return jni_CSSNodeStyleGetMinHeight(mNativePointer); + } + + private native void jni_CSSNodeStyleSetMinHeight(int nativePointer, float minHeight); + @Override + public void setStyleMinHeight(float minHeight) { + assertNativeInstance(); + jni_CSSNodeStyleSetMinHeight(mNativePointer, minHeight); + } + + private native float jni_CSSNodeStyleGetMaxWidth(int nativePointer); + @Override + public float getStyleMaxWidth() { + assertNativeInstance(); + return jni_CSSNodeStyleGetMaxWidth(mNativePointer); + } + + private native void jni_CSSNodeStyleSetMaxWidth(int nativePointer, float maxWidth); + @Override + public void setStyleMaxWidth(float maxWidth) { + assertNativeInstance(); + jni_CSSNodeStyleSetMaxWidth(mNativePointer, maxWidth); + } + + private native float jni_CSSNodeStyleGetMaxHeight(int nativePointer); + @Override + public float getStyleMaxHeight() { + assertNativeInstance(); + return jni_CSSNodeStyleGetMaxHeight(mNativePointer); + } + + private native void jni_CSSNodeStyleSetMaxHeight(int nativePointer, float maxheight); + @Override + public void setStyleMaxHeight(float maxheight) { + assertNativeInstance(); + jni_CSSNodeStyleSetMaxHeight(mNativePointer, maxheight); + } + + private native float jni_CSSNodeLayoutGetLeft(int nativePointer); + @Override + public float getLayoutX() { + assertNativeInstance(); + return jni_CSSNodeLayoutGetLeft(mNativePointer); + } + + private native float jni_CSSNodeLayoutGetTop(int nativePointer); + @Override + public float getLayoutY() { + assertNativeInstance(); + return jni_CSSNodeLayoutGetTop(mNativePointer); + } + + private native float jni_CSSNodeLayoutGetWidth(int nativePointer); + @Override + public float getLayoutWidth() { + assertNativeInstance(); + return jni_CSSNodeLayoutGetWidth(mNativePointer); + } + + private native float jni_CSSNodeLayoutGetHeight(int nativePointer); + @Override + public float getLayoutHeight() { + assertNativeInstance(); + return jni_CSSNodeLayoutGetHeight(mNativePointer); + } + + private native void jni_CSSNodeSetHasMeasureFunc(int nativePointer, boolean hasMeasureFunc); + @Override + public void setMeasureFunction(MeasureFunction measureFunction) { + assertNativeInstance(); + mMeasureFunction = measureFunction; + jni_CSSNodeSetHasMeasureFunc(mNativePointer, measureFunction != null); + } + + @DoNotStrip + public long measure(float width, int widthMode, float height, int heightMode) { + assertNativeInstance(); + if (!isMeasureDefined()) { + throw new RuntimeException("Measure function isn't defined!"); + } + + MeasureOutput output = new MeasureOutput(); + mMeasureFunction.measure( + this, + width, + CSSMeasureMode.values()[widthMode], + height, + CSSMeasureMode.values()[heightMode], + output); + return ((long) output.width) << 32 | ((long) output.height); + } + + @Override + public boolean isMeasureDefined() { + return mMeasureFunction != null; + } + + @Override + public boolean valuesEqual(float f1, float f2) { + return FloatUtil.floatsEqual(f1, f2); + } +} diff --git a/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactShadowNode.java b/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactShadowNode.java index df8ad675d..2fbb96216 100644 --- a/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactShadowNode.java +++ b/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactShadowNode.java @@ -94,7 +94,7 @@ public class ReactShadowNode extends CSSNode { } } - protected void markUpdated() { + public void markUpdated() { if (mNodeUpdated) { return; } @@ -110,7 +110,7 @@ public class ReactShadowNode extends CSSNode { } @Override - protected void dirty() { + public void dirty() { if (!isVirtual()) { super.dirty(); } diff --git a/ReactAndroid/src/main/java/com/facebook/react/views/art/ARTSurfaceViewManager.java b/ReactAndroid/src/main/java/com/facebook/react/views/art/ARTSurfaceViewManager.java index 45963735e..729fff291 100644 --- a/ReactAndroid/src/main/java/com/facebook/react/views/art/ARTSurfaceViewManager.java +++ b/ReactAndroid/src/main/java/com/facebook/react/views/art/ARTSurfaceViewManager.java @@ -12,7 +12,7 @@ package com.facebook.react.views.art; import android.graphics.Bitmap; import com.facebook.csslayout.CSSMeasureMode; -import com.facebook.csslayout.CSSNode; +import com.facebook.csslayout.CSSNodeAPI; import com.facebook.csslayout.MeasureOutput; import com.facebook.react.uimanager.BaseViewManager; import com.facebook.react.uimanager.ThemedReactContext; @@ -26,10 +26,10 @@ public class ARTSurfaceViewManager extends private static final String REACT_CLASS = "ARTSurfaceView"; - private static final CSSNode.MeasureFunction MEASURE_FUNCTION = new CSSNode.MeasureFunction() { + private static final CSSNodeAPI.MeasureFunction MEASURE_FUNCTION = new CSSNodeAPI.MeasureFunction() { @Override public void measure( - CSSNode node, + CSSNodeAPI node, float width, CSSMeasureMode widthMode, float height, diff --git a/ReactAndroid/src/main/java/com/facebook/react/views/progressbar/ProgressBarShadowNode.java b/ReactAndroid/src/main/java/com/facebook/react/views/progressbar/ProgressBarShadowNode.java index ce85293fb..d5a3779d2 100644 --- a/ReactAndroid/src/main/java/com/facebook/react/views/progressbar/ProgressBarShadowNode.java +++ b/ReactAndroid/src/main/java/com/facebook/react/views/progressbar/ProgressBarShadowNode.java @@ -20,7 +20,7 @@ import android.view.ViewGroup; import android.widget.ProgressBar; import com.facebook.csslayout.CSSMeasureMode; -import com.facebook.csslayout.CSSNode; +import com.facebook.csslayout.CSSNodeAPI; import com.facebook.csslayout.MeasureOutput; import com.facebook.react.uimanager.LayoutShadowNode; import com.facebook.react.uimanager.annotations.ReactProp; @@ -30,7 +30,7 @@ import com.facebook.react.uimanager.annotations.ReactProp; * {@link android.R.attr.progressBarStyle} for possible styles. ReactProgressBarViewManager * manages how this style is applied to the ProgressBar. */ -public class ProgressBarShadowNode extends LayoutShadowNode implements CSSNode.MeasureFunction { +public class ProgressBarShadowNode extends LayoutShadowNode implements CSSNodeAPI.MeasureFunction { private String mStyle = ReactProgressBarViewManager.DEFAULT_STYLE; @@ -53,7 +53,7 @@ public class ProgressBarShadowNode extends LayoutShadowNode implements CSSNode.M @Override public void measure( - CSSNode node, + CSSNodeAPI node, float width, CSSMeasureMode widthMode, float height, diff --git a/ReactAndroid/src/main/java/com/facebook/react/views/slider/ReactSliderManager.java b/ReactAndroid/src/main/java/com/facebook/react/views/slider/ReactSliderManager.java index d02771d3e..87f930ab4 100644 --- a/ReactAndroid/src/main/java/com/facebook/react/views/slider/ReactSliderManager.java +++ b/ReactAndroid/src/main/java/com/facebook/react/views/slider/ReactSliderManager.java @@ -16,7 +16,7 @@ import android.view.ViewGroup; import android.widget.SeekBar; import com.facebook.csslayout.CSSMeasureMode; -import com.facebook.csslayout.CSSNode; +import com.facebook.csslayout.CSSNodeAPI; import com.facebook.csslayout.MeasureOutput; import com.facebook.react.bridge.ReactContext; import com.facebook.react.common.MapBuilder; @@ -39,7 +39,7 @@ public class ReactSliderManager extends SimpleViewManager { private static final String REACT_CLASS = "RCTSlider"; static class ReactSliderShadowNode extends LayoutShadowNode implements - CSSNode.MeasureFunction { + CSSNodeAPI.MeasureFunction { private int mWidth; private int mHeight; @@ -51,7 +51,7 @@ public class ReactSliderManager extends SimpleViewManager { @Override public void measure( - CSSNode node, + CSSNodeAPI node, float width, CSSMeasureMode widthMode, float height, diff --git a/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitchManager.java b/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitchManager.java index 2e6ef890d..d05f8bae3 100644 --- a/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitchManager.java +++ b/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitchManager.java @@ -15,7 +15,7 @@ import android.view.ViewGroup; import android.widget.CompoundButton; import com.facebook.csslayout.CSSMeasureMode; -import com.facebook.csslayout.CSSNode; +import com.facebook.csslayout.CSSNodeAPI; import com.facebook.csslayout.MeasureOutput; import com.facebook.react.bridge.ReactContext; import com.facebook.react.uimanager.LayoutShadowNode; @@ -33,7 +33,7 @@ public class ReactSwitchManager extends SimpleViewManager { private static final String REACT_CLASS = "AndroidSwitch"; static class ReactSwitchShadowNode extends LayoutShadowNode implements - CSSNode.MeasureFunction { + CSSNodeAPI.MeasureFunction { private int mWidth; private int mHeight; @@ -45,7 +45,7 @@ public class ReactSwitchManager extends SimpleViewManager { @Override public void measure( - CSSNode node, + CSSNodeAPI node, float width, CSSMeasureMode widthMode, float height, diff --git a/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextShadowNode.java b/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextShadowNode.java index 43a699814..498ff6f89 100644 --- a/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextShadowNode.java +++ b/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextShadowNode.java @@ -34,6 +34,7 @@ import com.facebook.csslayout.CSSDirection; import com.facebook.csslayout.CSSConstants; import com.facebook.csslayout.CSSMeasureMode; import com.facebook.csslayout.CSSNode; +import com.facebook.csslayout.CSSNodeAPI; import com.facebook.csslayout.MeasureOutput; import com.facebook.infer.annotation.Assertions; import com.facebook.react.bridge.JSApplicationIllegalArgumentException; @@ -210,11 +211,11 @@ public class ReactTextShadowNode extends LayoutShadowNode { return sb; } - private static final CSSNode.MeasureFunction TEXT_MEASURE_FUNCTION = - new CSSNode.MeasureFunction() { + private static final CSSNodeAPI.MeasureFunction TEXT_MEASURE_FUNCTION = + new CSSNodeAPI.MeasureFunction() { @Override public void measure( - CSSNode node, + CSSNodeAPI node, float width, CSSMeasureMode widthMode, float height, @@ -391,7 +392,7 @@ public class ReactTextShadowNode extends LayoutShadowNode { } @Override - protected void markUpdated() { + public void markUpdated() { super.markUpdated(); // We mark virtual anchor node as dirty as updated text needs to be re-measured if (!mIsVirtual) { diff --git a/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputShadowNode.java b/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputShadowNode.java index 13fe74dd6..c33d26ced 100644 --- a/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputShadowNode.java +++ b/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputShadowNode.java @@ -17,7 +17,7 @@ import android.view.ViewGroup; import android.widget.EditText; import com.facebook.csslayout.CSSMeasureMode; -import com.facebook.csslayout.CSSNode; +import com.facebook.csslayout.CSSNodeAPI; import com.facebook.csslayout.MeasureOutput; import com.facebook.csslayout.Spacing; import com.facebook.infer.annotation.Assertions; @@ -33,7 +33,7 @@ import com.facebook.react.views.text.ReactTextUpdate; @VisibleForTesting public class ReactTextInputShadowNode extends ReactTextShadowNode implements - CSSNode.MeasureFunction { + CSSNodeAPI.MeasureFunction { private @Nullable EditText mEditText; private @Nullable float[] mComputedPadding; @@ -66,7 +66,7 @@ public class ReactTextInputShadowNode extends ReactTextShadowNode implements @Override public void measure( - CSSNode node, + CSSNodeAPI node, float width, CSSMeasureMode widthMode, float height,