732 lines
24 KiB
Java
732 lines
24 KiB
Java
package com.facebook.yoga;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
public class YogaNode implements Cloneable {
|
|
private YogaBaselineFunction mBaselineFunction;
|
|
|
|
private float mBorderBottom;
|
|
|
|
private float mBorderLeft;
|
|
|
|
private float mBorderRight;
|
|
|
|
private float mBorderTop;
|
|
|
|
private List<YogaNode> mChildren;
|
|
|
|
private Object mData;
|
|
|
|
private int mEdgeSetFlag;
|
|
|
|
private boolean mHasNewLayout = true;
|
|
|
|
private boolean mHasSetPosition;
|
|
|
|
private float mHeight = 1.0E21F;
|
|
|
|
private int mLayoutDirection;
|
|
|
|
private float mLeft = 1.0E21F;
|
|
|
|
private float mMarginBottom;
|
|
|
|
private float mMarginLeft;
|
|
|
|
private float mMarginRight;
|
|
|
|
private float mMarginTop;
|
|
|
|
private YogaMeasureFunction mMeasureFunction;
|
|
|
|
private long mNativePointer = jni_YGNodeNew();
|
|
|
|
private float mPaddingBottom;
|
|
|
|
private float mPaddingLeft;
|
|
|
|
private float mPaddingRight;
|
|
|
|
private float mPaddingTop;
|
|
|
|
private YogaNode mParent;
|
|
|
|
private float mTop = 1.0E21F;
|
|
|
|
private float mWidth = 1.0E21F;
|
|
|
|
public YogaNode() {
|
|
if (this.mNativePointer != 0L)
|
|
return;
|
|
throw new IllegalStateException("Failed to allocate native memory");
|
|
}
|
|
|
|
public YogaNode(YogaConfig paramYogaConfig) {
|
|
if (this.mNativePointer != 0L)
|
|
return;
|
|
throw new IllegalStateException("Failed to allocate native memory");
|
|
}
|
|
|
|
private native void jni_YGNodeCalculateLayout(long paramLong, float paramFloat1, float paramFloat2);
|
|
|
|
private native long jni_YGNodeClone(long paramLong, Object paramObject);
|
|
|
|
private native void jni_YGNodeCopyStyle(long paramLong1, long paramLong2);
|
|
|
|
private native void jni_YGNodeFree(long paramLong);
|
|
|
|
static native int jni_YGNodeGetInstanceCount();
|
|
|
|
private native void jni_YGNodeInsertChild(long paramLong1, long paramLong2, int paramInt);
|
|
|
|
private native boolean jni_YGNodeIsDirty(long paramLong);
|
|
|
|
private native void jni_YGNodeMarkDirty(long paramLong);
|
|
|
|
private native void jni_YGNodeMarkDirtyAndPropogateToDescendants(long paramLong);
|
|
|
|
private native long jni_YGNodeNew();
|
|
|
|
private native long jni_YGNodeNewWithConfig(long paramLong);
|
|
|
|
private native void jni_YGNodePrint(long paramLong);
|
|
|
|
private native void jni_YGNodeRemoveChild(long paramLong1, long paramLong2);
|
|
|
|
private native void jni_YGNodeReset(long paramLong);
|
|
|
|
private native void jni_YGNodeSetHasBaselineFunc(long paramLong, boolean paramBoolean);
|
|
|
|
private native void jni_YGNodeSetHasMeasureFunc(long paramLong, boolean paramBoolean);
|
|
|
|
private native int jni_YGNodeStyleGetAlignContent(long paramLong);
|
|
|
|
private native int jni_YGNodeStyleGetAlignItems(long paramLong);
|
|
|
|
private native int jni_YGNodeStyleGetAlignSelf(long paramLong);
|
|
|
|
private native float jni_YGNodeStyleGetAspectRatio(long paramLong);
|
|
|
|
private native float jni_YGNodeStyleGetBorder(long paramLong, int paramInt);
|
|
|
|
private native int jni_YGNodeStyleGetDirection(long paramLong);
|
|
|
|
private native int jni_YGNodeStyleGetDisplay(long paramLong);
|
|
|
|
private native Object jni_YGNodeStyleGetFlexBasis(long paramLong);
|
|
|
|
private native int jni_YGNodeStyleGetFlexDirection(long paramLong);
|
|
|
|
private native float jni_YGNodeStyleGetFlexGrow(long paramLong);
|
|
|
|
private native float jni_YGNodeStyleGetFlexShrink(long paramLong);
|
|
|
|
private native Object jni_YGNodeStyleGetHeight(long paramLong);
|
|
|
|
private native int jni_YGNodeStyleGetJustifyContent(long paramLong);
|
|
|
|
private native Object jni_YGNodeStyleGetMargin(long paramLong, int paramInt);
|
|
|
|
private native Object jni_YGNodeStyleGetMaxHeight(long paramLong);
|
|
|
|
private native Object jni_YGNodeStyleGetMaxWidth(long paramLong);
|
|
|
|
private native Object jni_YGNodeStyleGetMinHeight(long paramLong);
|
|
|
|
private native Object jni_YGNodeStyleGetMinWidth(long paramLong);
|
|
|
|
private native int jni_YGNodeStyleGetOverflow(long paramLong);
|
|
|
|
private native Object jni_YGNodeStyleGetPadding(long paramLong, int paramInt);
|
|
|
|
private native Object jni_YGNodeStyleGetPosition(long paramLong, int paramInt);
|
|
|
|
private native int jni_YGNodeStyleGetPositionType(long paramLong);
|
|
|
|
private native Object jni_YGNodeStyleGetWidth(long paramLong);
|
|
|
|
private native void jni_YGNodeStyleSetAlignContent(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetAlignItems(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetAlignSelf(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetAspectRatio(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetBorder(long paramLong, int paramInt, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetDirection(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetDisplay(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetFlex(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetFlexBasis(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetFlexBasisAuto(long paramLong);
|
|
|
|
private native void jni_YGNodeStyleSetFlexBasisPercent(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetFlexDirection(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetFlexGrow(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetFlexShrink(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetFlexWrap(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetHeight(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetHeightAuto(long paramLong);
|
|
|
|
private native void jni_YGNodeStyleSetHeightPercent(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetJustifyContent(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetMargin(long paramLong, int paramInt, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMarginAuto(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetMarginPercent(long paramLong, int paramInt, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMaxHeight(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMaxHeightPercent(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMaxWidth(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMaxWidthPercent(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMinHeight(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMinHeightPercent(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMinWidth(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetMinWidthPercent(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetOverflow(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetPadding(long paramLong, int paramInt, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetPaddingPercent(long paramLong, int paramInt, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetPosition(long paramLong, int paramInt, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetPositionPercent(long paramLong, int paramInt, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetPositionType(long paramLong, int paramInt);
|
|
|
|
private native void jni_YGNodeStyleSetWidth(long paramLong, float paramFloat);
|
|
|
|
private native void jni_YGNodeStyleSetWidthAuto(long paramLong);
|
|
|
|
private native void jni_YGNodeStyleSetWidthPercent(long paramLong, float paramFloat);
|
|
|
|
public void addChildAt(YogaNode paramYogaNode, int paramInt) {
|
|
if (paramYogaNode.mParent == null) {
|
|
if (this.mChildren == null)
|
|
this.mChildren = new ArrayList<YogaNode>(4);
|
|
this.mChildren.add(paramInt, paramYogaNode);
|
|
paramYogaNode.mParent = this;
|
|
jni_YGNodeInsertChild(this.mNativePointer, paramYogaNode.mNativePointer, paramInt);
|
|
return;
|
|
}
|
|
throw new IllegalStateException("Child already has a parent, it must be removed first.");
|
|
}
|
|
|
|
public final float baseline(float paramFloat1, float paramFloat2) {
|
|
return this.mBaselineFunction.baseline(this, paramFloat1, paramFloat2);
|
|
}
|
|
|
|
public void calculateLayout(float paramFloat1, float paramFloat2) {
|
|
jni_YGNodeCalculateLayout(this.mNativePointer, paramFloat1, paramFloat2);
|
|
}
|
|
|
|
public YogaNode clone() throws CloneNotSupportedException {
|
|
YogaNode yogaNode = (YogaNode)super.clone();
|
|
yogaNode.mNativePointer = jni_YGNodeClone(this.mNativePointer, yogaNode);
|
|
List<YogaNode> list = this.mChildren;
|
|
if (list != null) {
|
|
list = (List<YogaNode>)((ArrayList)list).clone();
|
|
} else {
|
|
list = null;
|
|
}
|
|
yogaNode.mChildren = list;
|
|
return yogaNode;
|
|
}
|
|
|
|
public void copyStyle(YogaNode paramYogaNode) {
|
|
jni_YGNodeCopyStyle(this.mNativePointer, paramYogaNode.mNativePointer);
|
|
}
|
|
|
|
public void dirty() {
|
|
jni_YGNodeMarkDirty(this.mNativePointer);
|
|
}
|
|
|
|
public void dirtyAllDescendants() {
|
|
jni_YGNodeMarkDirtyAndPropogateToDescendants(this.mNativePointer);
|
|
}
|
|
|
|
protected void finalize() throws Throwable {
|
|
try {
|
|
jni_YGNodeFree(this.mNativePointer);
|
|
return;
|
|
} finally {
|
|
super.finalize();
|
|
}
|
|
}
|
|
|
|
public YogaAlign getAlignContent() {
|
|
return YogaAlign.fromInt(jni_YGNodeStyleGetAlignContent(this.mNativePointer));
|
|
}
|
|
|
|
public YogaAlign getAlignItems() {
|
|
return YogaAlign.fromInt(jni_YGNodeStyleGetAlignItems(this.mNativePointer));
|
|
}
|
|
|
|
public YogaAlign getAlignSelf() {
|
|
return YogaAlign.fromInt(jni_YGNodeStyleGetAlignSelf(this.mNativePointer));
|
|
}
|
|
|
|
public float getAspectRatio() {
|
|
return jni_YGNodeStyleGetAspectRatio(this.mNativePointer);
|
|
}
|
|
|
|
public float getBorder(YogaEdge paramYogaEdge) {
|
|
return ((this.mEdgeSetFlag & 0x4) != 4) ? 1.0E21F : jni_YGNodeStyleGetBorder(this.mNativePointer, paramYogaEdge.intValue());
|
|
}
|
|
|
|
public YogaNode getChildAt(int paramInt) {
|
|
return this.mChildren.get(paramInt);
|
|
}
|
|
|
|
public int getChildCount() {
|
|
List<YogaNode> list = this.mChildren;
|
|
return (list == null) ? 0 : list.size();
|
|
}
|
|
|
|
public Object getData() {
|
|
return this.mData;
|
|
}
|
|
|
|
public YogaDisplay getDisplay() {
|
|
return YogaDisplay.fromInt(jni_YGNodeStyleGetDisplay(this.mNativePointer));
|
|
}
|
|
|
|
public YogaValue getFlexBasis() {
|
|
return (YogaValue)jni_YGNodeStyleGetFlexBasis(this.mNativePointer);
|
|
}
|
|
|
|
public YogaFlexDirection getFlexDirection() {
|
|
return YogaFlexDirection.fromInt(jni_YGNodeStyleGetFlexDirection(this.mNativePointer));
|
|
}
|
|
|
|
public float getFlexGrow() {
|
|
return jni_YGNodeStyleGetFlexGrow(this.mNativePointer);
|
|
}
|
|
|
|
public float getFlexShrink() {
|
|
return jni_YGNodeStyleGetFlexShrink(this.mNativePointer);
|
|
}
|
|
|
|
public YogaValue getHeight() {
|
|
return (YogaValue)jni_YGNodeStyleGetHeight(this.mNativePointer);
|
|
}
|
|
|
|
public YogaJustify getJustifyContent() {
|
|
return YogaJustify.fromInt(jni_YGNodeStyleGetJustifyContent(this.mNativePointer));
|
|
}
|
|
|
|
public float getLayoutBorder(YogaEdge paramYogaEdge) {
|
|
switch (null.a[paramYogaEdge.ordinal()]) {
|
|
default:
|
|
throw new IllegalArgumentException("Cannot get layout border of multi-edge shorthands");
|
|
case 6:
|
|
return (getLayoutDirection() == YogaDirection.RTL) ? this.mBorderLeft : this.mBorderRight;
|
|
case 5:
|
|
return (getLayoutDirection() == YogaDirection.RTL) ? this.mBorderRight : this.mBorderLeft;
|
|
case 4:
|
|
return this.mBorderBottom;
|
|
case 3:
|
|
return this.mBorderRight;
|
|
case 2:
|
|
return this.mBorderTop;
|
|
case 1:
|
|
break;
|
|
}
|
|
return this.mBorderLeft;
|
|
}
|
|
|
|
public YogaDirection getLayoutDirection() {
|
|
return YogaDirection.fromInt(this.mLayoutDirection);
|
|
}
|
|
|
|
public float getLayoutHeight() {
|
|
return this.mHeight;
|
|
}
|
|
|
|
public float getLayoutMargin(YogaEdge paramYogaEdge) {
|
|
switch (null.a[paramYogaEdge.ordinal()]) {
|
|
default:
|
|
throw new IllegalArgumentException("Cannot get layout margins of multi-edge shorthands");
|
|
case 6:
|
|
return (getLayoutDirection() == YogaDirection.RTL) ? this.mMarginLeft : this.mMarginRight;
|
|
case 5:
|
|
return (getLayoutDirection() == YogaDirection.RTL) ? this.mMarginRight : this.mMarginLeft;
|
|
case 4:
|
|
return this.mMarginBottom;
|
|
case 3:
|
|
return this.mMarginRight;
|
|
case 2:
|
|
return this.mMarginTop;
|
|
case 1:
|
|
break;
|
|
}
|
|
return this.mMarginLeft;
|
|
}
|
|
|
|
public float getLayoutPadding(YogaEdge paramYogaEdge) {
|
|
switch (null.a[paramYogaEdge.ordinal()]) {
|
|
default:
|
|
throw new IllegalArgumentException("Cannot get layout paddings of multi-edge shorthands");
|
|
case 6:
|
|
return (getLayoutDirection() == YogaDirection.RTL) ? this.mPaddingLeft : this.mPaddingRight;
|
|
case 5:
|
|
return (getLayoutDirection() == YogaDirection.RTL) ? this.mPaddingRight : this.mPaddingLeft;
|
|
case 4:
|
|
return this.mPaddingBottom;
|
|
case 3:
|
|
return this.mPaddingRight;
|
|
case 2:
|
|
return this.mPaddingTop;
|
|
case 1:
|
|
break;
|
|
}
|
|
return this.mPaddingLeft;
|
|
}
|
|
|
|
public float getLayoutWidth() {
|
|
return this.mWidth;
|
|
}
|
|
|
|
public float getLayoutX() {
|
|
return this.mLeft;
|
|
}
|
|
|
|
public float getLayoutY() {
|
|
return this.mTop;
|
|
}
|
|
|
|
public YogaValue getMargin(YogaEdge paramYogaEdge) {
|
|
return ((this.mEdgeSetFlag & 0x1) != 1) ? YogaValue.UNDEFINED : (YogaValue)jni_YGNodeStyleGetMargin(this.mNativePointer, paramYogaEdge.intValue());
|
|
}
|
|
|
|
public YogaValue getMaxHeight() {
|
|
return (YogaValue)jni_YGNodeStyleGetMaxHeight(this.mNativePointer);
|
|
}
|
|
|
|
public YogaValue getMaxWidth() {
|
|
return (YogaValue)jni_YGNodeStyleGetMaxWidth(this.mNativePointer);
|
|
}
|
|
|
|
public YogaValue getMinHeight() {
|
|
return (YogaValue)jni_YGNodeStyleGetMinHeight(this.mNativePointer);
|
|
}
|
|
|
|
public YogaValue getMinWidth() {
|
|
return (YogaValue)jni_YGNodeStyleGetMinWidth(this.mNativePointer);
|
|
}
|
|
|
|
public YogaOverflow getOverflow() {
|
|
return YogaOverflow.fromInt(jni_YGNodeStyleGetOverflow(this.mNativePointer));
|
|
}
|
|
|
|
public YogaValue getPadding(YogaEdge paramYogaEdge) {
|
|
return ((this.mEdgeSetFlag & 0x2) != 2) ? YogaValue.UNDEFINED : (YogaValue)jni_YGNodeStyleGetPadding(this.mNativePointer, paramYogaEdge.intValue());
|
|
}
|
|
|
|
public YogaNode getParent() {
|
|
return this.mParent;
|
|
}
|
|
|
|
public YogaValue getPosition(YogaEdge paramYogaEdge) {
|
|
return !this.mHasSetPosition ? YogaValue.UNDEFINED : (YogaValue)jni_YGNodeStyleGetPosition(this.mNativePointer, paramYogaEdge.intValue());
|
|
}
|
|
|
|
public YogaPositionType getPositionType() {
|
|
return YogaPositionType.fromInt(jni_YGNodeStyleGetPositionType(this.mNativePointer));
|
|
}
|
|
|
|
public YogaDirection getStyleDirection() {
|
|
return YogaDirection.fromInt(jni_YGNodeStyleGetDirection(this.mNativePointer));
|
|
}
|
|
|
|
public YogaValue getWidth() {
|
|
return (YogaValue)jni_YGNodeStyleGetWidth(this.mNativePointer);
|
|
}
|
|
|
|
public boolean hasNewLayout() {
|
|
return this.mHasNewLayout;
|
|
}
|
|
|
|
public int indexOf(YogaNode paramYogaNode) {
|
|
List<YogaNode> list = this.mChildren;
|
|
return (list == null) ? -1 : list.indexOf(paramYogaNode);
|
|
}
|
|
|
|
public boolean isDirty() {
|
|
return jni_YGNodeIsDirty(this.mNativePointer);
|
|
}
|
|
|
|
public boolean isMeasureDefined() {
|
|
return (this.mMeasureFunction != null);
|
|
}
|
|
|
|
public void markLayoutSeen() {
|
|
this.mHasNewLayout = false;
|
|
}
|
|
|
|
public final long measure(float paramFloat1, int paramInt1, float paramFloat2, int paramInt2) {
|
|
if (isMeasureDefined())
|
|
return this.mMeasureFunction.measure(this, paramFloat1, YogaMeasureMode.fromInt(paramInt1), paramFloat2, YogaMeasureMode.fromInt(paramInt2));
|
|
throw new RuntimeException("Measure function isn't defined!");
|
|
}
|
|
|
|
public void print() {
|
|
jni_YGNodePrint(this.mNativePointer);
|
|
}
|
|
|
|
public YogaNode removeChildAt(int paramInt) {
|
|
YogaNode yogaNode = this.mChildren.remove(paramInt);
|
|
yogaNode.mParent = null;
|
|
jni_YGNodeRemoveChild(this.mNativePointer, yogaNode.mNativePointer);
|
|
return yogaNode;
|
|
}
|
|
|
|
public void reset() {
|
|
this.mEdgeSetFlag = 0;
|
|
this.mHasSetPosition = false;
|
|
this.mHasNewLayout = true;
|
|
this.mWidth = 1.0E21F;
|
|
this.mHeight = 1.0E21F;
|
|
this.mTop = 1.0E21F;
|
|
this.mLeft = 1.0E21F;
|
|
this.mMarginLeft = 0.0F;
|
|
this.mMarginTop = 0.0F;
|
|
this.mMarginRight = 0.0F;
|
|
this.mMarginBottom = 0.0F;
|
|
this.mPaddingLeft = 0.0F;
|
|
this.mPaddingTop = 0.0F;
|
|
this.mPaddingRight = 0.0F;
|
|
this.mPaddingBottom = 0.0F;
|
|
this.mBorderLeft = 0.0F;
|
|
this.mBorderTop = 0.0F;
|
|
this.mBorderRight = 0.0F;
|
|
this.mBorderBottom = 0.0F;
|
|
this.mLayoutDirection = 0;
|
|
this.mMeasureFunction = null;
|
|
this.mBaselineFunction = null;
|
|
this.mData = null;
|
|
jni_YGNodeReset(this.mNativePointer);
|
|
}
|
|
|
|
public void setAlignContent(YogaAlign paramYogaAlign) {
|
|
jni_YGNodeStyleSetAlignContent(this.mNativePointer, paramYogaAlign.intValue());
|
|
}
|
|
|
|
public void setAlignItems(YogaAlign paramYogaAlign) {
|
|
jni_YGNodeStyleSetAlignItems(this.mNativePointer, paramYogaAlign.intValue());
|
|
}
|
|
|
|
public void setAlignSelf(YogaAlign paramYogaAlign) {
|
|
jni_YGNodeStyleSetAlignSelf(this.mNativePointer, paramYogaAlign.intValue());
|
|
}
|
|
|
|
public void setAspectRatio(float paramFloat) {
|
|
jni_YGNodeStyleSetAspectRatio(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setBaselineFunction(YogaBaselineFunction paramYogaBaselineFunction) {
|
|
boolean bool;
|
|
this.mBaselineFunction = paramYogaBaselineFunction;
|
|
long l = this.mNativePointer;
|
|
if (paramYogaBaselineFunction != null) {
|
|
bool = true;
|
|
} else {
|
|
bool = false;
|
|
}
|
|
jni_YGNodeSetHasBaselineFunc(l, bool);
|
|
}
|
|
|
|
public void setBorder(YogaEdge paramYogaEdge, float paramFloat) {
|
|
this.mEdgeSetFlag |= 0x4;
|
|
jni_YGNodeStyleSetBorder(this.mNativePointer, paramYogaEdge.intValue(), paramFloat);
|
|
}
|
|
|
|
public void setData(Object paramObject) {
|
|
this.mData = paramObject;
|
|
}
|
|
|
|
public void setDirection(YogaDirection paramYogaDirection) {
|
|
jni_YGNodeStyleSetDirection(this.mNativePointer, paramYogaDirection.intValue());
|
|
}
|
|
|
|
public void setDisplay(YogaDisplay paramYogaDisplay) {
|
|
jni_YGNodeStyleSetDisplay(this.mNativePointer, paramYogaDisplay.intValue());
|
|
}
|
|
|
|
public void setFlex(float paramFloat) {
|
|
jni_YGNodeStyleSetFlex(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setFlexBasis(float paramFloat) {
|
|
jni_YGNodeStyleSetFlexBasis(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setFlexBasisAuto() {
|
|
jni_YGNodeStyleSetFlexBasisAuto(this.mNativePointer);
|
|
}
|
|
|
|
public void setFlexBasisPercent(float paramFloat) {
|
|
jni_YGNodeStyleSetFlexBasisPercent(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setFlexDirection(YogaFlexDirection paramYogaFlexDirection) {
|
|
jni_YGNodeStyleSetFlexDirection(this.mNativePointer, paramYogaFlexDirection.intValue());
|
|
}
|
|
|
|
public void setFlexGrow(float paramFloat) {
|
|
jni_YGNodeStyleSetFlexGrow(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setFlexShrink(float paramFloat) {
|
|
jni_YGNodeStyleSetFlexShrink(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setHeight(float paramFloat) {
|
|
jni_YGNodeStyleSetHeight(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setHeightAuto() {
|
|
jni_YGNodeStyleSetHeightAuto(this.mNativePointer);
|
|
}
|
|
|
|
public void setHeightPercent(float paramFloat) {
|
|
jni_YGNodeStyleSetHeightPercent(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setJustifyContent(YogaJustify paramYogaJustify) {
|
|
jni_YGNodeStyleSetJustifyContent(this.mNativePointer, paramYogaJustify.intValue());
|
|
}
|
|
|
|
public void setMargin(YogaEdge paramYogaEdge, float paramFloat) {
|
|
this.mEdgeSetFlag |= 0x1;
|
|
jni_YGNodeStyleSetMargin(this.mNativePointer, paramYogaEdge.intValue(), paramFloat);
|
|
}
|
|
|
|
public void setMarginAuto(YogaEdge paramYogaEdge) {
|
|
this.mEdgeSetFlag |= 0x1;
|
|
jni_YGNodeStyleSetMarginAuto(this.mNativePointer, paramYogaEdge.intValue());
|
|
}
|
|
|
|
public void setMarginPercent(YogaEdge paramYogaEdge, float paramFloat) {
|
|
this.mEdgeSetFlag |= 0x1;
|
|
jni_YGNodeStyleSetMarginPercent(this.mNativePointer, paramYogaEdge.intValue(), paramFloat);
|
|
}
|
|
|
|
public void setMaxHeight(float paramFloat) {
|
|
jni_YGNodeStyleSetMaxHeight(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setMaxHeightPercent(float paramFloat) {
|
|
jni_YGNodeStyleSetMaxHeightPercent(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setMaxWidth(float paramFloat) {
|
|
jni_YGNodeStyleSetMaxWidth(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setMaxWidthPercent(float paramFloat) {
|
|
jni_YGNodeStyleSetMaxWidthPercent(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setMeasureFunction(YogaMeasureFunction paramYogaMeasureFunction) {
|
|
boolean bool;
|
|
this.mMeasureFunction = paramYogaMeasureFunction;
|
|
long l = this.mNativePointer;
|
|
if (paramYogaMeasureFunction != null) {
|
|
bool = true;
|
|
} else {
|
|
bool = false;
|
|
}
|
|
jni_YGNodeSetHasMeasureFunc(l, bool);
|
|
}
|
|
|
|
public void setMinHeight(float paramFloat) {
|
|
jni_YGNodeStyleSetMinHeight(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setMinHeightPercent(float paramFloat) {
|
|
jni_YGNodeStyleSetMinHeightPercent(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setMinWidth(float paramFloat) {
|
|
jni_YGNodeStyleSetMinWidth(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setMinWidthPercent(float paramFloat) {
|
|
jni_YGNodeStyleSetMinWidthPercent(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setOverflow(YogaOverflow paramYogaOverflow) {
|
|
jni_YGNodeStyleSetOverflow(this.mNativePointer, paramYogaOverflow.intValue());
|
|
}
|
|
|
|
public void setPadding(YogaEdge paramYogaEdge, float paramFloat) {
|
|
this.mEdgeSetFlag |= 0x2;
|
|
jni_YGNodeStyleSetPadding(this.mNativePointer, paramYogaEdge.intValue(), paramFloat);
|
|
}
|
|
|
|
public void setPaddingPercent(YogaEdge paramYogaEdge, float paramFloat) {
|
|
this.mEdgeSetFlag |= 0x2;
|
|
jni_YGNodeStyleSetPaddingPercent(this.mNativePointer, paramYogaEdge.intValue(), paramFloat);
|
|
}
|
|
|
|
public void setPosition(YogaEdge paramYogaEdge, float paramFloat) {
|
|
this.mHasSetPosition = true;
|
|
jni_YGNodeStyleSetPosition(this.mNativePointer, paramYogaEdge.intValue(), paramFloat);
|
|
}
|
|
|
|
public void setPositionPercent(YogaEdge paramYogaEdge, float paramFloat) {
|
|
this.mHasSetPosition = true;
|
|
jni_YGNodeStyleSetPositionPercent(this.mNativePointer, paramYogaEdge.intValue(), paramFloat);
|
|
}
|
|
|
|
public void setPositionType(YogaPositionType paramYogaPositionType) {
|
|
jni_YGNodeStyleSetPositionType(this.mNativePointer, paramYogaPositionType.intValue());
|
|
}
|
|
|
|
public void setWidth(float paramFloat) {
|
|
jni_YGNodeStyleSetWidth(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setWidthAuto() {
|
|
jni_YGNodeStyleSetWidthAuto(this.mNativePointer);
|
|
}
|
|
|
|
public void setWidthPercent(float paramFloat) {
|
|
jni_YGNodeStyleSetWidthPercent(this.mNativePointer, paramFloat);
|
|
}
|
|
|
|
public void setWrap(YogaWrap paramYogaWrap) {
|
|
jni_YGNodeStyleSetFlexWrap(this.mNativePointer, paramYogaWrap.intValue());
|
|
}
|
|
}
|
|
|
|
|
|
/* Location: C:\Users\august\Desktop\tik\df_rn_kit\classes.jar.jar!\com\facebook\yoga\YogaNode.class
|
|
* Java compiler version: 6 (50.0)
|
|
* JD-Core Version: 1.1.3
|
|
*/ |