From dde2b349f22b6e1ee2dc9e637b1575afe1249f82 Mon Sep 17 00:00:00 2001 From: Emil Sjolander Date: Tue, 16 Aug 2016 08:49:54 -0700 Subject: [PATCH] Support 64 bit platforms Summary: Pointers are 64 bit on 64 bit platforms so using an int might truncate the pointer. Using longs supports 32 bit platforms as well. Reviewed By: davidaurelio Differential Revision: D3722479 fbshipit-source-id: c132f24c92c8476b328713861ad30670a43040c4 --- java/com/facebook/csslayout/CSSNodeJNI.java | 114 ++++++++++---------- java/jni/CSSJNI.c | 105 +++++++++--------- 2 files changed, 112 insertions(+), 107 deletions(-) diff --git a/java/com/facebook/csslayout/CSSNodeJNI.java b/java/com/facebook/csslayout/CSSNodeJNI.java index bba01819..11205b76 100644 --- a/java/com/facebook/csslayout/CSSNodeJNI.java +++ b/java/com/facebook/csslayout/CSSNodeJNI.java @@ -32,7 +32,7 @@ public class CSSNodeJNI implements CSSNodeAPI { private CSSNodeJNI mParent; private List mChildren; private MeasureFunction mMeasureFunction; - private int mNativePointer; + private long mNativePointer; private Object mData; private void assertNativeInstance() { @@ -41,7 +41,7 @@ public class CSSNodeJNI implements CSSNodeAPI { } } - private native int jni_CSSNodeNew(); + private native long jni_CSSNodeNew(); @Override public void init() { if (mNativePointer != 0) { @@ -52,7 +52,7 @@ public class CSSNodeJNI implements CSSNodeAPI { mChildren = new ArrayList<>(4); } - private native void jni_CSSNodeFree(int nativePointer); + private native void jni_CSSNodeFree(long nativePointer); @Override public void reset() { assertNativeInstance(); @@ -74,7 +74,7 @@ public class CSSNodeJNI implements CSSNodeAPI { return mChildren.get(i); } - private native void jni_CSSNodeInsertChild(int nativePointer, int childPointer, int index); + private native void jni_CSSNodeInsertChild(long nativePointer, long childPointer, int index); @Override public void addChildAt(CSSNodeJNI child, int i) { assertNativeInstance(); @@ -84,7 +84,7 @@ public class CSSNodeJNI implements CSSNodeAPI { jni_CSSNodeInsertChild(mNativePointer, child.mNativePointer, i); } - private native void jni_CSSNodeRemoveChild(int nativePointer, int childPointer); + private native void jni_CSSNodeRemoveChild(long nativePointer, long childPointer); @Override public CSSNodeJNI removeChildAt(int i) { assertNativeInstance(); @@ -105,195 +105,195 @@ public class CSSNodeJNI implements CSSNodeAPI { return mChildren.indexOf(child); } - private native void jni_CSSNodeSetIsTextNode(int nativePointer, boolean isTextNode); + private native void jni_CSSNodeSetIsTextNode(long nativePointer, boolean isTextNode); @Override public void setIsTextNode(boolean isTextNode) { assertNativeInstance(); jni_CSSNodeSetIsTextNode(mNativePointer, isTextNode); } - private native boolean jni_CSSNodeGetIsTextNode(int nativePointer); + private native boolean jni_CSSNodeGetIsTextNode(long nativePointer); @Override public boolean isTextNode() { assertNativeInstance(); return jni_CSSNodeGetIsTextNode(mNativePointer); } - private native void jni_CSSNodeCalculateLayout(int nativePointer); + private native void jni_CSSNodeCalculateLayout(long nativePointer); @Override public void calculateLayout(CSSLayoutContext layoutContext) { assertNativeInstance(); jni_CSSNodeCalculateLayout(mNativePointer); } - private native boolean jni_CSSNodeHasNewLayout(int nativePointer); + private native boolean jni_CSSNodeHasNewLayout(long nativePointer); @Override public boolean hasNewLayout() { assertNativeInstance(); return jni_CSSNodeHasNewLayout(mNativePointer); } - private native void jni_CSSNodeMarkDirty(int nativePointer); + private native void jni_CSSNodeMarkDirty(long nativePointer); @Override public void dirty() { assertNativeInstance(); jni_CSSNodeMarkDirty(mNativePointer); } - private native boolean jni_CSSNodeIsDirty(int nativePointer); + private native boolean jni_CSSNodeIsDirty(long nativePointer); @Override public boolean isDirty() { return jni_CSSNodeIsDirty(mNativePointer); } - private native void jni_CSSNodeMarkLayoutSeen(int nativePointer); + private native void jni_CSSNodeMarkLayoutSeen(long nativePointer); @Override public void markLayoutSeen() { assertNativeInstance(); jni_CSSNodeMarkLayoutSeen(mNativePointer); } - private native int jni_CSSNodeStyleGetDirection(int nativePointer); + private native int jni_CSSNodeStyleGetDirection(long nativePointer); @Override public CSSDirection getStyleDirection() { assertNativeInstance(); return CSSDirection.values()[jni_CSSNodeStyleGetDirection(mNativePointer)]; } - private native void jni_CSSNodeStyleSetDirection(int nativePointer, int direction); + private native void jni_CSSNodeStyleSetDirection(long nativePointer, int direction); @Override public void setDirection(CSSDirection direction) { assertNativeInstance(); jni_CSSNodeStyleSetDirection(mNativePointer, direction.ordinal()); } - private native int jni_CSSNodeLayoutGetDirection(int nativePointer); + private native int jni_CSSNodeLayoutGetDirection(long nativePointer); @Override public CSSDirection getLayoutDirection() { assertNativeInstance(); return CSSDirection.values()[jni_CSSNodeLayoutGetDirection(mNativePointer)]; } - private native int jni_CSSNodeStyleGetFlexDirection(int nativePointer); + private native int jni_CSSNodeStyleGetFlexDirection(long nativePointer); @Override public CSSFlexDirection getFlexDirection() { assertNativeInstance(); return CSSFlexDirection.values()[jni_CSSNodeStyleGetFlexDirection(mNativePointer)]; } - private native void jni_CSSNodeStyleSetFlexDirection(int nativePointer, int flexDirection); + private native void jni_CSSNodeStyleSetFlexDirection(long nativePointer, int flexDirection); @Override public void setFlexDirection(CSSFlexDirection flexDirection) { assertNativeInstance(); jni_CSSNodeStyleSetFlexDirection(mNativePointer, flexDirection.ordinal()); } - private native int jni_CSSNodeStyleGetJustifyContent(int nativePointer); + private native int jni_CSSNodeStyleGetJustifyContent(long nativePointer); @Override public CSSJustify getJustifyContent() { assertNativeInstance(); return CSSJustify.values()[jni_CSSNodeStyleGetJustifyContent(mNativePointer)]; } - private native void jni_CSSNodeStyleSetJustifyContent(int nativePointer, int justifyContent); + private native void jni_CSSNodeStyleSetJustifyContent(long nativePointer, int justifyContent); @Override public void setJustifyContent(CSSJustify justifyContent) { assertNativeInstance(); jni_CSSNodeStyleSetJustifyContent(mNativePointer, justifyContent.ordinal()); } - private native int jni_CSSNodeStyleGetAlignItems(int nativePointer); + private native int jni_CSSNodeStyleGetAlignItems(long nativePointer); @Override public CSSAlign getAlignItems() { assertNativeInstance(); return CSSAlign.values()[jni_CSSNodeStyleGetAlignItems(mNativePointer)]; } - private native void jni_CSSNodeStyleSetAlignItems(int nativePointer, int alignItems); + private native void jni_CSSNodeStyleSetAlignItems(long nativePointer, int alignItems); @Override public void setAlignItems(CSSAlign alignItems) { assertNativeInstance(); jni_CSSNodeStyleSetAlignItems(mNativePointer, alignItems.ordinal()); } - private native int jni_CSSNodeStyleGetAlignSelf(int nativePointer); + private native int jni_CSSNodeStyleGetAlignSelf(long nativePointer); @Override public CSSAlign getAlignSelf() { assertNativeInstance(); return CSSAlign.values()[jni_CSSNodeStyleGetAlignSelf(mNativePointer)]; } - private native void jni_CSSNodeStyleSetAlignSelf(int nativePointer, int alignSelf); + private native void jni_CSSNodeStyleSetAlignSelf(long nativePointer, int alignSelf); @Override public void setAlignSelf(CSSAlign alignSelf) { assertNativeInstance(); jni_CSSNodeStyleSetAlignSelf(mNativePointer, alignSelf.ordinal()); } - private native int jni_CSSNodeStyleGetAlignContent(int nativePointer); + private native int jni_CSSNodeStyleGetAlignContent(long nativePointer); @Override public CSSAlign getAlignContent() { assertNativeInstance(); return CSSAlign.values()[jni_CSSNodeStyleGetAlignContent(mNativePointer)]; } - private native void jni_CSSNodeStyleSetAlignContent(int nativePointer, int alignContent); + private native void jni_CSSNodeStyleSetAlignContent(long nativePointer, int alignContent); @Override public void setAlignContent(CSSAlign alignContent) { assertNativeInstance(); jni_CSSNodeStyleSetAlignContent(mNativePointer, alignContent.ordinal()); } - private native int jni_CSSNodeStyleGetPositionType(int nativePointer); + private native int jni_CSSNodeStyleGetPositionType(long nativePointer); @Override public CSSPositionType getPositionType() { assertNativeInstance(); return CSSPositionType.values()[jni_CSSNodeStyleGetPositionType(mNativePointer)]; } - private native void jni_CSSNodeStyleSetPositionType(int nativePointer, int positionType); + private native void jni_CSSNodeStyleSetPositionType(long nativePointer, int positionType); @Override public void setPositionType(CSSPositionType positionType) { assertNativeInstance(); jni_CSSNodeStyleSetPositionType(mNativePointer, positionType.ordinal()); } - private native void jni_CSSNodeStyleSetFlexWrap(int nativePointer, int wrapType); + private native void jni_CSSNodeStyleSetFlexWrap(long nativePointer, int wrapType); @Override public void setWrap(CSSWrap flexWrap) { assertNativeInstance(); jni_CSSNodeStyleSetFlexWrap(mNativePointer, flexWrap.ordinal()); } - private native int jni_CSSNodeStyleGetOverflow(int nativePointer); + private native int jni_CSSNodeStyleGetOverflow(long nativePointer); @Override public CSSOverflow getOverflow() { assertNativeInstance(); return CSSOverflow.values()[jni_CSSNodeStyleGetOverflow(mNativePointer)]; } - private native void jni_CSSNodeStyleSetOverflow(int nativePointer, int overflow); + private native void jni_CSSNodeStyleSetOverflow(long nativePointer, int overflow); @Override public void setOverflow(CSSOverflow overflow) { assertNativeInstance(); jni_CSSNodeStyleSetOverflow(mNativePointer, overflow.ordinal()); } - private native float jni_CSSNodeStyleGetFlex(int nativePointer); + private native float jni_CSSNodeStyleGetFlex(long nativePointer); @Override public float getFlex() { assertNativeInstance(); return jni_CSSNodeStyleGetFlex(mNativePointer); } - private native void jni_CSSNodeStyleSetFlex(int nativePointer, float flex); + private native void jni_CSSNodeStyleSetFlex(long nativePointer, float flex); @Override public void setFlex(float flex) { assertNativeInstance(); jni_CSSNodeStyleSetFlex(mNativePointer, flex); } - private native float jni_CSSNodeStyleGetMargin(int nativePointer, int edge); + private native float jni_CSSNodeStyleGetMargin(long nativePointer, int edge); @Override public Spacing getMargin() { assertNativeInstance(); @@ -307,14 +307,14 @@ public class CSSNodeJNI implements CSSNodeAPI { return margin; } - private native void jni_CSSNodeStyleSetMargin(int nativePointer, int edge, float margin); + private native void jni_CSSNodeStyleSetMargin(long nativePointer, int edge, float margin); @Override public void setMargin(int spacingType, float margin) { assertNativeInstance(); jni_CSSNodeStyleSetMargin(mNativePointer, spacingType, margin); } - private native float jni_CSSNodeStyleGetPadding(int nativePointer, int edge); + private native float jni_CSSNodeStyleGetPadding(long nativePointer, int edge); @Override public Spacing getPadding() { assertNativeInstance(); @@ -328,7 +328,7 @@ public class CSSNodeJNI implements CSSNodeAPI { return padding; } - private native void jni_CSSNodeStyleSetPadding(int nativePointer, int edge, float padding); + private native void jni_CSSNodeStyleSetPadding(long nativePointer, int edge, float padding); @Override public void setPadding(int spacingType, float padding) { assertNativeInstance(); @@ -340,7 +340,7 @@ public class CSSNodeJNI implements CSSNodeAPI { // TODO } - private native float jni_CSSNodeStyleGetBorder(int nativePointer, int edge); + private native float jni_CSSNodeStyleGetBorder(long nativePointer, int edge); @Override public Spacing getBorder() { assertNativeInstance(); @@ -354,14 +354,14 @@ public class CSSNodeJNI implements CSSNodeAPI { return border; } - private native void jni_CSSNodeStyleSetBorder(int nativePointer, int edge, float border); + private native void jni_CSSNodeStyleSetBorder(long nativePointer, int edge, float border); @Override public void setBorder(int spacingType, float border) { assertNativeInstance(); jni_CSSNodeStyleSetBorder(mNativePointer, spacingType, border); } - private native float jni_CSSNodeStyleGetPosition(int nativePointer, int edge); + private native float jni_CSSNodeStyleGetPosition(long nativePointer, int edge); @Override public Spacing getPosition() { assertNativeInstance(); @@ -375,126 +375,126 @@ public class CSSNodeJNI implements CSSNodeAPI { return position; } - private native void jni_CSSNodeStyleSetPosition(int nativePointer, int edge, float position); + private native void jni_CSSNodeStyleSetPosition(long nativePointer, int edge, float position); @Override public void setPosition(int spacingType, float position) { assertNativeInstance(); jni_CSSNodeStyleSetPosition(mNativePointer, spacingType, position); } - private native float jni_CSSNodeStyleGetWidth(int nativePointer); + private native float jni_CSSNodeStyleGetWidth(long nativePointer); @Override public float getStyleWidth() { assertNativeInstance(); return jni_CSSNodeStyleGetWidth(mNativePointer); } - private native void jni_CSSNodeStyleSetWidth(int nativePointer, float width); + private native void jni_CSSNodeStyleSetWidth(long nativePointer, float width); @Override public void setStyleWidth(float width) { assertNativeInstance(); jni_CSSNodeStyleSetWidth(mNativePointer, width); } - private native float jni_CSSNodeStyleGetHeight(int nativePointer); + private native float jni_CSSNodeStyleGetHeight(long nativePointer); @Override public float getStyleHeight() { assertNativeInstance(); return jni_CSSNodeStyleGetHeight(mNativePointer); } - private native void jni_CSSNodeStyleSetHeight(int nativePointer, float height); + private native void jni_CSSNodeStyleSetHeight(long nativePointer, float height); @Override public void setStyleHeight(float height) { assertNativeInstance(); jni_CSSNodeStyleSetHeight(mNativePointer, height); } - private native float jni_CSSNodeStyleGetMinWidth(int nativePointer); + private native float jni_CSSNodeStyleGetMinWidth(long nativePointer); @Override public float getStyleMinWidth() { assertNativeInstance(); return jni_CSSNodeStyleGetMinWidth(mNativePointer); } - private native void jni_CSSNodeStyleSetMinWidth(int nativePointer, float minWidth); + private native void jni_CSSNodeStyleSetMinWidth(long nativePointer, float minWidth); @Override public void setStyleMinWidth(float minWidth) { assertNativeInstance(); jni_CSSNodeStyleSetMinWidth(mNativePointer, minWidth); } - private native float jni_CSSNodeStyleGetMinHeight(int nativePointer); + private native float jni_CSSNodeStyleGetMinHeight(long nativePointer); @Override public float getStyleMinHeight() { assertNativeInstance(); return jni_CSSNodeStyleGetMinHeight(mNativePointer); } - private native void jni_CSSNodeStyleSetMinHeight(int nativePointer, float minHeight); + private native void jni_CSSNodeStyleSetMinHeight(long nativePointer, float minHeight); @Override public void setStyleMinHeight(float minHeight) { assertNativeInstance(); jni_CSSNodeStyleSetMinHeight(mNativePointer, minHeight); } - private native float jni_CSSNodeStyleGetMaxWidth(int nativePointer); + private native float jni_CSSNodeStyleGetMaxWidth(long nativePointer); @Override public float getStyleMaxWidth() { assertNativeInstance(); return jni_CSSNodeStyleGetMaxWidth(mNativePointer); } - private native void jni_CSSNodeStyleSetMaxWidth(int nativePointer, float maxWidth); + private native void jni_CSSNodeStyleSetMaxWidth(long nativePointer, float maxWidth); @Override public void setStyleMaxWidth(float maxWidth) { assertNativeInstance(); jni_CSSNodeStyleSetMaxWidth(mNativePointer, maxWidth); } - private native float jni_CSSNodeStyleGetMaxHeight(int nativePointer); + private native float jni_CSSNodeStyleGetMaxHeight(long nativePointer); @Override public float getStyleMaxHeight() { assertNativeInstance(); return jni_CSSNodeStyleGetMaxHeight(mNativePointer); } - private native void jni_CSSNodeStyleSetMaxHeight(int nativePointer, float maxheight); + private native void jni_CSSNodeStyleSetMaxHeight(long nativePointer, float maxheight); @Override public void setStyleMaxHeight(float maxheight) { assertNativeInstance(); jni_CSSNodeStyleSetMaxHeight(mNativePointer, maxheight); } - private native float jni_CSSNodeLayoutGetLeft(int nativePointer); + private native float jni_CSSNodeLayoutGetLeft(long nativePointer); @Override public float getLayoutX() { assertNativeInstance(); return jni_CSSNodeLayoutGetLeft(mNativePointer); } - private native float jni_CSSNodeLayoutGetTop(int nativePointer); + private native float jni_CSSNodeLayoutGetTop(long nativePointer); @Override public float getLayoutY() { assertNativeInstance(); return jni_CSSNodeLayoutGetTop(mNativePointer); } - private native float jni_CSSNodeLayoutGetWidth(int nativePointer); + private native float jni_CSSNodeLayoutGetWidth(long nativePointer); @Override public float getLayoutWidth() { assertNativeInstance(); return jni_CSSNodeLayoutGetWidth(mNativePointer); } - private native float jni_CSSNodeLayoutGetHeight(int nativePointer); + private native float jni_CSSNodeLayoutGetHeight(long nativePointer); @Override public float getLayoutHeight() { assertNativeInstance(); return jni_CSSNodeLayoutGetHeight(mNativePointer); } - private native void jni_CSSNodeSetHasMeasureFunc(int nativePointer, boolean hasMeasureFunc); + private native void jni_CSSNodeSetHasMeasureFunc(long nativePointer, boolean hasMeasureFunc); @Override public void setMeasureFunction(MeasureFunction measureFunction) { assertNativeInstance(); diff --git a/java/jni/CSSJNI.c b/java/jni/CSSJNI.c index 93940a4f..808ad48d 100644 --- a/java/jni/CSSJNI.c +++ b/java/jni/CSSJNI.c @@ -15,35 +15,37 @@ #define CSS_NODE_JNI(type, func) \ JNIEXPORT type JNICALL Java_com_facebook_csslayout_CSSNodeJNI_jni_1##func -#define CSS_NODE_JNI_STYLE_PROP(javatype, type, name) \ - CSS_NODE_JNI(javatype, \ - CSSNodeStyleGet##name(JNIEnv *env, jobject instance, jint nativePointer) { \ - return (javatype) CSSNodeStyleGet##name((CSSNodeRef) nativePointer); \ - }) \ - \ - CSS_NODE_JNI( \ - void, \ - CSSNodeStyleSet##name(JNIEnv *env, jobject instance, jint nativePointer, javatype value) { \ - CSSNodeStyleSet##name((CSSNodeRef) nativePointer, (type) value); \ +#define CSS_NODE_JNI_STYLE_PROP(javatype, type, name) \ + CSS_NODE_JNI(javatype, \ + CSSNodeStyleGet##name(JNIEnv *env, jobject instance, jlong nativePointer) { \ + return (javatype) CSSNodeStyleGet##name((CSSNodeRef)(intptr_t) nativePointer); \ + }) \ + \ + CSS_NODE_JNI( \ + void, \ + CSSNodeStyleSet##name(JNIEnv *env, jobject instance, jlong nativePointer, javatype value) { \ + CSSNodeStyleSet##name((CSSNodeRef)(intptr_t) nativePointer, (type) value); \ }) #define CSS_NODE_JNI_STYLE_EDGE_PROP(javatype, type, name) \ CSS_NODE_JNI( \ javatype, \ - CSSNodeStyleGet##name(JNIEnv *env, jobject instance, jint nativePointer, jint edge) { \ - return (javatype) CSSNodeStyleGet##name((CSSNodeRef) nativePointer, (CSSEdge) edge); \ + CSSNodeStyleGet##name(JNIEnv *env, jobject instance, jlong nativePointer, jint edge) { \ + return (javatype) CSSNodeStyleGet##name((CSSNodeRef)(intptr_t) nativePointer, \ + (CSSEdge) edge); \ }) \ \ - CSS_NODE_JNI(void, \ - CSSNodeStyleSet##name( \ - JNIEnv *env, jobject instance, jint nativePointer, jint edge, javatype value) { \ - CSSNodeStyleSet##name((CSSNodeRef) nativePointer, (CSSEdge) edge, (type) value); \ - }) + CSS_NODE_JNI( \ + void, \ + CSSNodeStyleSet##name( \ + JNIEnv *env, jobject instance, jlong nativePointer, jint edge, javatype value) { \ + CSSNodeStyleSet##name((CSSNodeRef)(intptr_t) nativePointer, (CSSEdge) edge, (type) value); \ + }) -#define CSS_NODE_JNI_LAYOUT_PROP(javatype, type, name) \ - CSS_NODE_JNI(javatype, \ - CSSNodeLayoutGet##name(JNIEnv *env, jobject instance, jint nativePointer) { \ - return (javatype) CSSNodeLayoutGet##name((CSSNodeRef) nativePointer); \ +#define CSS_NODE_JNI_LAYOUT_PROP(javatype, type, name) \ + CSS_NODE_JNI(javatype, \ + CSSNodeLayoutGet##name(JNIEnv *env, jobject instance, jlong nativePointer) { \ + return (javatype) CSSNodeLayoutGet##name((CSSNodeRef)(intptr_t) nativePointer); \ }) static JavaVM *jvm = NULL; @@ -105,72 +107,75 @@ static CSSSize _jniMeasureFunc(void *context, return size; } -CSS_NODE_JNI(jint, CSSNodeNew(JNIEnv *env, jobject thiz) { +CSS_NODE_JNI(jlong, CSSNodeNew(JNIEnv *env, jobject thiz) { CSSNodeRef node = CSSNodeNew(); CSSNodeSetContext(node, (*env)->NewGlobalRef(env, thiz)); CSSNodeSetPrintFunc(node, _jniPrint); - return (jint) node; + return (jlong)(intptr_t) node; }) -CSS_NODE_JNI(void, CSSNodeFree(JNIEnv *env, jobject thiz, jint nativePointer) { - (*env)->DeleteGlobalRef(env, (jobject) CSSNodeGetContext((CSSNodeRef) nativePointer)); - CSSNodeFree((CSSNodeRef) nativePointer); +CSS_NODE_JNI(void, CSSNodeFree(JNIEnv *env, jobject thiz, jlong nativePointer) { + (*env)->DeleteGlobalRef(env, (jobject) CSSNodeGetContext((CSSNodeRef)(intptr_t) nativePointer)); + CSSNodeFree((CSSNodeRef)(intptr_t) nativePointer); }) CSS_NODE_JNI(void, CSSNodeInsertChild(JNIEnv *env, jobject thiz, - jint nativePointer, - jint childPointer, + jlong nativePointer, + jlong childPointer, jint index) { - CSSNodeInsertChild((CSSNodeRef) nativePointer, (CSSNodeRef) childPointer, index); + CSSNodeInsertChild((CSSNodeRef)(intptr_t) nativePointer, + (CSSNodeRef)(intptr_t) childPointer, + index); }) -CSS_NODE_JNI(void, - CSSNodeRemoveChild(JNIEnv *env, jobject thiz, jint nativePointer, jint childPointer) { - CSSNodeRemoveChild((CSSNodeRef) nativePointer, (CSSNodeRef) childPointer); - }) +CSS_NODE_JNI( + void, + CSSNodeRemoveChild(JNIEnv *env, jobject thiz, jlong nativePointer, jlong childPointer) { + CSSNodeRemoveChild((CSSNodeRef)(intptr_t) nativePointer, (CSSNodeRef)(intptr_t) childPointer); + }) -CSS_NODE_JNI(void, CSSNodeCalculateLayout(JNIEnv *env, jobject thiz, jint nativePointer) { - CSSNodeCalculateLayout((CSSNodeRef) nativePointer, +CSS_NODE_JNI(void, CSSNodeCalculateLayout(JNIEnv *env, jobject thiz, jlong nativePointer) { + CSSNodeCalculateLayout((CSSNodeRef)(intptr_t) nativePointer, NAN, NAN, - CSSNodeStyleGetDirection(((CSSNodeRef) nativePointer))); + CSSNodeStyleGetDirection(((CSSNodeRef)(intptr_t) nativePointer))); }) -CSS_NODE_JNI(void, CSSNodeMarkDirty(JNIEnv *env, jobject thiz, jint nativePointer) { - CSSNodeMarkDirty((CSSNodeRef) nativePointer); +CSS_NODE_JNI(void, CSSNodeMarkDirty(JNIEnv *env, jobject thiz, jlong nativePointer) { + CSSNodeMarkDirty((CSSNodeRef)(intptr_t) nativePointer); }) -CSS_NODE_JNI(jboolean, CSSNodeIsDirty(JNIEnv *env, jobject instance, jint nativePointer) { - return (jboolean) CSSNodeIsDirty((CSSNodeRef) nativePointer); +CSS_NODE_JNI(jboolean, CSSNodeIsDirty(JNIEnv *env, jobject instance, jlong nativePointer) { + return (jboolean) CSSNodeIsDirty((CSSNodeRef)(intptr_t) nativePointer); }) CSS_NODE_JNI(void, CSSNodeSetHasMeasureFunc(JNIEnv *env, jobject thiz, - jint nativePointer, + jlong nativePointer, jboolean hasMeasureFunc) { - CSSNodeSetMeasureFunc((CSSNodeRef) nativePointer, + CSSNodeSetMeasureFunc((CSSNodeRef)(intptr_t) nativePointer, hasMeasureFunc ? _jniMeasureFunc : NULL); }) CSS_NODE_JNI( void, - CSSNodeSetIsTextNode(JNIEnv *env, jobject instance, jint nativePointer, jboolean isTextNode) { - CSSNodeSetIsTextnode((CSSNodeRef) nativePointer, isTextNode); + CSSNodeSetIsTextNode(JNIEnv *env, jobject instance, jlong nativePointer, jboolean isTextNode) { + CSSNodeSetIsTextnode((CSSNodeRef)(intptr_t) nativePointer, isTextNode); }) -CSS_NODE_JNI(jboolean, CSSNodeGetIsTextNode(JNIEnv *env, jobject instance, jint nativePointer) { - return (jboolean) CSSNodeGetIsTextnode((CSSNodeRef) nativePointer); +CSS_NODE_JNI(jboolean, CSSNodeGetIsTextNode(JNIEnv *env, jobject instance, jlong nativePointer) { + return (jboolean) CSSNodeGetIsTextnode((CSSNodeRef)(intptr_t) nativePointer); }) -CSS_NODE_JNI(jboolean, CSSNodeHasNewLayout(JNIEnv *env, jobject instance, jint nativePointer) { - return (jboolean) CSSNodeGetHasNewLayout((CSSNodeRef) nativePointer); +CSS_NODE_JNI(jboolean, CSSNodeHasNewLayout(JNIEnv *env, jobject instance, jlong nativePointer) { + return (jboolean) CSSNodeGetHasNewLayout((CSSNodeRef)(intptr_t) nativePointer); }) -CSS_NODE_JNI(void, CSSNodeMarkLayoutSeen(JNIEnv *env, jobject instance, jint nativePointer) { - CSSNodeSetHasNewLayout((CSSNodeRef) nativePointer, false); +CSS_NODE_JNI(void, CSSNodeMarkLayoutSeen(JNIEnv *env, jobject instance, jlong nativePointer) { + CSSNodeSetHasNewLayout((CSSNodeRef)(intptr_t) nativePointer, false); }) CSS_NODE_JNI_STYLE_PROP(jint, CSSDirection, Direction);