return mValid && mFinalizer != null;
}
- long getNativeDisplayList() {
+ int getNativeDisplayList() {
if (!mValid || mFinalizer == null) {
throw new IllegalStateException("The display list is not valid.");
}
// Native methods
///////////////////////////////////////////////////////////////////////////
- private static native void nDestroyDisplayList(long displayList);
- private static native int nGetDisplayListSize(long displayList);
- private static native void nSetDisplayListName(long displayList, String name);
+ private static native void nDestroyDisplayList(int displayList);
+ private static native int nGetDisplayListSize(int displayList);
+ private static native void nSetDisplayListName(int displayList, String name);
// Properties
- private static native void nReset(long displayList);
- private static native void nOffsetTopAndBottom(long displayList, float offset);
- private static native void nOffsetLeftAndRight(long displayList, float offset);
- private static native void nSetLeftTopRightBottom(long displayList, int left, int top,
+ private static native void nReset(int displayList);
+ private static native void nOffsetTopAndBottom(int displayList, float offset);
+ private static native void nOffsetLeftAndRight(int displayList, float offset);
+ private static native void nSetLeftTopRightBottom(int displayList, int left, int top,
int right, int bottom);
- private static native void nSetBottom(long displayList, int bottom);
- private static native void nSetRight(long displayList, int right);
- private static native void nSetTop(long displayList, int top);
- private static native void nSetLeft(long displayList, int left);
- private static native void nSetCameraDistance(long displayList, float distance);
- private static native void nSetPivotY(long displayList, float pivotY);
- private static native void nSetPivotX(long displayList, float pivotX);
- private static native void nSetCaching(long displayList, boolean caching);
- private static native void nSetClipToBounds(long displayList, boolean clipToBounds);
- private static native void nSetProjectToContainedVolume(long displayList, boolean shouldProject);
- private static native void nSetIsContainedVolume(long displayList, boolean isContainedVolume);
- private static native void nSetAlpha(long displayList, float alpha);
- private static native void nSetHasOverlappingRendering(long displayList,
+ private static native void nSetBottom(int displayList, int bottom);
+ private static native void nSetRight(int displayList, int right);
+ private static native void nSetTop(int displayList, int top);
+ private static native void nSetLeft(int displayList, int left);
+ private static native void nSetCameraDistance(int displayList, float distance);
+ private static native void nSetPivotY(int displayList, float pivotY);
+ private static native void nSetPivotX(int displayList, float pivotX);
+ private static native void nSetCaching(int displayList, boolean caching);
+ private static native void nSetClipToBounds(int displayList, boolean clipToBounds);
+ private static native void nSetProjectToContainedVolume(int displayList, boolean shouldProject);
+ private static native void nSetIsContainedVolume(int displayList, boolean isContainedVolume);
+ private static native void nSetAlpha(int displayList, float alpha);
+ private static native void nSetHasOverlappingRendering(int displayList,
boolean hasOverlappingRendering);
- private static native void nSetTranslationX(long displayList, float translationX);
- private static native void nSetTranslationY(long displayList, float translationY);
- private static native void nSetTranslationZ(long displayList, float translationZ);
- private static native void nSetRotation(long displayList, float rotation);
- private static native void nSetRotationX(long displayList, float rotationX);
- private static native void nSetRotationY(long displayList, float rotationY);
- private static native void nSetScaleX(long displayList, float scaleX);
- private static native void nSetScaleY(long displayList, float scaleY);
- private static native void nSetTransformationInfo(long displayList, float alpha,
+ private static native void nSetTranslationX(int displayList, float translationX);
+ private static native void nSetTranslationY(int displayList, float translationY);
+ private static native void nSetTranslationZ(int displayList, float translationZ);
+ private static native void nSetRotation(int displayList, float rotation);
+ private static native void nSetRotationX(int displayList, float rotationX);
+ private static native void nSetRotationY(int displayList, float rotationY);
+ private static native void nSetScaleX(int displayList, float scaleX);
+ private static native void nSetScaleY(int displayList, float scaleY);
+ private static native void nSetTransformationInfo(int displayList, float alpha,
float translationX, float translationY, float translationZ,
float rotation, float rotationX, float rotationY, float scaleX, float scaleY);
- private static native void nSetStaticMatrix(long displayList, long nativeMatrix);
- private static native void nSetAnimationMatrix(long displayList, long animationMatrix);
-
- private static native boolean nHasOverlappingRendering(long displayList);
- private static native void nGetMatrix(long displayList, long matrix);
- private static native float nGetAlpha(long displayList);
- private static native float nGetLeft(long displayList);
- private static native float nGetTop(long displayList);
- private static native float nGetRight(long displayList);
- private static native float nGetBottom(long displayList);
- private static native float nGetCameraDistance(long displayList);
- private static native float nGetScaleX(long displayList);
- private static native float nGetScaleY(long displayList);
- private static native float nGetTranslationX(long displayList);
- private static native float nGetTranslationY(long displayList);
- private static native float nGetTranslationZ(long displayList);
- private static native float nGetRotation(long displayList);
- private static native float nGetRotationX(long displayList);
- private static native float nGetRotationY(long displayList);
- private static native float nGetPivotX(long displayList);
- private static native float nGetPivotY(long displayList);
- private static native void nOutput(long displayList);
+ private static native void nSetStaticMatrix(int displayList, int nativeMatrix);
+ private static native void nSetAnimationMatrix(int displayList, int animationMatrix);
+
+ private static native boolean nHasOverlappingRendering(int displayList);
+ private static native void nGetMatrix(int displayList, int matrix);
+ private static native float nGetAlpha(int displayList);
+ private static native float nGetLeft(int displayList);
+ private static native float nGetTop(int displayList);
+ private static native float nGetRight(int displayList);
+ private static native float nGetBottom(int displayList);
+ private static native float nGetCameraDistance(int displayList);
+ private static native float nGetScaleX(int displayList);
+ private static native float nGetScaleY(int displayList);
+ private static native float nGetTranslationX(int displayList);
+ private static native float nGetTranslationY(int displayList);
+ private static native float nGetTranslationZ(int displayList);
+ private static native float nGetRotation(int displayList);
+ private static native float nGetRotationX(int displayList);
+ private static native float nGetRotationY(int displayList);
+ private static native float nGetPivotX(int displayList);
+ private static native float nGetPivotY(int displayList);
+ private static native void nOutput(int displayList);
///////////////////////////////////////////////////////////////////////////
// Finalization
///////////////////////////////////////////////////////////////////////////
private static class DisplayListFinalizer {
- final long mNativeDisplayList;
+ final int mNativeDisplayList;
- public DisplayListFinalizer(long nativeDisplayList) {
+ public DisplayListFinalizer(int nativeDisplayList) {
mNativeDisplayList = nativeDisplayList;
}
private static final int MODIFIER_COLOR_FILTER = 4;
private final boolean mOpaque;
- private long mRenderer;
+ private int mRenderer;
// The native renderer will be destroyed when this object dies.
// DO NOT overwrite this reference once it is set.
/**
* Creates a canvas to render into an FBO.
*/
- GLES20Canvas(long layer, boolean translucent) {
+ GLES20Canvas(int layer, boolean translucent) {
mOpaque = !translucent;
mRenderer = nCreateLayerRenderer(layer);
setupFinalizer();
nResetDisplayListRenderer(mRenderer);
}
- private static native long nCreateRenderer();
- private static native long nCreateLayerRenderer(long layer);
- private static native long nCreateDisplayListRenderer();
- private static native void nResetDisplayListRenderer(long renderer);
- private static native void nDestroyRenderer(long renderer);
+ private static native int nCreateRenderer();
+ private static native int nCreateLayerRenderer(int layer);
+ private static native int nCreateDisplayListRenderer();
+ private static native void nResetDisplayListRenderer(int renderer);
+ private static native void nDestroyRenderer(int renderer);
private static final class CanvasFinalizer {
- private final long mRenderer;
+ private final int mRenderer;
- public CanvasFinalizer(long renderer) {
+ public CanvasFinalizer(int renderer) {
mRenderer = renderer;
}
nClearLayerUpdates(mRenderer);
}
- static native long nCreateTextureLayer(boolean opaque, int[] layerInfo);
- static native long nCreateLayer(int width, int height, boolean isOpaque, int[] layerInfo);
- static native boolean nResizeLayer(long layerId, int width, int height, int[] layerInfo);
- static native void nSetOpaqueLayer(long layerId, boolean isOpaque);
- static native void nSetLayerPaint(long layerId, long nativePaint);
- static native void nSetLayerColorFilter(long layerId, long nativeColorFilter);
- static native void nUpdateTextureLayer(long layerId, int width, int height, boolean opaque,
+ static native int nCreateTextureLayer(boolean opaque, int[] layerInfo);
+ static native int nCreateLayer(int width, int height, boolean isOpaque, int[] layerInfo);
+ static native boolean nResizeLayer(int layerId, int width, int height, int[] layerInfo);
+ static native void nSetOpaqueLayer(int layerId, boolean isOpaque);
+ static native void nSetLayerPaint(int layerId, int nativePaint);
+ static native void nSetLayerColorFilter(int layerId, int nativeColorFilter);
+ static native void nUpdateTextureLayer(int layerId, int width, int height, boolean opaque,
SurfaceTexture surface);
- static native void nClearLayerTexture(long layerId);
- static native void nSetTextureLayerTransform(long layerId, long matrix);
- static native void nDestroyLayer(long layerId);
- static native void nDestroyLayerDeferred(long layerId);
- static native void nUpdateRenderLayer(long layerId, long renderer, long displayList,
+ static native void nClearLayerTexture(int layerId);
+ static native void nSetTextureLayerTransform(int layerId, int matrix);
+ static native void nDestroyLayer(int layerId);
+ static native void nDestroyLayerDeferred(int layerId);
+ static native void nUpdateRenderLayer(int layerId, int renderer, int displayList,
int left, int top, int right, int bottom);
- static native boolean nCopyLayer(long layerId, long bitmap);
+ static native boolean nCopyLayer(int layerId, int bitmap);
- private static native void nClearLayerUpdates(long renderer);
- private static native void nFlushLayerUpdates(long renderer);
- private static native void nPushLayerUpdate(long renderer, long layer);
- private static native void nCancelLayerUpdate(long renderer, long layer);
+ private static native void nClearLayerUpdates(int renderer);
+ private static native void nFlushLayerUpdates(int renderer);
+ private static native void nPushLayerUpdate(int renderer, int layer);
+ private static native void nCancelLayerUpdate(int renderer, int layer);
///////////////////////////////////////////////////////////////////////////
// Canvas management
/**
* Returns the native OpenGLRenderer object.
*/
- long getRenderer() {
+ int getRenderer() {
return mRenderer;
}
nSetViewport(mRenderer, width, height);
}
- private static native void nSetViewport(long renderer, int width, int height);
+ private static native void nSetViewport(int renderer, int width, int height);
@Override
public int onPreDraw(Rect dirty) {
}
}
- private static native int nPrepare(long renderer, boolean opaque);
- private static native int nPrepareDirty(long renderer, int left, int top, int right, int bottom,
+ private static native int nPrepare(int renderer, boolean opaque);
+ private static native int nPrepareDirty(int renderer, int left, int top, int right, int bottom,
boolean opaque);
@Override
nFinish(mRenderer);
}
- private static native void nFinish(long renderer);
+ private static native void nFinish(int renderer);
/**
* Returns the size of the stencil buffer required by the underlying
nSetCountOverdrawEnabled(mRenderer, enabled);
}
- static native void nSetCountOverdrawEnabled(long renderer, boolean enabled);
+ static native void nSetCountOverdrawEnabled(int renderer, boolean enabled);
float getOverdraw() {
return nGetOverdraw(mRenderer);
}
- static native float nGetOverdraw(long renderer);
+ static native float nGetOverdraw(int renderer);
///////////////////////////////////////////////////////////////////////////
// Functor
///////////////////////////////////////////////////////////////////////////
@Override
- public int callDrawGLFunction(long drawGLFunction) {
+ public int callDrawGLFunction(int drawGLFunction) {
return nCallDrawGLFunction(mRenderer, drawGLFunction);
}
- private static native int nCallDrawGLFunction(long renderer, long drawGLFunction);
+ private static native int nCallDrawGLFunction(int renderer, int drawGLFunction);
@Override
public int invokeFunctors(Rect dirty) {
return nInvokeFunctors(mRenderer, dirty);
}
- private static native int nInvokeFunctors(long renderer, Rect dirty);
+ private static native int nInvokeFunctors(int renderer, Rect dirty);
@Override
- public void detachFunctor(long functor) {
+ public void detachFunctor(int functor) {
nDetachFunctor(mRenderer, functor);
}
- private static native void nDetachFunctor(long renderer, long functor);
+ private static native void nDetachFunctor(int renderer, int functor);
@Override
- public void attachFunctor(long functor) {
+ public void attachFunctor(int functor) {
nAttachFunctor(mRenderer, functor);
}
- private static native void nAttachFunctor(long renderer, long functor);
+ private static native void nAttachFunctor(int renderer, int functor);
///////////////////////////////////////////////////////////////////////////
// Memory
// Display list
///////////////////////////////////////////////////////////////////////////
- long getDisplayList(long displayList) {
+ int getDisplayList(int displayList) {
return nGetDisplayList(mRenderer, displayList);
}
- private static native long nGetDisplayList(long renderer, long displayList);
+ private static native int nGetDisplayList(int renderer, int displayList);
@Override
public int drawDisplayList(DisplayList displayList, Rect dirty, int flags) {
dirty, flags);
}
- private static native int nDrawDisplayList(long renderer, long displayList,
+ private static native int nDrawDisplayList(int renderer, int displayList,
Rect dirty, int flags);
///////////////////////////////////////////////////////////////////////////
nDrawLayer(mRenderer, glLayer.getLayer(), x, y);
}
- private static native void nDrawLayer(long renderer, long layer, float x, float y);
+ private static native void nDrawLayer(int renderer, int layer, float x, float y);
void interrupt() {
nInterrupt(mRenderer);
nResume(mRenderer);
}
- private static native void nInterrupt(long renderer);
- private static native void nResume(long renderer);
+ private static native void nInterrupt(int renderer);
+ private static native void nResume(int renderer);
///////////////////////////////////////////////////////////////////////////
// Support
return nClipPath(mRenderer, path.mNativePath, op.nativeInt);
}
- private static native boolean nClipPath(long renderer, long path, int op);
+ private static native boolean nClipPath(int renderer, int path, int op);
@Override
public boolean clipRect(float left, float top, float right, float bottom) {
return nClipRect(mRenderer, left, top, right, bottom, Region.Op.INTERSECT.nativeInt);
}
- private static native boolean nClipRect(long renderer, float left, float top,
+ private static native boolean nClipRect(int renderer, float left, float top,
float right, float bottom, int op);
@Override
return nClipRect(mRenderer, left, top, right, bottom, Region.Op.INTERSECT.nativeInt);
}
- private static native boolean nClipRect(long renderer, int left, int top,
+ private static native boolean nClipRect(int renderer, int left, int top,
int right, int bottom, int op);
@Override
return nClipRegion(mRenderer, region.mNativeRegion, op.nativeInt);
}
- private static native boolean nClipRegion(long renderer, long region, int op);
+ private static native boolean nClipRegion(int renderer, int region, int op);
@Override
public boolean getClipBounds(Rect bounds) {
return nGetClipBounds(mRenderer, bounds);
}
- private static native boolean nGetClipBounds(long renderer, Rect bounds);
+ private static native boolean nGetClipBounds(int renderer, Rect bounds);
@Override
public boolean quickReject(float left, float top, float right, float bottom, EdgeType type) {
return nQuickReject(mRenderer, left, top, right, bottom);
}
- private static native boolean nQuickReject(long renderer, float left, float top,
+ private static native boolean nQuickReject(int renderer, float left, float top,
float right, float bottom);
@Override
if (dx != 0.0f || dy != 0.0f) nTranslate(mRenderer, dx, dy);
}
- private static native void nTranslate(long renderer, float dx, float dy);
+ private static native void nTranslate(int renderer, float dx, float dy);
@Override
public void skew(float sx, float sy) {
nSkew(mRenderer, sx, sy);
}
- private static native void nSkew(long renderer, float sx, float sy);
+ private static native void nSkew(int renderer, float sx, float sy);
@Override
public void rotate(float degrees) {
nRotate(mRenderer, degrees);
}
- private static native void nRotate(long renderer, float degrees);
+ private static native void nRotate(int renderer, float degrees);
@Override
public void scale(float sx, float sy) {
nScale(mRenderer, sx, sy);
}
- private static native void nScale(long renderer, float sx, float sy);
+ private static native void nScale(int renderer, float sx, float sy);
@Override
public void setMatrix(Matrix matrix) {
nSetMatrix(mRenderer, matrix == null ? 0 : matrix.native_instance);
}
- private static native void nSetMatrix(long renderer, long matrix);
+ private static native void nSetMatrix(int renderer, int matrix);
@SuppressWarnings("deprecation")
@Override
nGetMatrix(mRenderer, matrix.native_instance);
}
- private static native void nGetMatrix(long renderer, long matrix);
+ private static native void nGetMatrix(int renderer, int matrix);
@Override
public void concat(Matrix matrix) {
if (matrix != null) nConcatMatrix(mRenderer, matrix.native_instance);
}
- private static native void nConcatMatrix(long renderer, long matrix);
+ private static native void nConcatMatrix(int renderer, int matrix);
///////////////////////////////////////////////////////////////////////////
// State management
return nSave(mRenderer, saveFlags);
}
- private static native int nSave(long renderer, int flags);
+ private static native int nSave(int renderer, int flags);
@Override
public int saveLayer(RectF bounds, Paint paint, int saveFlags) {
int count;
int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
count = nSaveLayer(mRenderer, nativePaint, saveFlags);
} finally {
if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
return count;
}
- private static native int nSaveLayer(long renderer, long paint, int saveFlags);
+ private static native int nSaveLayer(int renderer, int paint, int saveFlags);
@Override
public int saveLayer(float left, float top, float right, float bottom, Paint paint,
int count;
int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
count = nSaveLayer(mRenderer, left, top, right, bottom, nativePaint, saveFlags);
} finally {
if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
return save(saveFlags);
}
- private static native int nSaveLayer(long renderer, float left, float top,
- float right, float bottom, long paint, int saveFlags);
+ private static native int nSaveLayer(int renderer, float left, float top,
+ float right, float bottom, int paint, int saveFlags);
@Override
public int saveLayerAlpha(RectF bounds, int alpha, int saveFlags) {
return nSaveLayerAlpha(mRenderer, alpha, saveFlags);
}
- private static native int nSaveLayerAlpha(long renderer, int alpha, int saveFlags);
+ private static native int nSaveLayerAlpha(int renderer, int alpha, int saveFlags);
@Override
public int saveLayerAlpha(float left, float top, float right, float bottom, int alpha,
return save(saveFlags);
}
- private static native int nSaveLayerAlpha(long renderer, float left, float top, float right,
+ private static native int nSaveLayerAlpha(int renderer, float left, float top, float right,
float bottom, int alpha, int saveFlags);
@Override
nRestore(mRenderer);
}
- private static native void nRestore(long renderer);
+ private static native void nRestore(int renderer);
@Override
public void restoreToCount(int saveCount) {
nRestoreToCount(mRenderer, saveCount);
}
- private static native void nRestoreToCount(long renderer, int saveCount);
+ private static native void nRestoreToCount(int renderer, int saveCount);
@Override
public int getSaveCount() {
return nGetSaveCount(mRenderer);
}
- private static native int nGetSaveCount(long renderer);
+ private static native int nGetSaveCount(int renderer);
///////////////////////////////////////////////////////////////////////////
// Filtering
}
}
- private static native void nResetPaintFilter(long renderer);
- private static native void nSetupPaintFilter(long renderer, int clearBits, int setBits);
+ private static native void nResetPaintFilter(int renderer);
+ private static native void nSetupPaintFilter(int renderer, int clearBits, int setBits);
@Override
public DrawFilter getDrawFilter() {
}
}
- private static native void nDrawArc(long renderer, float left, float top,
+ private static native void nDrawArc(int renderer, float left, float top,
float right, float bottom, float startAngle, float sweepAngle,
- boolean useCenter, long paint);
+ boolean useCenter, int paint);
@Override
public void drawARGB(int a, int r, int g, int b) {
// Shaders are ignored when drawing patches
int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, patch.mNativeChunk,
dst.left, dst.top, dst.right, dst.bottom, nativePaint);
} finally {
// Shaders are ignored when drawing patches
int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, patch.mNativeChunk,
dst.left, dst.top, dst.right, dst.bottom, nativePaint);
} finally {
}
}
- private static native void nDrawPatch(long renderer, long bitmap, byte[] buffer, long chunk,
- float left, float top, float right, float bottom, long paint);
+ private static native void nDrawPatch(int renderer, int bitmap, byte[] buffer, int chunk,
+ float left, float top, float right, float bottom, int paint);
@Override
public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint) {
// Shaders are ignored when drawing bitmaps
int modifiers = paint != null ? setupModifiers(bitmap, paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
nDrawBitmap(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, left, top, nativePaint);
} finally {
if (modifiers != MODIFIER_NONE) nResetModifiers(mRenderer, modifiers);
}
}
- private static native void nDrawBitmap(long renderer, long bitmap, byte[] buffer,
- float left, float top, long paint);
+ private static native void nDrawBitmap(int renderer, int bitmap, byte[] buffer,
+ float left, float top, int paint);
@Override
public void drawBitmap(Bitmap bitmap, Matrix matrix, Paint paint) {
// Shaders are ignored when drawing bitmaps
int modifiers = paint != null ? setupModifiers(bitmap, paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
nDrawBitmap(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer,
matrix.native_instance, nativePaint);
} finally {
}
}
- private static native void nDrawBitmap(long renderer, long bitmap, byte[] buffer,
- long matrix, long paint);
+ private static native void nDrawBitmap(int renderer, int bitmap, byte[] buffer,
+ int matrix, int paint);
@Override
public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {
// Shaders are ignored when drawing bitmaps
int modifiers = paint != null ? setupModifiers(bitmap, paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
int left, top, right, bottom;
if (src == null) {
// Shaders are ignored when drawing bitmaps
int modifiers = paint != null ? setupModifiers(bitmap, paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
float left, top, right, bottom;
if (src == null) {
}
}
- private static native void nDrawBitmap(long renderer, long bitmap, byte[] buffer,
+ private static native void nDrawBitmap(int renderer, int bitmap, byte[] buffer,
float srcLeft, float srcTop, float srcRight, float srcBottom,
- float left, float top, float right, float bottom, long paint);
+ float left, float top, float right, float bottom, int paint);
@Override
public void drawBitmap(int[] colors, int offset, int stride, float x, float y,
// Shaders are ignored when drawing bitmaps
int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
nDrawBitmap(mRenderer, colors, offset, stride, x, y,
width, height, hasAlpha, nativePaint);
} finally {
}
}
- private static native void nDrawBitmap(long renderer, int[] colors, int offset, int stride,
- float x, float y, int width, int height, boolean hasAlpha, long nativePaint);
+ private static native void nDrawBitmap(int renderer, int[] colors, int offset, int stride,
+ float x, float y, int width, int height, boolean hasAlpha, int nativePaint);
@Override
public void drawBitmap(int[] colors, int offset, int stride, int x, int y,
int modifiers = paint != null ? setupModifiers(bitmap, paint) : MODIFIER_NONE;
try {
- final long nativePaint = paint == null ? 0 : paint.mNativePaint;
+ final int nativePaint = paint == null ? 0 : paint.mNativePaint;
nDrawBitmapMesh(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, meshWidth, meshHeight,
verts, vertOffset, colors, colorOffset, nativePaint);
} finally {
}
}
- private static native void nDrawBitmapMesh(long renderer, long bitmap, byte[] buffer,
+ private static native void nDrawBitmapMesh(int renderer, int bitmap, byte[] buffer,
int meshWidth, int meshHeight, float[] verts, int vertOffset,
- int[] colors, int colorOffset, long paint);
+ int[] colors, int colorOffset, int paint);
@Override
public void drawCircle(float cx, float cy, float radius, Paint paint) {
}
}
- private static native void nDrawCircle(long renderer, float cx, float cy,
- float radius, long paint);
+ private static native void nDrawCircle(int renderer, float cx, float cy,
+ float radius, int paint);
@Override
public void drawColor(int color) {
nDrawColor(mRenderer, color, mode.nativeInt);
}
- private static native void nDrawColor(long renderer, int color, int mode);
+ private static native void nDrawColor(int renderer, int color, int mode);
@Override
public void drawLine(float startX, float startY, float stopX, float stopY, Paint paint) {
}
}
- private static native void nDrawLines(long renderer, float[] points,
- int offset, int count, long paint);
+ private static native void nDrawLines(int renderer, float[] points,
+ int offset, int count, int paint);
@Override
public void drawLines(float[] pts, Paint paint) {
}
}
- private static native void nDrawOval(long renderer, float left, float top,
- float right, float bottom, long paint);
+ private static native void nDrawOval(int renderer, float left, float top,
+ float right, float bottom, int paint);
@Override
public void drawPaint(Paint paint) {
}
}
- private static native void nDrawPath(long renderer, long path, long paint);
- private static native void nDrawRects(long renderer, long region, long paint);
+ private static native void nDrawPath(int renderer, int path, int paint);
+ private static native void nDrawRects(int renderer, int region, int paint);
void drawRects(float[] rects, int count, Paint paint) {
int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
}
}
- private static native void nDrawRects(long renderer, float[] rects, int count, long paint);
+ private static native void nDrawRects(int renderer, float[] rects, int count, int paint);
@Override
public void drawPicture(Picture picture) {
}
}
- private static native void nDrawPoints(long renderer, float[] points,
- int offset, int count, long paint);
+ private static native void nDrawPoints(int renderer, float[] points,
+ int offset, int count, int paint);
@SuppressWarnings("deprecation")
@Override
}
}
- private static native void nDrawPosText(long renderer, char[] text, int index, int count,
- float[] pos, long paint);
+ private static native void nDrawPosText(int renderer, char[] text, int index, int count,
+ float[] pos, int paint);
@SuppressWarnings("deprecation")
@Override
}
}
- private static native void nDrawPosText(long renderer, String text, int start, int end,
- float[] pos, long paint);
+ private static native void nDrawPosText(int renderer, String text, int start, int end,
+ float[] pos, int paint);
@Override
public void drawRect(float left, float top, float right, float bottom, Paint paint) {
}
}
- private static native void nDrawRect(long renderer, float left, float top,
- float right, float bottom, long paint);
+ private static native void nDrawRect(int renderer, float left, float top,
+ float right, float bottom, int paint);
@Override
public void drawRect(Rect r, Paint paint) {
}
}
- private static native void nDrawRoundRect(long renderer, float left, float top,
- float right, float bottom, float rx, float y, long paint);
+ private static native void nDrawRoundRect(int renderer, float left, float top,
+ float right, float bottom, float rx, float y, int paint);
@Override
public void drawText(char[] text, int index, int count, float x, float y, Paint paint) {
}
}
- private static native void nDrawText(long renderer, char[] text, int index, int count,
- float x, float y, int bidiFlags, long paint);
+ private static native void nDrawText(int renderer, char[] text, int index, int count,
+ float x, float y, int bidiFlags, int paint);
@Override
public void drawText(CharSequence text, int start, int end, float x, float y, Paint paint) {
}
}
- private static native void nDrawText(long renderer, String text, int start, int end,
- float x, float y, int bidiFlags, long paint);
+ private static native void nDrawText(int renderer, String text, int start, int end,
+ float x, float y, int bidiFlags, int paint);
@Override
public void drawText(String text, float x, float y, Paint paint) {
}
}
- private static native void nDrawTextOnPath(long renderer, char[] text, int index, int count,
- long path, float hOffset, float vOffset, int bidiFlags, long nativePaint);
+ private static native void nDrawTextOnPath(int renderer, char[] text, int index, int count,
+ int path, float hOffset, float vOffset, int bidiFlags, int nativePaint);
@Override
public void drawTextOnPath(String text, Path path, float hOffset, float vOffset, Paint paint) {
}
}
- private static native void nDrawTextOnPath(long renderer, String text, int start, int end,
- long path, float hOffset, float vOffset, int bidiFlags, long nativePaint);
+ private static native void nDrawTextOnPath(int renderer, String text, int start, int end,
+ int path, float hOffset, float vOffset, int bidiFlags, int nativePaint);
@Override
public void drawTextRun(char[] text, int index, int count, int contextIndex, int contextCount,
}
}
- private static native void nDrawTextRun(long renderer, char[] text, int index, int count,
- int contextIndex, int contextCount, float x, float y, int dir, long nativePaint);
+ private static native void nDrawTextRun(int renderer, char[] text, int index, int count,
+ int contextIndex, int contextCount, float x, float y, int dir, int nativePaint);
@Override
public void drawTextRun(CharSequence text, int start, int end, int contextStart, int contextEnd,
}
}
- private static native void nDrawTextRun(long renderer, String text, int start, int end,
- int contextStart, int contextEnd, float x, float y, int flags, long nativePaint);
+ private static native void nDrawTextRun(int renderer, String text, int start, int end,
+ int contextStart, int contextEnd, float x, float y, int flags, int nativePaint);
@Override
public void drawVertices(VertexMode mode, int vertexCount, float[] verts, int vertOffset,
return MODIFIER_NONE;
}
- private static native void nSetupShader(long renderer, long shader);
- private static native void nSetupColorFilter(long renderer, long colorFilter);
- private static native void nSetupShadow(long renderer, float radius,
+ private static native void nSetupShader(int renderer, int shader);
+ private static native void nSetupColorFilter(int renderer, int colorFilter);
+ private static native void nSetupShadow(int renderer, float radius,
float dx, float dy, int color);
- private static native void nResetModifiers(long renderer, int modifiers);
+ private static native void nResetModifiers(int renderer, int modifiers);
}
* An OpenGL ES 2.0 implementation of {@link HardwareLayer}.
*/
abstract class GLES20Layer extends HardwareLayer {
- long mLayer;
+ int mLayer;
Finalizer mFinalizer;
GLES20Layer() {
*
* @return A pointer to the native layer object, or 0 if the object is NULL
*/
- public long getLayer() {
+ public int getLayer() {
return mLayer;
}
}
static class Finalizer {
- private long mLayerId;
+ private int mLayerId;
- public Finalizer(long layerId) {
+ public Finalizer(int layerId) {
mLayerId = layerId;
}
mDisplayList.clearReferences();
}
- long end(long nativeDisplayList) {
+ int end(int nativeDisplayList) {
return getDisplayList(nativeDisplayList);
}
}
@Override
- void detachFunctor(long functor) {
+ void detachFunctor(int functor) {
if (mCanvas != null) {
mCanvas.detachFunctor(functor);
}
}
@Override
- boolean attachFunctor(View.AttachInfo attachInfo, long functor) {
+ boolean attachFunctor(View.AttachInfo attachInfo, int functor) {
if (mCanvas != null) {
mCanvas.attachFunctor(functor);
mFunctorsRunnable.attachInfo = attachInfo;
private final int mFormat;
private final int mUsage;
// Note: do not rename, this field is used by native code
- private final long mNativeObject;
+ private final int mNativeObject;
// These two fields are only used by lock/unlockCanvas()
private Canvas mCanvas;
* @return A <code>GraphicBuffer</code> instance or null
*/
public static GraphicBuffer create(int width, int height, int format, int usage) {
- long nativeObject = nCreateGraphicBuffer(width, height, format, usage);
+ int nativeObject = nCreateGraphicBuffer(width, height, format, usage);
if (nativeObject != 0) {
return new GraphicBuffer(width, height, format, usage, nativeObject);
}
/**
* Private use only. See {@link #create(int, int, int, int)}.
*/
- private GraphicBuffer(int width, int height, int format, int usage, long nativeObject) {
+ private GraphicBuffer(int width, int height, int format, int usage, int nativeObject) {
mWidth = width;
mHeight = height;
mFormat = format;
int height = in.readInt();
int format = in.readInt();
int usage = in.readInt();
- long nativeObject = nReadGraphicBufferFromParcel(in);
+ int nativeObject = nReadGraphicBufferFromParcel(in);
if (nativeObject != 0) {
return new GraphicBuffer(width, height, format, usage, nativeObject);
}
}
};
- private static native long nCreateGraphicBuffer(int width, int height, int format, int usage);
- private static native void nDestroyGraphicBuffer(long nativeObject);
- private static native void nWriteGraphicBufferToParcel(long nativeObject, Parcel dest);
- private static native long nReadGraphicBufferFromParcel(Parcel in);
- private static native boolean nLockCanvas(long nativeObject, Canvas canvas, Rect dirty);
- private static native boolean nUnlockCanvasAndPost(long nativeObject, Canvas canvas);
+ private static native int nCreateGraphicBuffer(int width, int height, int format, int usage);
+ private static native void nDestroyGraphicBuffer(int nativeObject);
+ private static native void nWriteGraphicBufferToParcel(int nativeObject, Parcel dest);
+ private static native int nReadGraphicBufferFromParcel(Parcel in);
+ private static native boolean nLockCanvas(int nativeObject, Canvas canvas, Rect dirty);
+ private static native boolean nUnlockCanvasAndPost(int nativeObject, Canvas canvas);
}
*
* @hide
*/
- public int callDrawGLFunction(long drawGLFunction) {
+ public int callDrawGLFunction(int drawGLFunction) {
// Noop - this is done in the display list recorder subclass
return DisplayList.STATUS_DONE;
}
* @param functor The native functor to remove from the execution queue.
*
* @see #invokeFunctors(android.graphics.Rect)
- * @see #callDrawGLFunction(long)
- * @see #detachFunctor(long)
+ * @see #callDrawGLFunction(int)
+ * @see #detachFunctor(int)
*
* @hide
*/
- abstract void detachFunctor(long functor);
+ abstract void detachFunctor(int functor);
/**
* Attaches the specified functor to the current functor execution queue.
* @param functor The native functor to add to the execution queue.
*
* @see #invokeFunctors(android.graphics.Rect)
- * @see #callDrawGLFunction(long)
- * @see #detachFunctor(long)
+ * @see #callDrawGLFunction(int)
+ * @see #detachFunctor(int)
*
* @hide
*/
- abstract void attachFunctor(long functor);
+ abstract void attachFunctor(int functor);
/**
* Indicates that the specified layer must be updated as soon as possible.
* @param functor The native functor to remove from the execution queue.
*
* @see HardwareCanvas#callDrawGLFunction(int)
- * @see #attachFunctor(android.view.View.AttachInfo, long)
+ * @see #attachFunctor(android.view.View.AttachInfo, int)
*/
- abstract void detachFunctor(long functor);
+ abstract void detachFunctor(int functor);
/**
* Schedules the specified functor in the functors execution queue.
* @param functor The native functor to insert in the execution queue.
*
* @see HardwareCanvas#callDrawGLFunction(int)
- * @see #detachFunctor(long)
+ * @see #detachFunctor(int)
*
* @return true if the functor was attached successfully
*/
- abstract boolean attachFunctor(View.AttachInfo attachInfo, long functor);
+ abstract boolean attachFunctor(View.AttachInfo attachInfo, int functor);
/**
* Initializes the hardware renderer for the specified surface and setup the
}
@Override
- void detachFunctor(long functor) {
+ void detachFunctor(int functor) {
if (mCanvas != null) {
mCanvas.detachFunctor(functor);
}
}
@Override
- boolean attachFunctor(View.AttachInfo attachInfo, long functor) {
+ boolean attachFunctor(View.AttachInfo attachInfo, int functor) {
if (mCanvas != null) {
mCanvas.attachFunctor(functor);
mFunctorsRunnable.attachInfo = attachInfo;
public class Surface implements Parcelable {
private static final String TAG = "Surface";
- private static native long nativeCreateFromSurfaceTexture(SurfaceTexture surfaceTexture)
+ private static native int nativeCreateFromSurfaceTexture(SurfaceTexture surfaceTexture)
throws OutOfResourcesException;
- private static native long nativeCreateFromSurfaceControl(long surfaceControlNativeObject);
+ private static native int nativeCreateFromSurfaceControl(int surfaceControlNativeObject);
- private static native long nativeLockCanvas(long nativeObject, Canvas canvas, Rect dirty)
+ private static native int nativeLockCanvas(int nativeObject, Canvas canvas, Rect dirty)
throws OutOfResourcesException;
- private static native void nativeUnlockCanvasAndPost(long nativeObject, Canvas canvas);
+ private static native void nativeUnlockCanvasAndPost(int nativeObject, Canvas canvas);
- private static native void nativeRelease(long nativeObject);
- private static native boolean nativeIsValid(long nativeObject);
- private static native boolean nativeIsConsumerRunningBehind(long nativeObject);
- private static native long nativeReadFromParcel(long nativeObject, Parcel source);
- private static native void nativeWriteToParcel(long nativeObject, Parcel dest);
+ private static native void nativeRelease(int nativeObject);
+ private static native boolean nativeIsValid(int nativeObject);
+ private static native boolean nativeIsConsumerRunningBehind(int nativeObject);
+ private static native int nativeReadFromParcel(int nativeObject, Parcel source);
+ private static native void nativeWriteToParcel(int nativeObject, Parcel dest);
public static final Parcelable.Creator<Surface> CREATOR =
new Parcelable.Creator<Surface>() {
// Guarded state.
final Object mLock = new Object(); // protects the native state
private String mName;
- long mNativeObject; // package scope only for SurfaceControl access
- private long mLockedObject;
+ int mNativeObject; // package scope only for SurfaceControl access
+ private int mLockedObject;
private int mGenerationId; // incremented each time mNativeObject changes
private final Canvas mCanvas = new CompatibleCanvas();
}
/* called from android_view_Surface_createFromIGraphicBufferProducer() */
- private Surface(long nativeObject) {
+ private Surface(int nativeObject) {
synchronized (mLock) {
setNativeObjectLocked(nativeObject);
}
checkNotReleasedLocked();
if (mNativeObject != mLockedObject) {
Log.w(TAG, "WARNING: Surface's mNativeObject (0x" +
- Long.toHexString(mNativeObject) + ") != mLockedObject (0x" +
- Long.toHexString(mLockedObject) +")");
+ Integer.toHexString(mNativeObject) + ") != mLockedObject (0x" +
+ Integer.toHexString(mLockedObject) +")");
}
if (mLockedObject == 0) {
throw new IllegalStateException("Surface was not locked");
throw new IllegalArgumentException("other must not be null");
}
- long surfaceControlPtr = other.mNativeObject;
+ int surfaceControlPtr = other.mNativeObject;
if (surfaceControlPtr == 0) {
throw new NullPointerException(
"SurfaceControl native object is null. Are you using a released SurfaceControl?");
}
- long newNativeObject = nativeCreateFromSurfaceControl(surfaceControlPtr);
+ int newNativeObject = nativeCreateFromSurfaceControl(surfaceControlPtr);
synchronized (mLock) {
if (mNativeObject != 0) {
throw new IllegalArgumentException("other must not be null");
}
if (other != this) {
- final long newPtr;
+ final int newPtr;
synchronized (other.mLock) {
newPtr = other.mNativeObject;
other.setNativeObjectLocked(0);
}
}
- private void setNativeObjectLocked(long ptr) {
+ private void setNativeObjectLocked(int ptr) {
if (mNativeObject != ptr) {
if (mNativeObject == 0 && ptr != 0) {
mCloseGuard.open("release");
public class SurfaceControl {
private static final String TAG = "SurfaceControl";
- private static native long nativeCreate(SurfaceSession session, String name,
+ private static native int nativeCreate(SurfaceSession session, String name,
int w, int h, int format, int flags)
throws OutOfResourcesException;
- private static native void nativeRelease(long nativeObject);
- private static native void nativeDestroy(long nativeObject);
+ private static native void nativeRelease(int nativeObject);
+ private static native void nativeDestroy(int nativeObject);
private static native Bitmap nativeScreenshot(IBinder displayToken,
int width, int height, int minLayer, int maxLayer, boolean allLayers);
private static native void nativeCloseTransaction();
private static native void nativeSetAnimationTransaction();
- private static native void nativeSetLayer(long nativeObject, int zorder);
- private static native void nativeSetPosition(long nativeObject, float x, float y);
- private static native void nativeSetSize(long nativeObject, int w, int h);
- private static native void nativeSetTransparentRegionHint(long nativeObject, Region region);
- private static native void nativeSetAlpha(long nativeObject, float alpha);
- private static native void nativeSetMatrix(long nativeObject, float dsdx, float dtdx, float dsdy, float dtdy);
- private static native void nativeSetFlags(long nativeObject, int flags, int mask);
- private static native void nativeSetWindowCrop(long nativeObject, int l, int t, int r, int b);
- private static native void nativeSetLayerStack(long nativeObject, int layerStack);
+ private static native void nativeSetLayer(int nativeObject, int zorder);
+ private static native void nativeSetPosition(int nativeObject, float x, float y);
+ private static native void nativeSetSize(int nativeObject, int w, int h);
+ private static native void nativeSetTransparentRegionHint(int nativeObject, Region region);
+ private static native void nativeSetAlpha(int nativeObject, float alpha);
+ private static native void nativeSetMatrix(int nativeObject, float dsdx, float dtdx, float dsdy, float dtdy);
+ private static native void nativeSetFlags(int nativeObject, int flags, int mask);
+ private static native void nativeSetWindowCrop(int nativeObject, int l, int t, int r, int b);
+ private static native void nativeSetLayerStack(int nativeObject, int layerStack);
private static native IBinder nativeGetBuiltInDisplay(int physicalDisplayId);
private static native IBinder nativeCreateDisplay(String name, boolean secure);
private static native void nativeDestroyDisplay(IBinder displayToken);
private static native void nativeSetDisplaySurface(
- IBinder displayToken, long nativeSurfaceObject);
+ IBinder displayToken, int nativeSurfaceObject);
private static native void nativeSetDisplayLayerStack(
IBinder displayToken, int layerStack);
private static native void nativeSetDisplayProjection(
private final CloseGuard mCloseGuard = CloseGuard.get();
private final String mName;
- long mNativeObject; // package visibility only for Surface.java access
+ int mNativeObject; // package visibility only for Surface.java access
/* flags used in constructor (keep in sync with ISurfaceComposerClient.h) */
private final Object[] mNativeWindowLock = new Object[0];
// Used from native code, do not write!
@SuppressWarnings({"UnusedDeclaration"})
- private long mNativeWindow;
+ private int mNativeWindow;
/**
* Creates a new TextureView.
private native void nCreateNativeWindow(SurfaceTexture surface);
private native void nDestroyNativeWindow();
- private static native boolean nLockCanvas(long nativeWindow, Canvas canvas, Rect dirty);
- private static native void nUnlockCanvasAndPost(long nativeWindow, Canvas canvas);
+ private static native boolean nLockCanvas(int nativeWindow, Canvas canvas, Rect dirty);
+ private static native void nUnlockCanvasAndPost(int nativeWindow, Canvas canvas);
}
}
@Override
- void detachFunctor(long functor) {
+ void detachFunctor(int functor) {
run("detachFunctor", functor);
}
@Override
- boolean attachFunctor(AttachInfo attachInfo, long functor) {
+ boolean attachFunctor(AttachInfo attachInfo, int functor) {
return (Boolean) run("attachFunctor", attachInfo, functor);
}
}\r
\r
static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,\r
- jint offset, jint stride, jint width, jint height,\r
- jint configHandle, jboolean isMutable) {\r
- SkBitmap::Config config = static_cast<SkBitmap::Config>(configHandle);\r
+ int offset, int stride, int width, int height,\r
+ SkBitmap::Config config, jboolean isMutable) {\r
if (NULL != jColors) {\r
size_t n = env->GetArrayLength(jColors);\r
if (n < SkAbs32(stride) * (size_t)height) {\r
getPremulBitmapCreateFlags(isMutable), NULL, NULL);\r
}\r
\r
-static jobject Bitmap_copy(JNIEnv* env, jobject, jlong srcHandle,\r
- jint dstConfigHandle, jboolean isMutable) {\r
- const SkBitmap* src = reinterpret_cast<SkBitmap*>(srcHandle);\r
- SkBitmap::Config dstConfig = static_cast<SkBitmap::Config>(dstConfigHandle);\r
+static jobject Bitmap_copy(JNIEnv* env, jobject, const SkBitmap* src,\r
+ SkBitmap::Config dstConfig, jboolean isMutable) {\r
SkBitmap result;\r
JavaPixelAllocator allocator(env);\r
\r
getPremulBitmapCreateFlags(isMutable), NULL, NULL);\r
}\r
\r
-static void Bitmap_destructor(JNIEnv* env, jobject, jlong bitmapHandle) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+static void Bitmap_destructor(JNIEnv* env, jobject, SkBitmap* bitmap) {\r
#ifdef USE_OPENGL_RENDERER\r
if (android::uirenderer::Caches::hasInstance()) {\r
android::uirenderer::Caches::getInstance().resourceCache.destructor(bitmap);\r
delete bitmap;\r
}\r
\r
-static jboolean Bitmap_recycle(JNIEnv* env, jobject, jlong bitmapHandle) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+static jboolean Bitmap_recycle(JNIEnv* env, jobject, SkBitmap* bitmap) {\r
#ifdef USE_OPENGL_RENDERER\r
if (android::uirenderer::Caches::hasInstance()) {\r
- bool result;\r
- result = android::uirenderer::Caches::getInstance().resourceCache.recycle(bitmap);\r
- return result ? JNI_TRUE : JNI_FALSE;\r
+ return android::uirenderer::Caches::getInstance().resourceCache.recycle(bitmap);\r
}\r
#endif // USE_OPENGL_RENDERER\r
bitmap->setPixels(NULL, NULL);\r
- return JNI_TRUE;\r
+ return true;\r
}\r
\r
-static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jlong bitmapHandle,\r
- jint width, jint height, jint configHandle, jint allocSize) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
- SkBitmap::Config config = static_cast<SkBitmap::Config>(configHandle); \r
+static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jint bitmapInt,\r
+ int width, int height, SkBitmap::Config config, int allocSize) {\r
if (width * height * SkBitmap::ComputeBytesPerPixel(config) > allocSize) {\r
// done in native as there's no way to get BytesPerPixel in Java\r
doThrowIAE(env, "Bitmap not large enough to support new configuration");\r
return;\r
}\r
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapInt);\r
SkPixelRef* ref = bitmap->pixelRef();\r
SkSafeRef(ref);\r
bitmap->setConfig(config, width, height);\r
kWEBP_JavaEncodeFormat = 2\r
};\r
\r
-static jboolean Bitmap_compress(JNIEnv* env, jobject clazz, jlong bitmapHandle,\r
- jint format, jint quality,\r
- jobject jstream, jbyteArray jstorage) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap,\r
+ int format, int quality,\r
+ jobject jstream, jbyteArray jstorage) {\r
SkImageEncoder::Type fm;\r
\r
switch (format) {\r
fm = SkImageEncoder::kWEBP_Type;\r
break;\r
default:\r
- return JNI_FALSE;\r
+ return false;\r
}\r
\r
bool success = false;\r
SkAutoLockPixels alp(*bitmap);\r
\r
if (NULL == bitmap->getPixels()) {\r
- return JNI_FALSE;\r
+ return false;\r
}\r
\r
SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);\r
if (NULL == strm) {\r
- return JNI_FALSE;\r
+ return false;\r
}\r
\r
SkImageEncoder* encoder = SkImageEncoder::Create(fm);\r
}\r
delete strm;\r
}\r
- return success ? JNI_TRUE : JNI_FALSE;\r
+ return success;\r
}\r
\r
-static void Bitmap_erase(JNIEnv* env, jobject, jlong bitmapHandle, jint color) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+static void Bitmap_erase(JNIEnv* env, jobject, SkBitmap* bitmap, jint color) {\r
bitmap->eraseColor(color);\r
}\r
\r
-static jint Bitmap_rowBytes(JNIEnv* env, jobject, jlong bitmapHandle) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
- return static_cast<jint>(bitmap->rowBytes());\r
+static int Bitmap_rowBytes(JNIEnv* env, jobject, SkBitmap* bitmap) {\r
+ return bitmap->rowBytes();\r
}\r
\r
-static jint Bitmap_config(JNIEnv* env, jobject, jlong bitmapHandle) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
- return static_cast<jint>(bitmap->config());\r
+static int Bitmap_config(JNIEnv* env, jobject, SkBitmap* bitmap) {\r
+ return bitmap->config();\r
}\r
\r
-static jint Bitmap_getGenerationId(JNIEnv* env, jobject, jlong bitmapHandle) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
- return static_cast<jint>(bitmap->getGenerationID());\r
+static int Bitmap_getGenerationId(JNIEnv* env, jobject, SkBitmap* bitmap) {\r
+ return bitmap->getGenerationID();\r
}\r
\r
-static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, jlong bitmapHandle) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
- return !bitmap->isOpaque() ? JNI_TRUE : JNI_FALSE;\r
+static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, SkBitmap* bitmap) {\r
+ return !bitmap->isOpaque();\r
}\r
\r
-static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle,\r
+static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, SkBitmap* bitmap,\r
jboolean hasAlpha, jboolean isPremul) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
if (!hasAlpha) {\r
bitmap->setAlphaType(kOpaque_SkAlphaType);\r
} else if (isPremul) {\r
} else {\r
bitmap->setAlphaType(kUnpremul_SkAlphaType);\r
}\r
- bitmap->setIsOpaque(!hasAlpha);\r
}\r
\r
-static jboolean Bitmap_hasMipMap(JNIEnv* env, jobject, jlong bitmapHandle) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
- return bitmap->hasHardwareMipMap() ? JNI_TRUE : JNI_FALSE;\r
+static jboolean Bitmap_hasMipMap(JNIEnv* env, jobject, SkBitmap* bitmap) {\r
+ return bitmap->hasHardwareMipMap();\r
}\r
\r
-static void Bitmap_setHasMipMap(JNIEnv* env, jobject, jlong bitmapHandle,\r
+static void Bitmap_setHasMipMap(JNIEnv* env, jobject, SkBitmap* bitmap,\r
jboolean hasMipMap) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
bitmap->setHasHardwareMipMap(hasMipMap);\r
}\r
\r
}\r
\r
static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject,\r
- jlong bitmapHandle,\r
+ const SkBitmap* bitmap,\r
jboolean isMutable, jint density,\r
jobject parcel) {\r
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
if (parcel == NULL) {\r
SkDebugf("------- writeToParcel null parcel\n");\r
- return JNI_FALSE;\r
+ return false;\r
}\r
\r
android::Parcel* p = android::parcelForJavaObject(env, parcel);\r
android::status_t status = p->writeBlob(size, &blob);\r
if (status) {\r
doThrowRE(env, "Could not write bitmap to parcel blob.");\r
- return JNI_FALSE;\r
+ return false;\r
}\r
\r
bitmap->lockPixels();\r
bitmap->unlockPixels();\r
\r
blob.release();\r
- return JNI_TRUE;\r
+ return true;\r
}\r
\r
static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz,\r
- jlong srcHandle, jlong paintHandle,\r
+ const SkBitmap* src, const SkPaint* paint,\r
jintArray offsetXY) {\r
- const SkBitmap* src = reinterpret_cast<SkBitmap*>(srcHandle);\r
- const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);\r
SkIPoint offset;\r
SkBitmap* dst = new SkBitmap;\r
JavaPixelAllocator allocator(env);\r
\r
///////////////////////////////////////////////////////////////////////////////\r
\r
-static jint Bitmap_getPixel(JNIEnv* env, jobject, jlong bitmapHandle,\r
- jint x, jint y, jboolean isPremultiplied) {\r
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+static int Bitmap_getPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,\r
+ int x, int y, bool isPremultiplied) {\r
SkAutoLockPixels alp(*bitmap);\r
\r
ToColorProc proc = ChooseToColorProc(*bitmap, isPremultiplied);\r
\r
SkColor dst[1];\r
proc(dst, src, 1, bitmap->getColorTable());\r
- return static_cast<jint>(dst[0]);\r
+ return dst[0];\r
}\r
\r
-static void Bitmap_getPixels(JNIEnv* env, jobject, jlong bitmapHandle,\r
- jintArray pixelArray, jint offset, jint stride,\r
- jint x, jint y, jint width, jint height, jboolean isPremultiplied) {\r
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+static void Bitmap_getPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,\r
+ jintArray pixelArray, int offset, int stride,\r
+ int x, int y, int width, int height, bool isPremultiplied) {\r
SkAutoLockPixels alp(*bitmap);\r
\r
ToColorProc proc = ChooseToColorProc(*bitmap, isPremultiplied);\r
\r
///////////////////////////////////////////////////////////////////////////////\r
\r
-static void Bitmap_setPixel(JNIEnv* env, jobject, jlong bitmapHandle,\r
- jint x, jint y, jint colorHandle, jboolean isPremultiplied) {\r
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
- SkColor color = static_cast<SkColor>(colorHandle);\r
+static void Bitmap_setPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,\r
+ int x, int y, SkColor color, bool isPremultiplied) {\r
SkAutoLockPixels alp(*bitmap);\r
if (NULL == bitmap->getPixels()) {\r
return;\r
bitmap->notifyPixelsChanged();\r
}\r
\r
-static void Bitmap_setPixels(JNIEnv* env, jobject, jlong bitmapHandle,\r
- jintArray pixelArray, jint offset, jint stride,\r
- jint x, jint y, jint width, jint height, jboolean isPremultiplied) {\r
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+static void Bitmap_setPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,\r
+ jintArray pixelArray, int offset, int stride,\r
+ int x, int y, int width, int height, bool isPremultiplied) {\r
GraphicsJNI::SetPixels(env, pixelArray, offset, stride,\r
x, y, width, height, *bitmap, isPremultiplied);\r
}\r
\r
static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject,\r
- jlong bitmapHandle, jobject jbuffer) {\r
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+ const SkBitmap* bitmap, jobject jbuffer) {\r
SkAutoLockPixels alp(*bitmap);\r
const void* src = bitmap->getPixels();\r
\r
}\r
\r
static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject,\r
- jlong bitmapHandle, jobject jbuffer) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+ const SkBitmap* bitmap, jobject jbuffer) {\r
SkAutoLockPixels alp(*bitmap);\r
void* dst = bitmap->getPixels();\r
\r
}\r
}\r
\r
-static jboolean Bitmap_sameAs(JNIEnv* env, jobject, jlong bm0Handle,\r
- jlong bm1Handle) {\r
- const SkBitmap* bm0 = reinterpret_cast<SkBitmap*>(bm0Handle);\r
- const SkBitmap* bm1 = reinterpret_cast<SkBitmap*>(bm1Handle);\r
+static bool Bitmap_sameAs(JNIEnv* env, jobject, const SkBitmap* bm0,\r
+ const SkBitmap* bm1) {\r
if (bm0->width() != bm1->width() ||\r
bm0->height() != bm1->height() ||\r
bm0->config() != bm1->config()) {\r
- return JNI_FALSE;\r
+ return false;\r
}\r
\r
SkAutoLockPixels alp0(*bm0);\r
\r
// if we can't load the pixels, return false\r
if (NULL == bm0->getPixels() || NULL == bm1->getPixels()) {\r
- return JNI_FALSE;\r
+ return false;\r
}\r
\r
if (bm0->config() == SkBitmap::kIndex8_Config) {\r
SkColorTable* ct0 = bm0->getColorTable();\r
SkColorTable* ct1 = bm1->getColorTable();\r
if (NULL == ct0 || NULL == ct1) {\r
- return JNI_FALSE;\r
+ return false;\r
}\r
if (ct0->count() != ct1->count()) {\r
- return JNI_FALSE;\r
+ return false;\r
}\r
\r
SkAutoLockColors alc0(ct0);\r
SkAutoLockColors alc1(ct1);\r
const size_t size = ct0->count() * sizeof(SkPMColor);\r
if (memcmp(alc0.colors(), alc1.colors(), size) != 0) {\r
- return JNI_FALSE;\r
+ return false;\r
}\r
}\r
\r
const size_t size = bm0->width() * bm0->bytesPerPixel();\r
for (int y = 0; y < h; y++) {\r
if (memcmp(bm0->getAddr(0, y), bm1->getAddr(0, y), size) != 0) {\r
- return JNI_FALSE;\r
+ return false;\r
}\r
}\r
- return JNI_TRUE;\r
+ return true;\r
}\r
\r
-static void Bitmap_prepareToDraw(JNIEnv* env, jobject, jlong bitmapHandle) {\r
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);\r
+static void Bitmap_prepareToDraw(JNIEnv* env, jobject, SkBitmap* bitmap) {\r
bitmap->lockPixels();\r
bitmap->unlockPixels();\r
}\r
static JNINativeMethod gBitmapMethods[] = {\r
{ "nativeCreate", "([IIIIIIZ)Landroid/graphics/Bitmap;",\r
(void*)Bitmap_creator },\r
- { "nativeCopy", "(JIZ)Landroid/graphics/Bitmap;",\r
+ { "nativeCopy", "(IIZ)Landroid/graphics/Bitmap;",\r
(void*)Bitmap_copy },\r
- { "nativeDestructor", "(J)V", (void*)Bitmap_destructor },\r
- { "nativeRecycle", "(J)Z", (void*)Bitmap_recycle },\r
- { "nativeReconfigure", "(JIIII)V", (void*)Bitmap_reconfigure },\r
- { "nativeCompress", "(JIILjava/io/OutputStream;[B)Z",\r
+ { "nativeDestructor", "(I)V", (void*)Bitmap_destructor },\r
+ { "nativeRecycle", "(I)Z", (void*)Bitmap_recycle },\r
+ { "nativeReconfigure", "(IIIII)V", (void*)Bitmap_reconfigure },\r
+ { "nativeCompress", "(IIILjava/io/OutputStream;[B)Z",\r
(void*)Bitmap_compress },\r
- { "nativeErase", "(JI)V", (void*)Bitmap_erase },\r
- { "nativeRowBytes", "(J)I", (void*)Bitmap_rowBytes },\r
- { "nativeConfig", "(J)I", (void*)Bitmap_config },\r
- { "nativeHasAlpha", "(J)Z", (void*)Bitmap_hasAlpha },\r
- { "nativeSetAlphaAndPremultiplied", "(JZZ)V", (void*)Bitmap_setAlphaAndPremultiplied},\r
- { "nativeHasMipMap", "(J)Z", (void*)Bitmap_hasMipMap },\r
- { "nativeSetHasMipMap", "(JZ)V", (void*)Bitmap_setHasMipMap },\r
+ { "nativeErase", "(II)V", (void*)Bitmap_erase },\r
+ { "nativeRowBytes", "(I)I", (void*)Bitmap_rowBytes },\r
+ { "nativeConfig", "(I)I", (void*)Bitmap_config },\r
+ { "nativeHasAlpha", "(I)Z", (void*)Bitmap_hasAlpha },\r
+ { "nativeSetAlphaAndPremultiplied", "(IZZ)V", (void*)Bitmap_setAlphaAndPremultiplied},\r
+ { "nativeHasMipMap", "(I)Z", (void*)Bitmap_hasMipMap },\r
+ { "nativeSetHasMipMap", "(IZ)V", (void*)Bitmap_setHasMipMap },\r
{ "nativeCreateFromParcel",\r
"(Landroid/os/Parcel;)Landroid/graphics/Bitmap;",\r
(void*)Bitmap_createFromParcel },\r
- { "nativeWriteToParcel", "(JZILandroid/os/Parcel;)Z",\r
+ { "nativeWriteToParcel", "(IZILandroid/os/Parcel;)Z",\r
(void*)Bitmap_writeToParcel },\r
- { "nativeExtractAlpha", "(JJ[I)Landroid/graphics/Bitmap;",\r
+ { "nativeExtractAlpha", "(II[I)Landroid/graphics/Bitmap;",\r
(void*)Bitmap_extractAlpha },\r
- { "nativeGenerationId", "(J)I", (void*)Bitmap_getGenerationId },\r
- { "nativeGetPixel", "(JIIZ)I", (void*)Bitmap_getPixel },\r
- { "nativeGetPixels", "(J[IIIIIIIZ)V", (void*)Bitmap_getPixels },\r
- { "nativeSetPixel", "(JIIIZ)V", (void*)Bitmap_setPixel },\r
- { "nativeSetPixels", "(J[IIIIIIIZ)V", (void*)Bitmap_setPixels },\r
- { "nativeCopyPixelsToBuffer", "(JLjava/nio/Buffer;)V",\r
+ { "nativeGenerationId", "(I)I", (void*)Bitmap_getGenerationId },\r
+ { "nativeGetPixel", "(IIIZ)I", (void*)Bitmap_getPixel },\r
+ { "nativeGetPixels", "(I[IIIIIIIZ)V", (void*)Bitmap_getPixels },\r
+ { "nativeSetPixel", "(IIIIZ)V", (void*)Bitmap_setPixel },\r
+ { "nativeSetPixels", "(I[IIIIIIIZ)V", (void*)Bitmap_setPixels },\r
+ { "nativeCopyPixelsToBuffer", "(ILjava/nio/Buffer;)V",\r
(void*)Bitmap_copyPixelsToBuffer },\r
- { "nativeCopyPixelsFromBuffer", "(JLjava/nio/Buffer;)V",\r
+ { "nativeCopyPixelsFromBuffer", "(ILjava/nio/Buffer;)V",\r
(void*)Bitmap_copyPixelsFromBuffer },\r
- { "nativeSameAs", "(JJ)Z", (void*)Bitmap_sameAs },\r
- { "nativePrepareToDraw", "(J)V", (void*)Bitmap_prepareToDraw },\r
+ { "nativeSameAs", "(II)Z", (void*)Bitmap_sameAs },\r
+ { "nativePrepareToDraw", "(I)V", (void*)Bitmap_prepareToDraw },\r
};\r
\r
#define kClassPathName "android/graphics/Bitmap"\r
SkBitmap* outputBitmap = NULL;
unsigned int existingBufferSize = 0;
if (javaBitmap != NULL) {
- outputBitmap = (SkBitmap*) env->GetLongField(javaBitmap, gBitmap_nativeBitmapFieldID);
+ outputBitmap = (SkBitmap*) env->GetIntField(javaBitmap, gBitmap_nativeBitmapFieldID);
if (outputBitmap->isImmutable()) {
ALOGW("Unable to reuse an immutable bitmap as an image decoder target.");
javaBitmap = NULL;
return doDecode(env, stream, padding, bitmapFactoryOptions, weOwnTheFD);
}
-static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jlong native_asset,
+static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jint native_asset,
jobject padding, jobject options) {
SkStreamRewindable* stream;
}
static jobject nativeDecodeByteArray(JNIEnv* env, jobject, jbyteArray byteArray,
- jint offset, jint length, jobject options) {
+ int offset, int length, jobject options) {
/* If optionsShareable() we could decide to just wrap the java array and
share it, but that means adding a globalref to the java array object
},
{ "nativeDecodeAsset",
- "(JLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",
+ "(ILandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",
(void*)nativeDecodeAsset
},
jclass bitmap_class = env->FindClass("android/graphics/Bitmap");
SkASSERT(bitmap_class);
- gBitmap_nativeBitmapFieldID = getFieldIDCheck(env, bitmap_class, "mNativeBitmap", "J");
+ gBitmap_nativeBitmapFieldID = getFieldIDCheck(env, bitmap_class, "mNativeBitmap", "I");
gBitmap_layoutBoundsFieldID = getFieldIDCheck(env, bitmap_class, "mLayoutBounds", "[I");
int ret = AndroidRuntime::registerNativeMethods(env,
"android/graphics/BitmapFactory$Options",
static void Camera_constructor(JNIEnv* env, jobject obj) {
Sk3DView* view = new Sk3DView;
- env->SetLongField(obj, gNativeInstanceFieldID, reinterpret_cast<jlong>(view));
+ env->SetIntField(obj, gNativeInstanceFieldID, (int)view);
}
static void Camera_destructor(JNIEnv* env, jobject obj) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* view = reinterpret_cast<Sk3DView*>(viewHandle);
- delete view;
+ delete (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
}
static void Camera_save(JNIEnv* env, jobject obj) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->save();
}
static void Camera_restore(JNIEnv* env, jobject obj) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->restore();
}
static void Camera_translate(JNIEnv* env, jobject obj,
- jfloat dx, jfloat dy, jfloat dz) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+ float dx, float dy, float dz) {
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->translate(SkFloatToScalar(dx), SkFloatToScalar(dy), SkFloatToScalar(dz));
}
-static void Camera_rotateX(JNIEnv* env, jobject obj, jfloat degrees) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+static void Camera_rotateX(JNIEnv* env, jobject obj, float degrees) {
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->rotateX(SkFloatToScalar(degrees));
}
-static void Camera_rotateY(JNIEnv* env, jobject obj, jfloat degrees) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+static void Camera_rotateY(JNIEnv* env, jobject obj, float degrees) {
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->rotateY(SkFloatToScalar(degrees));
}
-static void Camera_rotateZ(JNIEnv* env, jobject obj, jfloat degrees) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+static void Camera_rotateZ(JNIEnv* env, jobject obj, float degrees) {
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->rotateZ(SkFloatToScalar(degrees));
}
static void Camera_rotate(JNIEnv* env, jobject obj, jfloat x, jfloat y, jfloat z) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->rotateX(SkFloatToScalar(x));
v->rotateY(SkFloatToScalar(y));
v->rotateZ(SkFloatToScalar(z));
}
static void Camera_setLocation(JNIEnv* env, jobject obj, jfloat x, jfloat y, jfloat z) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->setCameraLocation(SkFloatToScalar(x), SkFloatToScalar(y), SkFloatToScalar(z));
}
static jfloat Camera_getLocationX(JNIEnv* env, jobject obj) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
return SkScalarToFloat(v->getCameraLocationX());
}
static jfloat Camera_getLocationY(JNIEnv* env, jobject obj) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
return SkScalarToFloat(v->getCameraLocationY());
}
static jfloat Camera_getLocationZ(JNIEnv* env, jobject obj) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
return SkScalarToFloat(v->getCameraLocationZ());
}
-static void Camera_getMatrix(JNIEnv* env, jobject obj, jlong matrixHandle) {
- SkMatrix* native_matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
- v->getMatrix(native_matrix);
+static void Camera_getMatrix(JNIEnv* env, jobject obj, int native_matrix) {
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
+ v->getMatrix((SkMatrix*)native_matrix);
}
-static void Camera_applyToCanvas(JNIEnv* env, jobject obj, jlong canvasHandle) {
- SkCanvas* native_canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+static void Camera_applyToCanvas(JNIEnv* env, jobject obj, int native_canvas) {
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
v->applyToCanvas((SkCanvas*)native_canvas);
}
-static jfloat Camera_dotWithNormal(JNIEnv* env, jobject obj,
- jfloat x, jfloat y, jfloat z) {
- jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
- Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
+static float Camera_dotWithNormal(JNIEnv* env, jobject obj,
+ float x, float y, float z) {
+ Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
SkScalar dot = v->dotWithNormal(SkFloatToScalar(x), SkFloatToScalar(y),
SkFloatToScalar(z));
return SkScalarToFloat(dot);
{ "getLocationX", "()F", (void*)Camera_getLocationX },
{ "getLocationY", "()F", (void*)Camera_getLocationY },
{ "getLocationZ", "()F", (void*)Camera_getLocationZ },
- { "nativeGetMatrix", "(J)V", (void*)Camera_getMatrix },
- { "nativeApplyToCanvas", "(J)V", (void*)Camera_applyToCanvas },
+ { "nativeGetMatrix", "(I)V", (void*)Camera_getMatrix },
+ { "nativeApplyToCanvas", "(I)V", (void*)Camera_applyToCanvas },
{ "dotWithNormal", "(FFF)F", (void*)Camera_dotWithNormal }
};
if (clazz == 0) {
return -1;
}
- gNativeInstanceFieldID = env->GetFieldID(clazz, "native_instance", "J");
+ gNativeInstanceFieldID = env->GetFieldID(clazz, "native_instance", "I");
if (gNativeInstanceFieldID == 0) {
return -1;
}
static uint32_t get_thread_msec() {
#if defined(HAVE_POSIX_CLOCKS)
struct timespec tm;
-
+
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tm);
-
+
return tm.tv_sec * 1000LL + tm.tv_nsec / 1000000;
#else
struct timeval tv;
-
+
gettimeofday(&tv, NULL);
return tv.tv_sec * 1000LL + tv.tv_usec / 1000;
#endif
class SkCanvasGlue {
public:
- static void finalizer(JNIEnv* env, jobject clazz, jlong canvasHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
+ static void finalizer(JNIEnv* env, jobject clazz, SkCanvas* canvas) {
canvas->unref();
}
- static jlong initRaster(JNIEnv* env, jobject, jlong bitmapHandle) {
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ static SkCanvas* initRaster(JNIEnv* env, jobject, SkBitmap* bitmap) {
if (bitmap) {
- return reinterpret_cast<jlong>(new SkCanvas(*bitmap));
+ return new SkCanvas(*bitmap);
} else {
// Create an empty bitmap device to prevent callers from crashing
// if they attempt to draw into this canvas.
SkBitmap emptyBitmap;
- return reinterpret_cast<jlong>(new SkCanvas(emptyBitmap));
+ return new SkCanvas(emptyBitmap);
}
}
-
+
static void copyCanvasState(JNIEnv* env, jobject clazz,
- jlong srcCanvasHandle, jlong dstCanvasHandle) {
- SkCanvas* srcCanvas = reinterpret_cast<SkCanvas*>(srcCanvasHandle);
- SkCanvas* dstCanvas = reinterpret_cast<SkCanvas*>(dstCanvasHandle);
+ SkCanvas* srcCanvas, SkCanvas* dstCanvas) {
if (srcCanvas && dstCanvas) {
dstCanvas->setMatrix(srcCanvas->getTotalMatrix());
if (NULL != srcCanvas->getDevice() && NULL != dstCanvas->getDevice()) {
static jboolean isOpaque(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
- bool result = canvas->getDevice()->accessBitmap(false).isOpaque();
- return result ? JNI_TRUE : JNI_FALSE;
+ return canvas->getDevice()->accessBitmap(false).isOpaque();
}
-
- static jint getWidth(JNIEnv* env, jobject jcanvas) {
+
+ static int getWidth(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
- int width = canvas->getDevice()->accessBitmap(false).width();
- return static_cast<jint>(width);
+ return canvas->getDevice()->accessBitmap(false).width();
}
-
- static jint getHeight(JNIEnv* env, jobject jcanvas) {
+
+ static int getHeight(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
- int height = canvas->getDevice()->accessBitmap(false).height();
- return static_cast<jint>(height);
+ return canvas->getDevice()->accessBitmap(false).height();
}
- static jint saveAll(JNIEnv* env, jobject jcanvas) {
+ static int saveAll(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
- int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save();
- return static_cast<jint>(result);
+ return GraphicsJNI::getNativeCanvas(env, jcanvas)->save();
}
-
- static jint save(JNIEnv* env, jobject jcanvas, jint flagsHandle) {
- SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);
+
+ static int save(JNIEnv* env, jobject jcanvas, SkCanvas::SaveFlags flags) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
- int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags);
- return static_cast<jint>(result);
+ return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags);
}
-
- static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, jobject bounds,
- jlong paintHandle, jint flags) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+
+ static int saveLayer(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds,
+ SkPaint* paint, int flags) {
SkRect* bounds_ = NULL;
SkRect storage;
if (bounds != NULL) {
GraphicsJNI::jrectf_to_rect(env, bounds, &storage);
bounds_ = &storage;
}
- return canvas->saveLayer(bounds_, paint, static_cast<SkCanvas::SaveFlags>(flags));
+ return canvas->saveLayer(bounds_, paint, (SkCanvas::SaveFlags)flags);
}
-
- static jint saveLayer4F(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static int saveLayer4F(JNIEnv* env, jobject, SkCanvas* canvas,
jfloat l, jfloat t, jfloat r, jfloat b,
- jlong paintHandle, jint flags) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ SkPaint* paint, int flags) {
SkRect bounds;
bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r),
SkFloatToScalar(b));
- int result = canvas->saveLayer(&bounds, paint,
- static_cast<SkCanvas::SaveFlags>(flags));
- return static_cast<jint>(result);
+ return canvas->saveLayer(&bounds, paint, (SkCanvas::SaveFlags)flags);
}
-
- static jint saveLayerAlpha(JNIEnv* env, jobject, jlong canvasHandle,
- jobject bounds, jint alpha, jint flags) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
+
+ static int saveLayerAlpha(JNIEnv* env, jobject, SkCanvas* canvas,
+ jobject bounds, int alpha, int flags) {
SkRect* bounds_ = NULL;
SkRect storage;
if (bounds != NULL) {
GraphicsJNI::jrectf_to_rect(env, bounds, &storage);
bounds_ = &storage;
}
- int result = canvas->saveLayerAlpha(bounds_, alpha,
- static_cast<SkCanvas::SaveFlags>(flags));
- return static_cast<jint>(result);
+ return canvas->saveLayerAlpha(bounds_, alpha,
+ (SkCanvas::SaveFlags)flags);
}
-
- static jint saveLayerAlpha4F(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static int saveLayerAlpha4F(JNIEnv* env, jobject, SkCanvas* canvas,
jfloat l, jfloat t, jfloat r, jfloat b,
- jint alpha, jint flags) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
+ int alpha, int flags) {
SkRect bounds;
bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r),
SkFloatToScalar(b));
- int result = canvas->saveLayerAlpha(&bounds, alpha,
- static_cast<SkCanvas::SaveFlags>(flags));
- return static_cast<jint>(result);
+ return canvas->saveLayerAlpha(&bounds, alpha,
+ (SkCanvas::SaveFlags)flags);
}
-
+
static void restore(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_VOID(env, jcanvas);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
}
canvas->restore();
}
-
- static jint getSaveCount(JNIEnv* env, jobject jcanvas) {
+
+ static int getSaveCount(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
- int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount();
- return static_cast<jint>(result);
+ return GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount();
}
-
- static void restoreToCount(JNIEnv* env, jobject jcanvas, jint restoreCount) {
+
+ static void restoreToCount(JNIEnv* env, jobject jcanvas, int restoreCount) {
NPE_CHECK_RETURN_VOID(env, jcanvas);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
if (restoreCount < 1) {
}
canvas->restoreToCount(restoreCount);
}
-
+
static void translate(JNIEnv* env, jobject jcanvas, jfloat dx, jfloat dy) {
NPE_CHECK_RETURN_VOID(env, jcanvas);
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
(void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx_, dy_);
}
-
+
static void scale__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) {
NPE_CHECK_RETURN_VOID(env, jcanvas);
SkScalar sx_ = SkFloatToScalar(sx);
SkScalar sy_ = SkFloatToScalar(sy);
(void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx_, sy_);
}
-
+
static void rotate__F(JNIEnv* env, jobject jcanvas, jfloat degrees) {
NPE_CHECK_RETURN_VOID(env, jcanvas);
SkScalar degrees_ = SkFloatToScalar(degrees);
(void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees_);
}
-
+
static void skew__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) {
NPE_CHECK_RETURN_VOID(env, jcanvas);
SkScalar sx_ = SkFloatToScalar(sx);
SkScalar sy_ = SkFloatToScalar(sy);
(void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx_, sy_);
}
-
- static void concat(JNIEnv* env, jobject, jlong canvasHandle,
- jlong matrixHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+
+ static void concat(JNIEnv* env, jobject, SkCanvas* canvas,
+ const SkMatrix* matrix) {
canvas->concat(*matrix);
}
-
- static void setMatrix(JNIEnv* env, jobject, jlong canvasHandle,
- jlong matrixHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+
+ static void setMatrix(JNIEnv* env, jobject, SkCanvas* canvas,
+ const SkMatrix* matrix) {
if (NULL == matrix) {
canvas->resetMatrix();
} else {
canvas->setMatrix(*matrix);
}
}
-
+
static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left,
jfloat top, jfloat right, jfloat bottom) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
r.set(SkFloatToScalar(left), SkFloatToScalar(top),
SkFloatToScalar(right), SkFloatToScalar(bottom));
SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
- bool result = c->clipRect(r);
- return result ? JNI_TRUE : JNI_FALSE;
+ return c->clipRect(r);
}
-
+
static jboolean clipRect_IIII(JNIEnv* env, jobject jcanvas, jint left,
jint top, jint right, jint bottom) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
SkRect r;
r.set(SkIntToScalar(left), SkIntToScalar(top),
SkIntToScalar(right), SkIntToScalar(bottom));
- bool result = GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r);
- return result ? JNI_TRUE : JNI_FALSE;
+ return GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r);
}
-
+
static jboolean clipRect_RectF(JNIEnv* env, jobject jcanvas, jobject rectf) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
NPE_CHECK_RETURN_ZERO(env, rectf);
SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
SkRect tmp;
- bool result = c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp));
- return result ? JNI_TRUE : JNI_FALSE;
+ return c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp));
}
-
+
static jboolean clipRect_Rect(JNIEnv* env, jobject jcanvas, jobject rect) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
NPE_CHECK_RETURN_ZERO(env, rect);
SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
SkRect tmp;
- bool result = c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp));
- return result ? JNI_TRUE : JNI_FALSE;
-
+ return c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp));
}
-
- static jboolean clipRect(JNIEnv* env, jobject, jlong canvasHandle,
- jfloat left, jfloat top, jfloat right, jfloat bottom,
- jint op) {
+
+ static jboolean clipRect(JNIEnv* env, jobject, SkCanvas* canvas,
+ float left, float top, float right, float bottom,
+ int op) {
SkRect rect;
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
rect.set(SkFloatToScalar(left), SkFloatToScalar(top),
SkFloatToScalar(right), SkFloatToScalar(bottom));
- bool result = canvas->clipRect(rect, static_cast<SkRegion::Op>(op));
- return result ? JNI_TRUE : JNI_FALSE;
-
+ return canvas->clipRect(rect, (SkRegion::Op)op);
}
-
- static jboolean clipPath(JNIEnv* env, jobject, jlong canvasHandle,
- SkPath* path, jint op) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- bool result = canvas->clipPath(*path, static_cast<SkRegion::Op>(op));
- return result ? JNI_TRUE : JNI_FALSE;
+
+ static jboolean clipPath(JNIEnv* env, jobject, SkCanvas* canvas,
+ SkPath* path, int op) {
+ return canvas->clipPath(*path, (SkRegion::Op)op);
}
-
- static jboolean clipRegion(JNIEnv* env, jobject, jlong canvasHandle,
- jlong deviceRgnHandle, jint op) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkRegion* deviceRgn = reinterpret_cast<SkRegion*>(deviceRgnHandle);
- bool result = canvas->clipRegion(*deviceRgn, static_cast<SkRegion::Op>(op));
- return result ? JNI_TRUE : JNI_FALSE;
+
+ static jboolean clipRegion(JNIEnv* env, jobject, SkCanvas* canvas,
+ SkRegion* deviceRgn, int op) {
+ return canvas->clipRegion(*deviceRgn, (SkRegion::Op)op);
}
-
- static void setDrawFilter(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static void setDrawFilter(JNIEnv* env, jobject, SkCanvas* canvas,
SkDrawFilter* filter) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
canvas->setDrawFilter(filter);
}
-
- static jboolean quickReject__RectF(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static jboolean quickReject__RectF(JNIEnv* env, jobject, SkCanvas* canvas,
jobject rect) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
SkRect rect_;
GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
return canvas->quickReject(rect_);
}
- static jboolean quickReject__Path(JNIEnv* env, jobject, jlong canvasHandle,
+ static jboolean quickReject__Path(JNIEnv* env, jobject, SkCanvas* canvas,
SkPath* path) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- bool result = canvas->quickReject(*path);
- return result ? JNI_TRUE : JNI_FALSE;
+ return canvas->quickReject(*path);
}
- static jboolean quickReject__FFFF(JNIEnv* env, jobject, jlong canvasHandle,
+ static jboolean quickReject__FFFF(JNIEnv* env, jobject, SkCanvas* canvas,
jfloat left, jfloat top, jfloat right,
jfloat bottom) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
SkRect r;
r.set(SkFloatToScalar(left), SkFloatToScalar(top),
SkFloatToScalar(right), SkFloatToScalar(bottom));
- bool result = canvas->quickReject(r);
- return result ? JNI_TRUE : JNI_FALSE;
+ return canvas->quickReject(r);
}
-
- static void drawRGB(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static void drawRGB(JNIEnv* env, jobject, SkCanvas* canvas,
jint r, jint g, jint b) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
canvas->drawARGB(0xFF, r, g, b);
}
-
- static void drawARGB(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static void drawARGB(JNIEnv* env, jobject, SkCanvas* canvas,
jint a, jint r, jint g, jint b) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
canvas->drawARGB(a, r, g, b);
}
-
- static void drawColor__I(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static void drawColor__I(JNIEnv* env, jobject, SkCanvas* canvas,
jint color) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
canvas->drawColor(color);
}
-
- static void drawColor__II(JNIEnv* env, jobject, jlong canvasHandle,
- jint color, jint modeHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle);
+
+ static void drawColor__II(JNIEnv* env, jobject, SkCanvas* canvas,
+ jint color, SkPorterDuff::Mode mode) {
canvas->drawColor(color, SkPorterDuff::ToXfermodeMode(mode));
}
-
- static void drawPaint(JNIEnv* env, jobject, jlong canvasHandle,
- jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+
+ static void drawPaint(JNIEnv* env, jobject, SkCanvas* canvas,
+ SkPaint* paint) {
canvas->drawPaint(*paint);
}
-
+
static void doPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
jint offset, jint count, jobject jpaint,
- jint modeHandle) {
+ SkCanvas::PointMode mode) {
NPE_CHECK_RETURN_VOID(env, jcanvas);
NPE_CHECK_RETURN_VOID(env, jptsArray);
NPE_CHECK_RETURN_VOID(env, jpaint);
- SkCanvas::PointMode mode = static_cast<SkCanvas::PointMode>(modeHandle);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint);
-
+
AutoJavaFloatArray autoPts(env, jptsArray);
float* floats = autoPts.ptr();
const int length = autoPts.length();
-
+
if ((offset | count) < 0 || offset + count > length) {
doThrowAIOOBE(env);
return;
}
-
+
// now convert the floats into SkPoints
count >>= 1; // now it is the number of points
SkAutoSTMalloc<32, SkPoint> storage(count);
for (int i = 0; i < count; i++) {
pts[i].set(SkFloatToScalar(src[0]), SkFloatToScalar(src[1]));
src += 2;
- }
+ }
canvas->drawPoints(mode, count, pts, paint);
}
-
+
static void drawPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
jint offset, jint count, jobject jpaint) {
doPoints(env, jcanvas, jptsArray, offset, count, jpaint,
SkCanvas::kPoints_PointMode);
}
-
+
static void drawLines(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
jint offset, jint count, jobject jpaint) {
doPoints(env, jcanvas, jptsArray, offset, count, jpaint,
SkCanvas::kLines_PointMode);
}
-
- static void drawPoint(JNIEnv* env, jobject jcanvas, jfloat x, jfloat y,
+
+ static void drawPoint(JNIEnv* env, jobject jcanvas, float x, float y,
jobject jpaint) {
NPE_CHECK_RETURN_VOID(env, jcanvas);
NPE_CHECK_RETURN_VOID(env, jpaint);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint);
-
+
canvas->drawPoint(SkFloatToScalar(x), SkFloatToScalar(y), paint);
}
-
- static void drawLine__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static void drawLine__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
jfloat startX, jfloat startY, jfloat stopX,
- jfloat stopY, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ jfloat stopY, SkPaint* paint) {
canvas->drawLine(SkFloatToScalar(startX), SkFloatToScalar(startY),
SkFloatToScalar(stopX), SkFloatToScalar(stopY),
*paint);
}
-
- static void drawRect__RectFPaint(JNIEnv* env, jobject, jlong canvasHandle,
- jobject rect, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+
+ static void drawRect__RectFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
+ jobject rect, SkPaint* paint) {
SkRect rect_;
GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
canvas->drawRect(rect_, *paint);
}
-
- static void drawRect__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static void drawRect__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
jfloat left, jfloat top, jfloat right,
- jfloat bottom, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ jfloat bottom, SkPaint* paint) {
SkScalar left_ = SkFloatToScalar(left);
SkScalar top_ = SkFloatToScalar(top);
SkScalar right_ = SkFloatToScalar(right);
SkScalar bottom_ = SkFloatToScalar(bottom);
canvas->drawRectCoords(left_, top_, right_, bottom_, *paint);
}
-
- static void drawOval(JNIEnv* env, jobject, jlong canvasHandle, jobject joval,
- jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+
+ static void drawOval(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval,
+ SkPaint* paint) {
SkRect oval;
GraphicsJNI::jrectf_to_rect(env, joval, &oval);
canvas->drawOval(oval, *paint);
}
-
- static void drawCircle(JNIEnv* env, jobject, jlong canvasHandle, jfloat cx,
- jfloat cy, jfloat radius, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+
+ static void drawCircle(JNIEnv* env, jobject, SkCanvas* canvas, jfloat cx,
+ jfloat cy, jfloat radius, SkPaint* paint) {
canvas->drawCircle(SkFloatToScalar(cx), SkFloatToScalar(cy),
SkFloatToScalar(radius), *paint);
}
-
- static void drawArc(JNIEnv* env, jobject, jlong canvasHandle, jobject joval,
+
+ static void drawArc(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval,
jfloat startAngle, jfloat sweepAngle,
- jboolean useCenter, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ jboolean useCenter, SkPaint* paint) {
SkRect oval;
GraphicsJNI::jrectf_to_rect(env, joval, &oval);
canvas->drawArc(oval, SkFloatToScalar(startAngle),
SkFloatToScalar(sweepAngle), useCenter, *paint);
}
-
- static void drawRoundRect(JNIEnv* env, jobject, jlong canvasHandle,
+
+ static void drawRoundRect(JNIEnv* env, jobject, SkCanvas* canvas,
jobject jrect, jfloat rx, jfloat ry,
- jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ SkPaint* paint) {
SkRect rect;
GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
canvas->drawRoundRect(rect, SkFloatToScalar(rx), SkFloatToScalar(ry),
*paint);
}
-
- static void drawPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle,
- jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+
+ static void drawPath(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path,
+ SkPaint* paint) {
canvas->drawPath(*path, *paint);
}
-
+
static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas,
- jlong canvasHandle, jlong bitmapHandle,
+ SkCanvas* canvas, SkBitmap* bitmap,
jfloat left, jfloat top,
- jlong paintHandle, jint canvasDensity,
+ SkPaint* paint, jint canvasDensity,
jint screenDensity, jint bitmapDensity) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
SkScalar left_ = SkFloatToScalar(left);
SkScalar top_ = SkFloatToScalar(top);
GraphicsJNI::jrect_to_irect(env, srcIRect, &src);
srcPtr = &src;
}
-
+
if (screenDensity != 0 && screenDensity != bitmapDensity) {
SkPaint filteredPaint;
if (paint) {
}
}
- static void drawBitmapRF(JNIEnv* env, jobject, jlong canvasHandle,
- jlong bitmapHandle, jobject srcIRect,
- jobject dstRectF, jlong paintHandle,
+ static void drawBitmapRF(JNIEnv* env, jobject, SkCanvas* canvas,
+ SkBitmap* bitmap, jobject srcIRect,
+ jobject dstRectF, SkPaint* paint,
jint screenDensity, jint bitmapDensity) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
SkRect dst;
GraphicsJNI::jrectf_to_rect(env, dstRectF, &dst);
doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint,
screenDensity, bitmapDensity);
}
-
- static void drawBitmapRR(JNIEnv* env, jobject, jlong canvasHandle,
- jlong bitmapHandle, jobject srcIRect,
- jobject dstRect, jlong paintHandle,
+
+ static void drawBitmapRR(JNIEnv* env, jobject, SkCanvas* canvas,
+ SkBitmap* bitmap, jobject srcIRect,
+ jobject dstRect, SkPaint* paint,
jint screenDensity, jint bitmapDensity) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
SkRect dst;
GraphicsJNI::jrect_to_rect(env, dstRect, &dst);
doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint,
screenDensity, bitmapDensity);
}
-
- static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle,
- jintArray jcolors, jint offset, jint stride,
- jfloat x, jfloat y, jint width, jint height,
- jboolean hasAlpha, jlong paintHandle)
+
+ static void drawBitmapArray(JNIEnv* env, jobject, SkCanvas* canvas,
+ jintArray jcolors, int offset, int stride,
+ jfloat x, jfloat y, int width, int height,
+ jboolean hasAlpha, SkPaint* paint)
{
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
SkBitmap bitmap;
bitmap.setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config :
SkBitmap::kRGB_565_Config, width, height);
canvas->drawBitmap(bitmap, SkFloatToScalar(x), SkFloatToScalar(y),
paint);
}
-
- static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle,
- jlong bitmapHandle, jlong matrixHandle,
- jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
- const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+
+ static void drawBitmapMatrix(JNIEnv* env, jobject, SkCanvas* canvas,
+ const SkBitmap* bitmap, const SkMatrix* matrix,
+ const SkPaint* paint) {
canvas->drawBitmapMatrix(*bitmap, *matrix, paint);
}
-
- static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle,
- jlong bitmapHandle, jint meshWidth, jint meshHeight,
- jfloatArray jverts, jint vertIndex, jintArray jcolors,
- jint colorIndex, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+
+ static void drawBitmapMesh(JNIEnv* env, jobject, SkCanvas* canvas,
+ const SkBitmap* bitmap, int meshWidth, int meshHeight,
+ jfloatArray jverts, int vertIndex, jintArray jcolors,
+ int colorIndex, const SkPaint* paint) {
const int ptCount = (meshWidth + 1) * (meshHeight + 1);
const int indexCount = meshWidth * meshHeight * 6;
AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1));
AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount);
-
+
/* Our temp storage holds 2 or 3 arrays.
texture points [ptCount * sizeof(SkPoint)]
optionally vertex points [ptCount * sizeof(SkPoint)] if we need a
const SkScalar h = SkIntToScalar(bitmap->height());
const SkScalar dx = w / meshWidth;
const SkScalar dy = h / meshHeight;
-
+
SkPoint* texsPtr = texs;
SkScalar y = 0;
for (int i = 0; i <= meshHeight; i++) {
}
SkASSERT(texsPtr - texs == ptCount);
}
-
+
// cons up indices
{
uint16_t* indexPtr = indices;
indexCount, tmpPaint);
}
- static void drawVertices(JNIEnv* env, jobject, jlong canvasHandle,
- jint modeHandle, jint vertexCount,
- jfloatArray jverts, jint vertIndex,
- jfloatArray jtexs, jint texIndex,
- jintArray jcolors, jint colorIndex,
- jshortArray jindices, jint indexIndex,
- jint indexCount, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkCanvas::VertexMode mode = static_cast<SkCanvas::VertexMode>(modeHandle);
- const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ static void drawVertices(JNIEnv* env, jobject, SkCanvas* canvas,
+ SkCanvas::VertexMode mode, int vertexCount,
+ jfloatArray jverts, int vertIndex,
+ jfloatArray jtexs, int texIndex,
+ jintArray jcolors, int colorIndex,
+ jshortArray jindices, int indexIndex,
+ int indexCount, const SkPaint* paint) {
AutoJavaFloatArray vertA(env, jverts, vertIndex + vertexCount);
AutoJavaFloatArray texA(env, jtexs, texIndex + vertexCount);
count += ptCount; // += for texs
}
SkAutoMalloc storage(count * sizeof(SkPoint));
- verts = (SkPoint*)storage.get();
+ verts = (SkPoint*)storage.get();
const float* src = vertA.ptr() + vertIndex;
for (int i = 0; i < ptCount; i++) {
verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1]));
}
- static void drawText___CIIFFIPaintTypeface(JNIEnv* env, jobject, jlong canvasHandle,
- jcharArray text, jint index, jint count,
- jfloat x, jfloat y, jint flags,
- jlong paintHandle, jlong typefaceHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
- TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle);
+ static void drawText___CIIFFIPaintTypeface(JNIEnv* env, jobject, SkCanvas* canvas,
+ jcharArray text, int index, int count,
+ jfloat x, jfloat y, int flags, SkPaint* paint,
+ TypefaceImpl *typeface) {
jchar* textArray = env->GetCharArrayElements(text, NULL);
drawTextWithGlyphs(canvas, textArray + index, 0, count, x, y, flags, paint, typeface);
env->ReleaseCharArrayElements(text, textArray, JNI_ABORT);
}
static void drawText__StringIIFFIPaintTypeface(JNIEnv* env, jobject,
- jlong canvasHandle, jstring text,
- jint start, jint end,
- jfloat x, jfloat y, jint flags,
- jlong paintHandle, jlong typefaceHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
- TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle);
+ SkCanvas* canvas, jstring text,
+ int start, int end,
+ jfloat x, jfloat y, int flags, SkPaint* paint,
+ TypefaceImpl *typeface) {
const jchar* textArray = env->GetStringChars(text, NULL);
drawTextWithGlyphs(canvas, textArray, start, end, x, y, flags, paint, typeface);
env->ReleaseStringChars(text, textArray);
}
static void drawTextRun___CIIIIFFIPaintTypeface(
- JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, jint index,
- jint count, jint contextIndex, jint contextCount,
- jfloat x, jfloat y, jint dirFlags, jlong paintHandle, jlong typefaceHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
- TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle);
+ JNIEnv* env, jobject, SkCanvas* canvas, jcharArray text, int index,
+ int count, int contextIndex, int contextCount,
+ jfloat x, jfloat y, int dirFlags, SkPaint* paint,
+ TypefaceImpl* typeface) {
jchar* chars = env->GetCharArrayElements(text, NULL);
drawTextWithGlyphs(canvas, chars + contextIndex, index - contextIndex,
}
static void drawTextRun__StringIIIIFFIPaintTypeface(
- JNIEnv* env, jobject obj, jlong canvasHandle, jstring text, jint start,
+ JNIEnv* env, jobject obj, SkCanvas* canvas, jstring text, jint start,
jint end, jint contextStart, jint contextEnd,
- jfloat x, jfloat y, jint dirFlags, jlong paintHandle, jlong typefaceHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
- TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle);
+ jfloat x, jfloat y, jint dirFlags, SkPaint* paint,
+ TypefaceImpl* typeface) {
jint count = end - start;
jint contextCount = contextEnd - contextStart;
env->ReleaseStringChars(text, chars);
}
- static void drawPosText___CII_FPaint(JNIEnv* env, jobject, jlong canvasHandle,
- jcharArray text, jint index, jint count,
- jfloatArray pos, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ static void drawPosText___CII_FPaint(JNIEnv* env, jobject, SkCanvas* canvas,
+ jcharArray text, int index, int count,
+ jfloatArray pos, SkPaint* paint) {
jchar* textArray = text ? env->GetCharArrayElements(text, NULL) : NULL;
jsize textCount = text ? env->GetArrayLength(text) : NULL;
float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL;
posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]);
posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]);
}
-
+
SkPaint::TextEncoding encoding = paint->getTextEncoding();
paint->setTextEncoding(SkPaint::kUTF16_TextEncoding);
canvas->drawPosText(textArray + index, count << 1, posPtr, *paint);
paint->setTextEncoding(encoding);
-
+
if (text) {
env->ReleaseCharArrayElements(text, textArray, 0);
}
}
static void drawPosText__String_FPaint(JNIEnv* env, jobject,
- jlong canvasHandle, jstring text,
+ SkCanvas* canvas, jstring text,
jfloatArray pos,
- jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ SkPaint* paint) {
const void* text_ = text ? env->GetStringChars(text, NULL) : NULL;
int byteLength = text ? env->GetStringLength(text) : 0;
float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL;
}
static void drawTextOnPath___CIIPathFFPaint(JNIEnv* env, jobject,
- jlong canvasHandle, jcharArray text, jint index, jint count,
- jlong pathHandle, jfloat hOffset, jfloat vOffset, jint bidiFlags, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ SkCanvas* canvas, jcharArray text, int index, int count,
+ SkPath* path, jfloat hOffset, jfloat vOffset, jint bidiFlags, SkPaint* paint) {
jchar* textArray = env->GetCharArrayElements(text, NULL);
TextLayout::drawTextOnPath(paint, textArray + index, count, bidiFlags, hOffset, vOffset,
}
static void drawTextOnPath__StringPathFFPaint(JNIEnv* env, jobject,
- jlong canvasHandle, jstring text, jlong pathHandle,
- jfloat hOffset, jfloat vOffset, jint bidiFlags, jlong paintHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ SkCanvas* canvas, jstring text, SkPath* path,
+ jfloat hOffset, jfloat vOffset, jint bidiFlags, SkPaint* paint) {
const jchar* text_ = env->GetStringChars(text, NULL);
int count = env->GetStringLength(text);
TextLayout::drawTextOnPath(paint, text_, count, bidiFlags, hOffset, vOffset,
return true;
}
- static jboolean getClipBounds(JNIEnv* env, jobject, jlong canvasHandle,
- jobject bounds) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
+ static bool getClipBounds(JNIEnv* env, jobject, SkCanvas* canvas,
+ jobject bounds) {
SkRect r;
SkIRect ir;
bool result = getHardClipBounds(canvas, &r);
r.round(&ir);
(void)GraphicsJNI::irect_to_jrect(ir, env, bounds);
- return result ? JNI_TRUE : JNI_FALSE;
+ return result;
}
- static void getCTM(JNIEnv* env, jobject, jlong canvasHandle,
- jlong matrixHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+ static void getCTM(JNIEnv* env, jobject, SkCanvas* canvas,
+ SkMatrix* matrix) {
*matrix = canvas->getTotalMatrix();
}
};
static JNINativeMethod gCanvasMethods[] = {
- {"finalizer", "(J)V", (void*) SkCanvasGlue::finalizer},
- {"initRaster","(J)J", (void*) SkCanvasGlue::initRaster},
- {"copyNativeCanvasState","(JJ)V", (void*) SkCanvasGlue::copyCanvasState},
+ {"finalizer", "(I)V", (void*) SkCanvasGlue::finalizer},
+ {"initRaster","(I)I", (void*) SkCanvasGlue::initRaster},
+ {"copyNativeCanvasState","(II)V", (void*) SkCanvasGlue::copyCanvasState},
{"isOpaque","()Z", (void*) SkCanvasGlue::isOpaque},
{"getWidth","()I", (void*) SkCanvasGlue::getWidth},
{"getHeight","()I", (void*) SkCanvasGlue::getHeight},
{"save","()I", (void*) SkCanvasGlue::saveAll},
{"save","(I)I", (void*) SkCanvasGlue::save},
- {"native_saveLayer","(JLandroid/graphics/RectF;JI)I",
+ {"native_saveLayer","(ILandroid/graphics/RectF;II)I",
(void*) SkCanvasGlue::saveLayer},
- {"native_saveLayer","(JFFFFJI)I", (void*) SkCanvasGlue::saveLayer4F},
- {"native_saveLayerAlpha","(JLandroid/graphics/RectF;II)I",
+ {"native_saveLayer","(IFFFFII)I", (void*) SkCanvasGlue::saveLayer4F},
+ {"native_saveLayerAlpha","(ILandroid/graphics/RectF;II)I",
(void*) SkCanvasGlue::saveLayerAlpha},
- {"native_saveLayerAlpha","(JFFFFII)I",
+ {"native_saveLayerAlpha","(IFFFFII)I",
(void*) SkCanvasGlue::saveLayerAlpha4F},
{"restore","()V", (void*) SkCanvasGlue::restore},
{"getSaveCount","()I", (void*) SkCanvasGlue::getSaveCount},
{"scale","(FF)V", (void*) SkCanvasGlue::scale__FF},
{"rotate","(F)V", (void*) SkCanvasGlue::rotate__F},
{"skew","(FF)V", (void*) SkCanvasGlue::skew__FF},
- {"native_concat","(JJ)V", (void*) SkCanvasGlue::concat},
- {"native_setMatrix","(JJ)V", (void*) SkCanvasGlue::setMatrix},
+ {"native_concat","(II)V", (void*) SkCanvasGlue::concat},
+ {"native_setMatrix","(II)V", (void*) SkCanvasGlue::setMatrix},
{"clipRect","(FFFF)Z", (void*) SkCanvasGlue::clipRect_FFFF},
{"clipRect","(IIII)Z", (void*) SkCanvasGlue::clipRect_IIII},
{"clipRect","(Landroid/graphics/RectF;)Z",
(void*) SkCanvasGlue::clipRect_RectF},
{"clipRect","(Landroid/graphics/Rect;)Z",
(void*) SkCanvasGlue::clipRect_Rect},
- {"native_clipRect","(JFFFFI)Z", (void*) SkCanvasGlue::clipRect},
- {"native_clipPath","(JJI)Z", (void*) SkCanvasGlue::clipPath},
- {"native_clipRegion","(JJI)Z", (void*) SkCanvasGlue::clipRegion},
- {"nativeSetDrawFilter", "(JJ)V", (void*) SkCanvasGlue::setDrawFilter},
- {"native_getClipBounds","(JLandroid/graphics/Rect;)Z",
+ {"native_clipRect","(IFFFFI)Z", (void*) SkCanvasGlue::clipRect},
+ {"native_clipPath","(III)Z", (void*) SkCanvasGlue::clipPath},
+ {"native_clipRegion","(III)Z", (void*) SkCanvasGlue::clipRegion},
+ {"nativeSetDrawFilter", "(II)V", (void*) SkCanvasGlue::setDrawFilter},
+ {"native_getClipBounds","(ILandroid/graphics/Rect;)Z",
(void*) SkCanvasGlue::getClipBounds},
- {"native_getCTM", "(JJ)V", (void*)SkCanvasGlue::getCTM},
- {"native_quickReject","(JLandroid/graphics/RectF;)Z",
+ {"native_getCTM", "(II)V", (void*)SkCanvasGlue::getCTM},
+ {"native_quickReject","(ILandroid/graphics/RectF;)Z",
(void*) SkCanvasGlue::quickReject__RectF},
- {"native_quickReject","(JJ)Z", (void*) SkCanvasGlue::quickReject__Path},
- {"native_quickReject","(JFFFF)Z", (void*)SkCanvasGlue::quickReject__FFFF},
- {"native_drawRGB","(JIII)V", (void*) SkCanvasGlue::drawRGB},
- {"native_drawARGB","(JIIII)V", (void*) SkCanvasGlue::drawARGB},
- {"native_drawColor","(JI)V", (void*) SkCanvasGlue::drawColor__I},
- {"native_drawColor","(JII)V", (void*) SkCanvasGlue::drawColor__II},
- {"native_drawPaint","(JJ)V", (void*) SkCanvasGlue::drawPaint},
+ {"native_quickReject","(II)Z", (void*) SkCanvasGlue::quickReject__Path},
+ {"native_quickReject","(IFFFF)Z", (void*)SkCanvasGlue::quickReject__FFFF},
+ {"native_drawRGB","(IIII)V", (void*) SkCanvasGlue::drawRGB},
+ {"native_drawARGB","(IIIII)V", (void*) SkCanvasGlue::drawARGB},
+ {"native_drawColor","(II)V", (void*) SkCanvasGlue::drawColor__I},
+ {"native_drawColor","(III)V", (void*) SkCanvasGlue::drawColor__II},
+ {"native_drawPaint","(II)V", (void*) SkCanvasGlue::drawPaint},
{"drawPoint", "(FFLandroid/graphics/Paint;)V",
(void*) SkCanvasGlue::drawPoint},
{"drawPoints", "([FIILandroid/graphics/Paint;)V",
(void*) SkCanvasGlue::drawPoints},
{"drawLines", "([FIILandroid/graphics/Paint;)V",
(void*) SkCanvasGlue::drawLines},
- {"native_drawLine","(JFFFFJ)V", (void*) SkCanvasGlue::drawLine__FFFFPaint},
- {"native_drawRect","(JLandroid/graphics/RectF;J)V",
+ {"native_drawLine","(IFFFFI)V", (void*) SkCanvasGlue::drawLine__FFFFPaint},
+ {"native_drawRect","(ILandroid/graphics/RectF;I)V",
(void*) SkCanvasGlue::drawRect__RectFPaint},
- {"native_drawRect","(JFFFFJ)V", (void*) SkCanvasGlue::drawRect__FFFFPaint},
- {"native_drawOval","(JLandroid/graphics/RectF;J)V",
+ {"native_drawRect","(IFFFFI)V", (void*) SkCanvasGlue::drawRect__FFFFPaint},
+ {"native_drawOval","(ILandroid/graphics/RectF;I)V",
(void*) SkCanvasGlue::drawOval},
- {"native_drawCircle","(JFFFJ)V", (void*) SkCanvasGlue::drawCircle},
- {"native_drawArc","(JLandroid/graphics/RectF;FFZJ)V",
+ {"native_drawCircle","(IFFFI)V", (void*) SkCanvasGlue::drawCircle},
+ {"native_drawArc","(ILandroid/graphics/RectF;FFZI)V",
(void*) SkCanvasGlue::drawArc},
- {"native_drawRoundRect","(JLandroid/graphics/RectF;FFJ)V",
+ {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V",
(void*) SkCanvasGlue::drawRoundRect},
- {"native_drawPath","(JJJ)V", (void*) SkCanvasGlue::drawPath},
- {"native_drawBitmap","(JJFFJIII)V",
+ {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath},
+ {"native_drawBitmap","(IIFFIIII)V",
(void*) SkCanvasGlue::drawBitmap__BitmapFFPaint},
- {"native_drawBitmap","(JJLandroid/graphics/Rect;Landroid/graphics/RectF;JII)V",
+ {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/RectF;III)V",
(void*) SkCanvasGlue::drawBitmapRF},
- {"native_drawBitmap","(JJLandroid/graphics/Rect;Landroid/graphics/Rect;JII)V",
+ {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/Rect;III)V",
(void*) SkCanvasGlue::drawBitmapRR},
- {"native_drawBitmap", "(J[IIIFFIIZJ)V",
+ {"native_drawBitmap", "(I[IIIFFIIZI)V",
(void*)SkCanvasGlue::drawBitmapArray},
- {"nativeDrawBitmapMatrix", "(JJJJ)V",
+ {"nativeDrawBitmapMatrix", "(IIII)V",
(void*)SkCanvasGlue::drawBitmapMatrix},
- {"nativeDrawBitmapMesh", "(JJII[FI[IIJ)V",
+ {"nativeDrawBitmapMesh", "(IIII[FI[III)V",
(void*)SkCanvasGlue::drawBitmapMesh},
- {"nativeDrawVertices", "(JII[FI[FI[II[SIIJ)V",
+ {"nativeDrawVertices", "(III[FI[FI[II[SIII)V",
(void*)SkCanvasGlue::drawVertices},
- {"native_drawText","(J[CIIFFIJJ)V",
+ {"native_drawText","(I[CIIFFIII)V",
(void*) SkCanvasGlue::drawText___CIIFFIPaintTypeface},
- {"native_drawText","(JLjava/lang/String;IIFFIJJ)V",
+ {"native_drawText","(ILjava/lang/String;IIFFIII)V",
(void*) SkCanvasGlue::drawText__StringIIFFIPaintTypeface},
- {"native_drawTextRun","(J[CIIIIFFIJJ)V",
+ {"native_drawTextRun","(I[CIIIIFFIII)V",
(void*) SkCanvasGlue::drawTextRun___CIIIIFFIPaintTypeface},
- {"native_drawTextRun","(JLjava/lang/String;IIIIFFIJJ)V",
+ {"native_drawTextRun","(ILjava/lang/String;IIIIFFIII)V",
(void*) SkCanvasGlue::drawTextRun__StringIIIIFFIPaintTypeface},
- {"native_drawPosText","(J[CII[FJ)V",
+ {"native_drawPosText","(I[CII[FI)V",
(void*) SkCanvasGlue::drawPosText___CII_FPaint},
- {"native_drawPosText","(JLjava/lang/String;[FJ)V",
+ {"native_drawPosText","(ILjava/lang/String;[FI)V",
(void*) SkCanvasGlue::drawPosText__String_FPaint},
- {"native_drawTextOnPath","(J[CIIJFFIJ)V",
+ {"native_drawTextOnPath","(I[CIIIFFII)V",
(void*) SkCanvasGlue::drawTextOnPath___CIIPathFFPaint},
- {"native_drawTextOnPath","(JLjava/lang/String;JFFIJ)V",
+ {"native_drawTextOnPath","(ILjava/lang/String;IFFII)V",
(void*) SkCanvasGlue::drawTextOnPath__StringPathFFPaint},
{"freeCaches", "()V", (void*) SkCanvasGlue::freeCaches},
int result;
REG(env, "android/graphics/Canvas", gCanvasMethods);
-
+
return result;
}
class SkColorFilterGlue {
public:
- static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong fHandle) {
- SkColorFilter* obj = reinterpret_cast<SkColorFilter *>(objHandle);
- SkiaColorFilter* f = reinterpret_cast<SkiaColorFilter *>(fHandle);
+ static void finalizer(JNIEnv* env, jobject clazz, SkColorFilter* obj, SkiaColorFilter* f) {
if (obj) SkSafeUnref(obj);
// f == NULL when not !USE_OPENGL_RENDERER, so no need to delete outside the ifdef
#ifdef USE_OPENGL_RENDERER
#endif
}
- static jlong glCreatePorterDuffFilter(JNIEnv* env, jobject, jlong skFilterHandle,
- jint srcColor, jint modeHandle) {
- SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
- SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle);
+ static SkiaColorFilter* glCreatePorterDuffFilter(JNIEnv* env, jobject, SkColorFilter *skFilter,
+ jint srcColor, SkPorterDuff::Mode mode) {
#ifdef USE_OPENGL_RENDERER
- return reinterpret_cast<jlong>(new SkiaBlendFilter(skFilter, srcColor, SkPorterDuff::ToXfermodeMode(mode)));
+ return new SkiaBlendFilter(skFilter, srcColor, SkPorterDuff::ToXfermodeMode(mode));
#else
return NULL;
#endif
}
- static jlong glCreateLightingFilter(JNIEnv* env, jobject, jlong skFilterHandle,
+ static SkiaColorFilter* glCreateLightingFilter(JNIEnv* env, jobject, SkColorFilter *skFilter,
jint mul, jint add) {
- SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
#ifdef USE_OPENGL_RENDERER
- return reinterpret_cast<jlong>(new SkiaLightingFilter(skFilter, mul, add));
+ return new SkiaLightingFilter(skFilter, mul, add);
#else
return NULL;
#endif
}
- static jlong glCreateColorMatrixFilter(JNIEnv* env, jobject, jlong skFilterHandle,
+ static SkiaColorFilter* glCreateColorMatrixFilter(JNIEnv* env, jobject, SkColorFilter *skFilter,
jfloatArray jarray) {
- SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
#ifdef USE_OPENGL_RENDERER
AutoJavaFloatArray autoArray(env, jarray, 20);
const float* src = autoArray.ptr();
colorVector[2] = src[14];
colorVector[3] = src[19];
- return reinterpret_cast<jlong>(new SkiaColorMatrixFilter(skFilter, colorMatrix, colorVector));
+ return new SkiaColorMatrixFilter(skFilter, colorMatrix, colorVector);
#else
return NULL;
#endif
}
- static jlong CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor,
- jint modeHandle) {
- SkPorterDuff::Mode mode = (SkPorterDuff::Mode) modeHandle;
- return reinterpret_cast<jlong>(SkColorFilter::CreateModeFilter(srcColor, SkPorterDuff::ToXfermodeMode(mode)));
+ static SkColorFilter* CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor,
+ SkPorterDuff::Mode mode) {
+ return SkColorFilter::CreateModeFilter(srcColor, SkPorterDuff::ToXfermodeMode(mode));
}
- static jlong CreateLightingFilter(JNIEnv* env, jobject, jint mul, jint add) {
- return reinterpret_cast<jlong>(SkColorFilter::CreateLightingFilter(mul, add));
+ static SkColorFilter* CreateLightingFilter(JNIEnv* env, jobject, jint mul, jint add) {
+ return SkColorFilter::CreateLightingFilter(mul, add);
}
- static jlong CreateColorMatrixFilter(JNIEnv* env, jobject, jfloatArray jarray) {
+ static SkColorFilter* CreateColorMatrixFilter(JNIEnv* env, jobject, jfloatArray jarray) {
AutoJavaFloatArray autoArray(env, jarray, 20);
const float* src = autoArray.ptr();
for (int i = 0; i < 20; i++) {
array[i] = SkFloatToScalar(src[i]);
}
- return reinterpret_cast<jlong>(new SkColorMatrixFilter(array));
+ return new SkColorMatrixFilter(array);
#else
- return reinterpret_cast<jlong>(new SkColorMatrixFilter(src));
+ return new SkColorMatrixFilter(src);
#endif
}
};
static JNINativeMethod colorfilter_methods[] = {
- {"destroyFilter", "(JJ)V", (void*) SkColorFilterGlue::finalizer}
+ {"destroyFilter", "(II)V", (void*) SkColorFilterGlue::finalizer}
};
static JNINativeMethod porterduff_methods[] = {
- { "native_CreatePorterDuffFilter", "(II)J", (void*) SkColorFilterGlue::CreatePorterDuffFilter },
- { "nCreatePorterDuffFilter", "(JII)J", (void*) SkColorFilterGlue::glCreatePorterDuffFilter }
+ { "native_CreatePorterDuffFilter", "(II)I", (void*) SkColorFilterGlue::CreatePorterDuffFilter },
+ { "nCreatePorterDuffFilter", "(III)I", (void*) SkColorFilterGlue::glCreatePorterDuffFilter }
};
static JNINativeMethod lighting_methods[] = {
- { "native_CreateLightingFilter", "(II)J", (void*) SkColorFilterGlue::CreateLightingFilter },
- { "nCreateLightingFilter", "(JII)J", (void*) SkColorFilterGlue::glCreateLightingFilter },
+ { "native_CreateLightingFilter", "(II)I", (void*) SkColorFilterGlue::CreateLightingFilter },
+ { "nCreateLightingFilter", "(III)I", (void*) SkColorFilterGlue::glCreateLightingFilter },
};
static JNINativeMethod colormatrix_methods[] = {
- { "nativeColorMatrixFilter", "([F)J", (void*) SkColorFilterGlue::CreateColorMatrixFilter },
- { "nColorMatrixFilter", "(J[F)J", (void*) SkColorFilterGlue::glCreateColorMatrixFilter }
+ { "nativeColorMatrixFilter", "([F)I", (void*) SkColorFilterGlue::CreateColorMatrixFilter },
+ { "nColorMatrixFilter", "(I[F)I", (void*) SkColorFilterGlue::glCreateColorMatrixFilter }
};
#define REG(env, name, array) \
class SkDrawFilterGlue {
public:
- static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkDrawFilter* obj = reinterpret_cast<SkDrawFilter*>(objHandle);
+ static void finalizer(JNIEnv* env, jobject clazz, SkDrawFilter* obj) {
SkSafeUnref(obj);
}
- static jlong CreatePaintFlagsDF(JNIEnv* env, jobject clazz,
- jint clearFlags, jint setFlags) {
+ static SkDrawFilter* CreatePaintFlagsDF(JNIEnv* env, jobject clazz,
+ int clearFlags, int setFlags) {
// trim off any out-of-range bits
clearFlags &= SkPaint::kAllFlags;
setFlags &= SkPaint::kAllFlags;
if (clearFlags | setFlags) {
- SkDrawFilter* filter = new SkPaintFlagsDrawFilter(clearFlags, setFlags);
- return reinterpret_cast<jlong>(filter);
+ return new SkPaintFlagsDrawFilter(clearFlags, setFlags);
} else {
return NULL;
}
};
static JNINativeMethod drawfilter_methods[] = {
- {"nativeDestructor", "(J)V", (void*) SkDrawFilterGlue::finalizer}
+ {"nativeDestructor", "(I)V", (void*) SkDrawFilterGlue::finalizer}
};
static JNINativeMethod paintflags_methods[] = {
- {"nativeConstructor","(II)J", (void*) SkDrawFilterGlue::CreatePaintFlagsDF}
+ {"nativeConstructor","(II)I", (void*) SkDrawFilterGlue::CreatePaintFlagsDF}
};
#define REG(env, name, array) \
SkASSERT(env);
SkASSERT(bitmap);
SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));
- jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativeInstanceID);
- SkBitmap* b = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ SkBitmap* b = (SkBitmap*)env->GetIntField(bitmap, gBitmap_nativeInstanceID);
SkASSERT(b);
return b;
}
SkASSERT(env);
SkASSERT(canvas);
SkASSERT(env->IsInstanceOf(canvas, gCanvas_class));
- jlong canvasHandle = env->GetLongField(canvas, gCanvas_nativeInstanceID);
- SkCanvas* c = reinterpret_cast<SkCanvas*>(canvasHandle);
+ SkCanvas* c = (SkCanvas*)env->GetIntField(canvas, gCanvas_nativeInstanceID);
SkASSERT(c);
return c;
}
SkASSERT(env);
SkASSERT(paint);
SkASSERT(env->IsInstanceOf(paint, gPaint_class));
- jlong paintHandle = env->GetLongField(paint, gPaint_nativeInstanceID);
- SkPaint* p = reinterpret_cast<SkPaint*>(paintHandle);
+ SkPaint* p = (SkPaint*)env->GetIntField(paint, gPaint_nativeInstanceID);
SkASSERT(p);
return p;
}
SkASSERT(env);
SkASSERT(picture);
SkASSERT(env->IsInstanceOf(picture, gPicture_class));
- jlong pictureHandle = env->GetLongField(picture, gPicture_nativeInstanceID);
- SkPicture* p = reinterpret_cast<SkPicture*>(pictureHandle);
+ SkPicture* p = (SkPicture*)env->GetIntField(picture, gPicture_nativeInstanceID);
SkASSERT(p);
return p;
}
SkASSERT(env);
SkASSERT(region);
SkASSERT(env->IsInstanceOf(region, gRegion_class));
- jlong regionHandle = env->GetLongField(region, gRegion_nativeInstanceID);
- SkRegion* r = reinterpret_cast<SkRegion*>(regionHandle);
+ SkRegion* r = (SkRegion*)env->GetIntField(region, gRegion_nativeInstanceID);
SkASSERT(r);
return r;
}
assert_premultiplied(*bitmap, isPremultiplied);
jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID,
- reinterpret_cast<jlong>(bitmap), buffer,
+ static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap)), buffer,
bitmap->width(), bitmap->height(), density, isMutable, isPremultiplied,
ninepatch, layoutbounds);
hasException(env); // For the side effect of logging.
{
SkASSERT(region != NULL);
jobject obj = env->NewObject(gRegion_class, gRegion_constructorMethodID,
- reinterpret_cast<jlong>(region), 0);
+ static_cast<jint>(reinterpret_cast<uintptr_t>(region)), 0);
hasException(env); // For the side effect of logging.
return obj;
}
gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F");
gBitmap_class = make_globalref(env, "android/graphics/Bitmap");
- gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "J");
- gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(J[BIIIZZ[B[I)V");
+ gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "I");
+ gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(I[BIIIZZ[B[I)V");
gBitmap_reinitMethodID = env->GetMethodID(gBitmap_class, "reinit", "(IIZ)V");
gBitmap_getAllocationByteCountMethodID = env->GetMethodID(gBitmap_class, "getAllocationByteCount", "()I");
gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder");
"nativeInt", "I");
gCanvas_class = make_globalref(env, "android/graphics/Canvas");
- gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "J");
+ gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "I");
gPaint_class = make_globalref(env, "android/graphics/Paint");
- gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "J");
+ gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "I");
gPicture_class = make_globalref(env, "android/graphics/Picture");
- gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "J");
+ gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "I");
gRegion_class = make_globalref(env, "android/graphics/Region");
- gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "J");
+ gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "I");
gRegion_constructorMethodID = env->GetMethodID(gRegion_class, "<init>",
- "(JI)V");
+ "(II)V");
c = env->FindClass("java/lang/Byte");
gByte_class = (jclass) env->NewGlobalRef(
class SkLayerRasterizerGlue {
public:
- static jlong create(JNIEnv* env, jobject) {
- return reinterpret_cast<jlong>(new SkLayerRasterizer());
+ static SkRasterizer* create(JNIEnv* env, jobject) {
+ return new SkLayerRasterizer();
}
- static void addLayer(JNIEnv* env, jobject, jlong layerHandle, jlong paintHandle, jfloat dx, jfloat dy) {
- SkLayerRasterizer* layer = reinterpret_cast<SkLayerRasterizer *>(layerHandle);
- const SkPaint* paint = reinterpret_cast<SkPaint *>(paintHandle);
+ static void addLayer(JNIEnv* env, jobject, SkLayerRasterizer* layer, const SkPaint* paint, float dx, float dy) {
SkASSERT(layer);
SkASSERT(paint);
layer->addLayer(*paint, SkFloatToScalar(dx), SkFloatToScalar(dy));
#include <android_runtime/AndroidRuntime.h>
static JNINativeMethod gLayerRasterizerMethods[] = {
- { "nativeConstructor", "()J", (void*)SkLayerRasterizerGlue::create },
- { "nativeAddLayer", "(JJFF)V", (void*)SkLayerRasterizerGlue::addLayer }
+ { "nativeConstructor", "()I", (void*)SkLayerRasterizerGlue::create },
+ { "nativeAddLayer", "(IIFF)V", (void*)SkLayerRasterizerGlue::addLayer }
};
int register_android_graphics_LayerRasterizer(JNIEnv* env)
class SkMaskFilterGlue {
public:
- static void destructor(JNIEnv* env, jobject, jlong filterHandle) {
- SkMaskFilter* filter = reinterpret_cast<SkMaskFilter *>(filterHandle);
+ static void destructor(JNIEnv* env, jobject, SkMaskFilter* filter) {
SkSafeUnref(filter);
}
- static jlong createBlur(JNIEnv* env, jobject, jfloat radius, jint blurStyle) {
+ static SkMaskFilter* createBlur(JNIEnv* env, jobject, float radius, int blurStyle) {
SkMaskFilter* filter = SkBlurMaskFilter::Create(SkFloatToScalar(radius),
(SkBlurMaskFilter::BlurStyle)blurStyle);
ThrowIAE_IfNull(env, filter);
- return reinterpret_cast<jlong>(filter);
+ return filter;
}
- static jlong createEmboss(JNIEnv* env, jobject, jfloatArray dirArray, jfloat ambient, jfloat specular, jfloat radius) {
+ static SkMaskFilter* createEmboss(JNIEnv* env, jobject, jfloatArray dirArray, float ambient, float specular, float radius) {
SkScalar direction[3];
AutoJavaFloatArray autoDir(env, dirArray, 3);
SkFloatToScalar(specular),
SkFloatToScalar(radius));
ThrowIAE_IfNull(env, filter);
- return reinterpret_cast<jlong>(filter);
+ return filter;
}
- static jlong createTable(JNIEnv* env, jobject, jbyteArray jtable) {
+ static SkMaskFilter* createTable(JNIEnv* env, jobject, jbyteArray jtable) {
AutoJavaByteArray autoTable(env, jtable, 256);
- SkMaskFilter* filter = new SkTableMaskFilter((const uint8_t*)autoTable.ptr());
- return reinterpret_cast<jlong>(filter);
+ return new SkTableMaskFilter((const uint8_t*)autoTable.ptr());
}
- static jlong createClipTable(JNIEnv* env, jobject, jint min, jint max) {
- SkMaskFilter* filter = SkTableMaskFilter::CreateClip(min, max);
- return reinterpret_cast<jlong>(filter);
+ static SkMaskFilter* createClipTable(JNIEnv* env, jobject, int min, int max) {
+ return SkTableMaskFilter::CreateClip(min, max);
}
- static jlong createGammaTable(JNIEnv* env, jobject, jfloat gamma) {
- SkMaskFilter* filter = SkTableMaskFilter::CreateGamma(gamma);
- return reinterpret_cast<jlong>(filter);
+ static SkMaskFilter* createGammaTable(JNIEnv* env, jobject, float gamma) {
+ return SkTableMaskFilter::CreateGamma(gamma);
}
};
static JNINativeMethod gMaskFilterMethods[] = {
- { "nativeDestructor", "(J)V", (void*)SkMaskFilterGlue::destructor }
+ { "nativeDestructor", "(I)V", (void*)SkMaskFilterGlue::destructor }
};
static JNINativeMethod gBlurMaskFilterMethods[] = {
- { "nativeConstructor", "(FI)J", (void*)SkMaskFilterGlue::createBlur }
+ { "nativeConstructor", "(FI)I", (void*)SkMaskFilterGlue::createBlur }
};
static JNINativeMethod gEmbossMaskFilterMethods[] = {
- { "nativeConstructor", "([FFFF)J", (void*)SkMaskFilterGlue::createEmboss }
+ { "nativeConstructor", "([FFFF)I", (void*)SkMaskFilterGlue::createEmboss }
};
static JNINativeMethod gTableMaskFilterMethods[] = {
- { "nativeNewTable", "([B)J", (void*)SkMaskFilterGlue::createTable },
- { "nativeNewClip", "(II)J", (void*)SkMaskFilterGlue::createClipTable },
- { "nativeNewGamma", "(F)J", (void*)SkMaskFilterGlue::createGammaTable }
+ { "nativeNewTable", "([B)I", (void*)SkMaskFilterGlue::createTable },
+ { "nativeNewClip", "(II)I", (void*)SkMaskFilterGlue::createClipTable },
+ { "nativeNewGamma", "(F)I", (void*)SkMaskFilterGlue::createGammaTable }
};
#include <android_runtime/AndroidRuntime.h>
class SkMatrixGlue {
public:
- static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+ static void finalizer(JNIEnv* env, jobject clazz, SkMatrix* obj) {
delete obj;
}
- static jlong create(JNIEnv* env, jobject clazz, jlong srcHandle) {
- const SkMatrix* src = reinterpret_cast<SkMatrix*>(srcHandle);
+ static SkMatrix* create(JNIEnv* env, jobject clazz, const SkMatrix* src) {
SkMatrix* obj = new SkMatrix();
if (src)
*obj = *src;
else
obj->reset();
- return reinterpret_cast<jlong>(obj);
+ return obj;
}
-
- static jboolean isIdentity(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
- return obj->isIdentity() ? JNI_TRUE : JNI_FALSE;
+
+ static jboolean isIdentity(JNIEnv* env, jobject clazz, SkMatrix* obj) {
+ return obj->isIdentity();
}
- static jboolean rectStaysRect(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
- return obj->rectStaysRect() ? JNI_TRUE : JNI_FALSE;
+
+ static jboolean rectStaysRect(JNIEnv* env, jobject clazz, SkMatrix* obj) {
+ return obj->rectStaysRect();
}
- static void reset(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void reset(JNIEnv* env, jobject clazz, SkMatrix* obj) {
obj->reset();
}
- static void set(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
- SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle);
+
+ static void set(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) {
*obj = *other;
}
- static void setTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
obj->setTranslate(dx_, dy_);
}
- static void setScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) {
SkScalar sx_ = SkFloatToScalar(sx);
SkScalar sy_ = SkFloatToScalar(sy);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
obj->setScale(sx_, sy_, px_, py_);
}
- static void setScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) {
SkScalar sx_ = SkFloatToScalar(sx);
SkScalar sy_ = SkFloatToScalar(sy);
obj->setScale(sx_, sy_);
}
- static void setRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) {
SkScalar degrees_ = SkFloatToScalar(degrees);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
obj->setRotate(degrees_, px_, py_);
}
- static void setRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) {
SkScalar degrees_ = SkFloatToScalar(degrees);
obj->setRotate(degrees_);
}
- static void setSinCos__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setSinCos__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) {
SkScalar sinValue_ = SkFloatToScalar(sinValue);
SkScalar cosValue_ = SkFloatToScalar(cosValue);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
obj->setSinCos(sinValue_, cosValue_, px_, py_);
}
- static void setSinCos__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setSinCos__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue) {
SkScalar sinValue_ = SkFloatToScalar(sinValue);
SkScalar cosValue_ = SkFloatToScalar(cosValue);
obj->setSinCos(sinValue_, cosValue_);
}
- static void setSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) {
SkScalar kx_ = SkFloatToScalar(kx);
SkScalar ky_ = SkFloatToScalar(ky);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
obj->setSkew(kx_, ky_, px_, py_);
}
- static void setSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static void setSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) {
SkScalar kx_ = SkFloatToScalar(kx);
SkScalar ky_ = SkFloatToScalar(ky);
obj->setSkew(kx_, ky_);
}
- static jboolean setConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong aHandle, jlong bHandle) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
- SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle);
- SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle);
- return obj->setConcat(*a, *b) ? JNI_TRUE : JNI_FALSE;
+
+ static jboolean setConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* a, SkMatrix* b) {
+ return obj->setConcat(*a, *b);
}
-
- static jboolean preTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean preTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
- return obj->preTranslate(dx_, dy_) ? JNI_TRUE : JNI_FALSE;
+ return obj->preTranslate(dx_, dy_);
}
-
- static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) {
SkScalar sx_ = SkFloatToScalar(sx);
SkScalar sy_ = SkFloatToScalar(sy);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
- return obj->preScale(sx_, sy_, px_, py_) ? JNI_TRUE : JNI_FALSE;
+ return obj->preScale(sx_, sy_, px_, py_);
}
-
- static jboolean preScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean preScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) {
SkScalar sx_ = SkFloatToScalar(sx);
SkScalar sy_ = SkFloatToScalar(sy);
- return obj->preScale(sx_, sy_) ? JNI_TRUE : JNI_FALSE;
+ return obj->preScale(sx_, sy_);
}
-
- static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) {
SkScalar degrees_ = SkFloatToScalar(degrees);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
- return obj->preRotate(degrees_, px_, py_) ? JNI_TRUE : JNI_FALSE;
+ return obj->preRotate(degrees_, px_, py_);
}
-
- static jboolean preRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean preRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) {
SkScalar degrees_ = SkFloatToScalar(degrees);
- return obj->preRotate(degrees_) ? JNI_TRUE : JNI_FALSE;
+ return obj->preRotate(degrees_);
}
-
- static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) {
SkScalar kx_ = SkFloatToScalar(kx);
SkScalar ky_ = SkFloatToScalar(ky);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
- return obj->preSkew(kx_, ky_, px_, py_) ? JNI_TRUE : JNI_FALSE;
+ return obj->preSkew(kx_, ky_, px_, py_);
}
-
- static jboolean preSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean preSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) {
SkScalar kx_ = SkFloatToScalar(kx);
SkScalar ky_ = SkFloatToScalar(ky);
- return obj->preSkew(kx_, ky_) ? JNI_TRUE : JNI_FALSE;
+ return obj->preSkew(kx_, ky_);
}
-
- static jboolean preConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
- SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle);
- return obj->preConcat(*other) ? JNI_TRUE : JNI_FALSE;
+
+ static jboolean preConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) {
+ return obj->preConcat(*other);
}
-
- static jboolean postTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean postTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
- return obj->postTranslate(dx_, dy_) ? JNI_TRUE : JNI_FALSE;
+ return obj->postTranslate(dx_, dy_);
}
-
- static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) {
SkScalar sx_ = SkFloatToScalar(sx);
SkScalar sy_ = SkFloatToScalar(sy);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
- return obj->postScale(sx_, sy_, px_, py_) ? JNI_TRUE : JNI_FALSE;
+ return obj->postScale(sx_, sy_, px_, py_);
}
-
- static jboolean postScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean postScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) {
SkScalar sx_ = SkFloatToScalar(sx);
SkScalar sy_ = SkFloatToScalar(sy);
- return obj->postScale(sx_, sy_) ? JNI_TRUE : JNI_FALSE;
+ return obj->postScale(sx_, sy_);
}
-
- static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) {
SkScalar degrees_ = SkFloatToScalar(degrees);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
- return obj->postRotate(degrees_, px_, py_) ? JNI_TRUE : JNI_FALSE;
+ return obj->postRotate(degrees_, px_, py_);
}
-
- static jboolean postRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean postRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) {
SkScalar degrees_ = SkFloatToScalar(degrees);
- return obj->postRotate(degrees_) ? JNI_TRUE : JNI_FALSE;
+ return obj->postRotate(degrees_);
}
-
- static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
- SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
+
+ static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) {
SkScalar kx_ = SkFloatToScalar(kx);
SkScalar ky_ = SkFloatToScalar(ky);
SkScalar px_ = SkFloatToScalar(px);
SkScalar py_ = SkFloatToScalar(py);
- return obj->postSkew(kx_, ky_, px_, py_) ? JNI_TRUE : JNI_FALSE;
+ return obj->postSkew(kx_, ky_, px_, py_);
}
-
- static jboolean postSkew__FF(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat kx, jfloat ky) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+
+ static jboolean postSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat kx, jfloat ky) {
SkScalar kx_ = SkFloatToScalar(kx);
SkScalar ky_ = SkFloatToScalar(ky);
- return matrix->postSkew(kx_, ky_) ? JNI_TRUE : JNI_FALSE;
+ return matrix->postSkew(kx_, ky_);
}
-
- static jboolean postConcat(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong otherHandle) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
- SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle);
- return matrix->postConcat(*other) ? JNI_TRUE : JNI_FALSE;
+
+ static jboolean postConcat(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* other) {
+ return matrix->postConcat(*other);
}
-
- static jboolean setRectToRect(JNIEnv* env, jobject clazz, jlong matrixHandle, jobject src, jobject dst, jint stfHandle) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
- SkMatrix::ScaleToFit stf = static_cast<SkMatrix::ScaleToFit>(stfHandle);
+
+ static jboolean setRectToRect(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobject src, jobject dst, SkMatrix::ScaleToFit stf) {
SkRect src_;
GraphicsJNI::jrectf_to_rect(env, src, &src_);
SkRect dst_;
GraphicsJNI::jrectf_to_rect(env, dst, &dst_);
- return matrix->setRectToRect(src_, dst_, stf) ? JNI_TRUE : JNI_FALSE;
+ return matrix->setRectToRect(src_, dst_, stf);
}
-
- static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, jlong matrixHandle,
- jfloatArray jsrc, jint srcIndex,
- jfloatArray jdst, jint dstIndex, jint ptCount) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+
+ static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, SkMatrix* matrix,
+ jfloatArray jsrc, int srcIndex,
+ jfloatArray jdst, int dstIndex, int ptCount) {
SkASSERT(srcIndex >= 0);
SkASSERT(dstIndex >= 0);
SkASSERT((unsigned)ptCount <= 4);
AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1));
float* src = autoSrc.ptr() + srcIndex;
float* dst = autoDst.ptr() + dstIndex;
- bool result;
#ifdef SK_SCALAR_IS_FIXED
SkPoint srcPt[4], dstPt[4];
srcPt[i].set(SkFloatToScalar(src[x]), SkFloatToScalar(src[y]));
dstPt[i].set(SkFloatToScalar(dst[x]), SkFloatToScalar(dst[y]));
}
- result = matrix->setPolyToPoly(srcPt, dstPt, ptCount);
+ return matrix->setPolyToPoly(srcPt, dstPt, ptCount);
#else
- result = matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst,
+ return matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst,
ptCount);
#endif
- return result ? JNI_TRUE : JNI_FALSE;
}
-
- static jboolean invert(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong inverseHandle) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
- SkMatrix* inverse = reinterpret_cast<SkMatrix*>(inverseHandle);
+
+ static jboolean invert(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* inverse) {
return matrix->invert(inverse);
}
-
- static void mapPoints(JNIEnv* env, jobject clazz, jlong matrixHandle,
- jfloatArray dst, jint dstIndex,
- jfloatArray src, jint srcIndex,
- jint ptCount, jboolean isPts) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+
+ static void mapPoints(JNIEnv* env, jobject clazz, SkMatrix* matrix,
+ jfloatArray dst, int dstIndex,
+ jfloatArray src, int srcIndex,
+ int ptCount, bool isPts) {
SkASSERT(ptCount >= 0);
AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1));
AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1));
ptCount);
#endif
}
-
- static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, jlong matrixHandle, jobjectArray dst, jobject src) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+
+ static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobjectArray dst, jobject src) {
SkRect dst_, src_;
GraphicsJNI::jrectf_to_rect(env, src, &src_);
jboolean rectStaysRect = matrix->mapRect(&dst_, src_);
GraphicsJNI::rect_to_jrectf(dst_, env, dst);
- return rectStaysRect ? JNI_TRUE : JNI_FALSE;
+ return rectStaysRect;
}
-
- static jfloat mapRadius(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat radius) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
- float result;
- result = SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius)));
- return static_cast<jfloat>(result);
+
+ static jfloat mapRadius(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat radius) {
+ return SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius)));
}
-
- static void getValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+
+ static void getValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) {
AutoJavaFloatArray autoValues(env, values, 9);
float* dst = autoValues.ptr();
}
#endif
}
-
- static void setValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) {
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+
+ static void setValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) {
AutoJavaFloatArray autoValues(env, values, 9);
const float* src = autoValues.ptr();
#endif
}
- static jboolean equals(JNIEnv* env, jobject clazz, jlong aHandle, jlong bHandle) {
- const SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle);
- const SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle);
+ static jboolean equals(JNIEnv* env, jobject clazz, const SkMatrix* a, const SkMatrix* b) {
return *a == *b;
}
};
static JNINativeMethod methods[] = {
- {"finalizer", "(J)V", (void*) SkMatrixGlue::finalizer},
- {"native_create","(J)J", (void*) SkMatrixGlue::create},
- {"native_isIdentity","(J)Z", (void*) SkMatrixGlue::isIdentity},
- {"native_rectStaysRect","(J)Z", (void*) SkMatrixGlue::rectStaysRect},
- {"native_reset","(J)V", (void*) SkMatrixGlue::reset},
- {"native_set","(JJ)V", (void*) SkMatrixGlue::set},
- {"native_setTranslate","(JFF)V", (void*) SkMatrixGlue::setTranslate},
- {"native_setScale","(JFFFF)V", (void*) SkMatrixGlue::setScale__FFFF},
- {"native_setScale","(JFF)V", (void*) SkMatrixGlue::setScale__FF},
- {"native_setRotate","(JFFF)V", (void*) SkMatrixGlue::setRotate__FFF},
- {"native_setRotate","(JF)V", (void*) SkMatrixGlue::setRotate__F},
- {"native_setSinCos","(JFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF},
- {"native_setSinCos","(JFF)V", (void*) SkMatrixGlue::setSinCos__FF},
- {"native_setSkew","(JFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF},
- {"native_setSkew","(JFF)V", (void*) SkMatrixGlue::setSkew__FF},
- {"native_setConcat","(JJJ)Z", (void*) SkMatrixGlue::setConcat},
- {"native_preTranslate","(JFF)Z", (void*) SkMatrixGlue::preTranslate},
- {"native_preScale","(JFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF},
- {"native_preScale","(JFF)Z", (void*) SkMatrixGlue::preScale__FF},
- {"native_preRotate","(JFFF)Z", (void*) SkMatrixGlue::preRotate__FFF},
- {"native_preRotate","(JF)Z", (void*) SkMatrixGlue::preRotate__F},
- {"native_preSkew","(JFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF},
- {"native_preSkew","(JFF)Z", (void*) SkMatrixGlue::preSkew__FF},
- {"native_preConcat","(JJ)Z", (void*) SkMatrixGlue::preConcat},
- {"native_postTranslate","(JFF)Z", (void*) SkMatrixGlue::postTranslate},
- {"native_postScale","(JFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF},
- {"native_postScale","(JFF)Z", (void*) SkMatrixGlue::postScale__FF},
- {"native_postRotate","(JFFF)Z", (void*) SkMatrixGlue::postRotate__FFF},
- {"native_postRotate","(JF)Z", (void*) SkMatrixGlue::postRotate__F},
- {"native_postSkew","(JFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF},
- {"native_postSkew","(JFF)Z", (void*) SkMatrixGlue::postSkew__FF},
- {"native_postConcat","(JJ)Z", (void*) SkMatrixGlue::postConcat},
- {"native_setRectToRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect},
- {"native_setPolyToPoly","(J[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly},
- {"native_invert","(JJ)Z", (void*) SkMatrixGlue::invert},
- {"native_mapPoints","(J[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints},
- {"native_mapRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF},
- {"native_mapRadius","(JF)F", (void*) SkMatrixGlue::mapRadius},
- {"native_getValues","(J[F)V", (void*) SkMatrixGlue::getValues},
- {"native_setValues","(J[F)V", (void*) SkMatrixGlue::setValues},
- {"native_equals", "(JJ)Z", (void*) SkMatrixGlue::equals}
+ {"finalizer", "(I)V", (void*) SkMatrixGlue::finalizer},
+ {"native_create","(I)I", (void*) SkMatrixGlue::create},
+ {"native_isIdentity","(I)Z", (void*) SkMatrixGlue::isIdentity},
+ {"native_rectStaysRect","(I)Z", (void*) SkMatrixGlue::rectStaysRect},
+ {"native_reset","(I)V", (void*) SkMatrixGlue::reset},
+ {"native_set","(II)V", (void*) SkMatrixGlue::set},
+ {"native_setTranslate","(IFF)V", (void*) SkMatrixGlue::setTranslate},
+ {"native_setScale","(IFFFF)V", (void*) SkMatrixGlue::setScale__FFFF},
+ {"native_setScale","(IFF)V", (void*) SkMatrixGlue::setScale__FF},
+ {"native_setRotate","(IFFF)V", (void*) SkMatrixGlue::setRotate__FFF},
+ {"native_setRotate","(IF)V", (void*) SkMatrixGlue::setRotate__F},
+ {"native_setSinCos","(IFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF},
+ {"native_setSinCos","(IFF)V", (void*) SkMatrixGlue::setSinCos__FF},
+ {"native_setSkew","(IFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF},
+ {"native_setSkew","(IFF)V", (void*) SkMatrixGlue::setSkew__FF},
+ {"native_setConcat","(III)Z", (void*) SkMatrixGlue::setConcat},
+ {"native_preTranslate","(IFF)Z", (void*) SkMatrixGlue::preTranslate},
+ {"native_preScale","(IFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF},
+ {"native_preScale","(IFF)Z", (void*) SkMatrixGlue::preScale__FF},
+ {"native_preRotate","(IFFF)Z", (void*) SkMatrixGlue::preRotate__FFF},
+ {"native_preRotate","(IF)Z", (void*) SkMatrixGlue::preRotate__F},
+ {"native_preSkew","(IFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF},
+ {"native_preSkew","(IFF)Z", (void*) SkMatrixGlue::preSkew__FF},
+ {"native_preConcat","(II)Z", (void*) SkMatrixGlue::preConcat},
+ {"native_postTranslate","(IFF)Z", (void*) SkMatrixGlue::postTranslate},
+ {"native_postScale","(IFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF},
+ {"native_postScale","(IFF)Z", (void*) SkMatrixGlue::postScale__FF},
+ {"native_postRotate","(IFFF)Z", (void*) SkMatrixGlue::postRotate__FFF},
+ {"native_postRotate","(IF)Z", (void*) SkMatrixGlue::postRotate__F},
+ {"native_postSkew","(IFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF},
+ {"native_postSkew","(IFF)Z", (void*) SkMatrixGlue::postSkew__FF},
+ {"native_postConcat","(II)Z", (void*) SkMatrixGlue::postConcat},
+ {"native_setRectToRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect},
+ {"native_setPolyToPoly","(I[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly},
+ {"native_invert","(II)Z", (void*) SkMatrixGlue::invert},
+ {"native_mapPoints","(I[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints},
+ {"native_mapRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF},
+ {"native_mapRadius","(IF)F", (void*) SkMatrixGlue::mapRadius},
+ {"native_getValues","(I[F)V", (void*) SkMatrixGlue::getValues},
+ {"native_setValues","(I[F)V", (void*) SkMatrixGlue::setValues},
+ {"native_equals", "(II)Z", (void*) SkMatrixGlue::equals}
};
static jfieldID sNativeInstanceField;
sizeof(methods) / sizeof(methods[0]));
jclass clazz = env->FindClass("android/graphics/Matrix");
- sNativeInstanceField = env->GetFieldID(clazz, "native_instance", "J");
+ sNativeInstanceField = env->GetFieldID(clazz, "native_instance", "I");
return result;
}
SkMatrix* android_graphics_Matrix_getSkMatrix(JNIEnv* env, jobject matrixObj) {
- return reinterpret_cast<SkMatrix*>(env->GetLongField(matrixObj, sNativeInstanceField));
+ return reinterpret_cast<SkMatrix*>(env->GetIntField(matrixObj, sNativeInstanceField));
}
}
public:
static jboolean isNinePatchChunk(JNIEnv* env, jobject, jbyteArray obj) {
if (NULL == obj) {
- return JNI_FALSE;
+ return false;
}
if (env->GetArrayLength(obj) < (int)sizeof(Res_png_9patch)) {
- return JNI_FALSE;
+ return false;
}
const jbyte* array = env->GetByteArrayElements(obj, 0);
if (array != NULL) {
const Res_png_9patch* chunk = reinterpret_cast<const Res_png_9patch*>(array);
int8_t wasDeserialized = chunk->wasDeserialized;
env->ReleaseByteArrayElements(obj, const_cast<jbyte*>(array), JNI_ABORT);
- return (wasDeserialized != -1) ? JNI_TRUE : JNI_FALSE;
+ return wasDeserialized != -1;
}
- return JNI_FALSE;
+ return false;
}
- static jlong validateNinePatchChunk(JNIEnv* env, jobject, jlong, jbyteArray obj) {
+ static int8_t* validateNinePatchChunk(JNIEnv* env, jobject, jint, jbyteArray obj) {
size_t chunkSize = env->GetArrayLength(obj);
if (chunkSize < (int) (sizeof(Res_png_9patch))) {
jniThrowRuntimeException(env, "Array too small for chunk.");
// This call copies the content of the jbyteArray
env->GetByteArrayRegion(obj, 0, chunkSize, reinterpret_cast<jbyte*>(storage));
// Deserialize in place, return the array we just allocated
- return reinterpret_cast<jlong>(Res_png_9patch::deserialize(storage));
+ return (int8_t*) Res_png_9patch::deserialize(storage);
}
- static void finalize(JNIEnv* env, jobject, jlong patchHandle) {
- int8_t* patch = reinterpret_cast<int8_t*>(patchHandle);
+ static void finalize(JNIEnv* env, jobject, int8_t* patch) {
#ifdef USE_OPENGL_RENDERER
if (android::uirenderer::Caches::hasInstance()) {
Res_png_9patch* p = (Res_png_9patch*) patch;
}
}
- static void drawF(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRectF,
- jlong bitmapHandle, jlong chunkHandle, jlong paintHandle,
+ static void drawF(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRectF,
+ const SkBitmap* bitmap, Res_png_9patch* chunk, const SkPaint* paint,
jint destDensity, jint srcDensity) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
- const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
SkASSERT(canvas);
SkASSERT(boundsRectF);
SkASSERT(bitmap);
draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity);
}
- static void drawI(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRect,
- jlong bitmapHandle, jlong chunkHandle, jlong paintHandle,
+ static void drawI(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRect,
+ const SkBitmap* bitmap, Res_png_9patch* chunk, const SkPaint* paint,
jint destDensity, jint srcDensity) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
- const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
SkASSERT(canvas);
SkASSERT(boundsRect);
SkASSERT(bitmap);
draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity);
}
- static jlong getTransparentRegion(JNIEnv* env, jobject, jlong bitmapHandle,
- jlong chunkHandle, jobject boundsRect) {
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
+ static jint getTransparentRegion(JNIEnv* env, jobject, const SkBitmap* bitmap,
+ Res_png_9patch* chunk, jobject boundsRect) {
SkASSERT(bitmap);
SkASSERT(chunk);
SkASSERT(boundsRect);
SkRegion* region = NULL;
NinePatch_Draw(NULL, bounds, *bitmap, *chunk, NULL, ®ion);
- return reinterpret_cast<jlong>(region);
+ return (jint) region;
}
};
static JNINativeMethod gNinePatchMethods[] = {
{ "isNinePatchChunk", "([B)Z", (void*) SkNinePatchGlue::isNinePatchChunk },
- { "validateNinePatchChunk", "(J[B)J", (void*) SkNinePatchGlue::validateNinePatchChunk },
- { "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize },
- { "nativeDraw", "(JLandroid/graphics/RectF;JJJII)V", (void*) SkNinePatchGlue::drawF },
- { "nativeDraw", "(JLandroid/graphics/Rect;JJJII)V", (void*) SkNinePatchGlue::drawI },
- { "nativeGetTransparentRegion", "(JJLandroid/graphics/Rect;)J",
+ { "validateNinePatchChunk", "(I[B)I", (void*) SkNinePatchGlue::validateNinePatchChunk },
+ { "nativeFinalize", "(I)V", (void*) SkNinePatchGlue::finalize },
+ { "nativeDraw", "(ILandroid/graphics/RectF;IIIII)V", (void*) SkNinePatchGlue::drawF },
+ { "nativeDraw", "(ILandroid/graphics/Rect;IIIII)V", (void*) SkNinePatchGlue::drawI },
+ { "nativeGetTransparentRegion", "(IILandroid/graphics/Rect;)I",
(void*) SkNinePatchGlue::getTransparentRegion }
};
AFTER, AT_OR_AFTER, BEFORE, AT_OR_BEFORE, AT
};
- static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
+ static void finalizer(JNIEnv* env, jobject clazz, SkPaint* obj) {
delete obj;
}
- static jlong init(JNIEnv* env, jobject clazz) {
+ static SkPaint* init(JNIEnv* env, jobject clazz) {
SkPaint* obj = new SkPaint();
defaultSettingsForAndroid(obj);
- return reinterpret_cast<jlong>(obj);
+ return obj;
}
- static jlong initWithPaint(JNIEnv* env, jobject clazz, jlong paintHandle) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ static SkPaint* intiWithPaint(JNIEnv* env, jobject clazz, SkPaint* paint) {
SkPaint* obj = new SkPaint(*paint);
- return reinterpret_cast<jlong>(obj);
+ return obj;
}
- static void reset(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
+ static void reset(JNIEnv* env, jobject clazz, SkPaint* obj) {
obj->reset();
defaultSettingsForAndroid(obj);
}
- static void assign(JNIEnv* env, jobject clazz, jlong dstPaintHandle, jlong srcPaintHandle) {
- SkPaint* dst = reinterpret_cast<SkPaint*>(dstPaintHandle);
- const SkPaint* src = reinterpret_cast<SkPaint*>(srcPaintHandle);
+ static void assign(JNIEnv* env, jobject clazz, SkPaint* dst, const SkPaint* src) {
*dst = *src;
}
static jint getFlags(JNIEnv* env, jobject paint) {
NPE_CHECK_RETURN_ZERO(env, paint);
- int result;
- result = GraphicsJNI::getNativePaint(env, paint)->getFlags();
- return static_cast<jint>(result);
+ return GraphicsJNI::getNativePaint(env, paint)->getFlags();
}
static void setFlags(JNIEnv* env, jobject paint, jint flags) {
GraphicsJNI::getNativePaint(env, paint)->setDither(dither);
}
- static jint getStyle(JNIEnv* env, jobject clazz,jlong objHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- return static_cast<jint>(obj->getStyle());
+ static jint getStyle(JNIEnv* env, jobject clazz, SkPaint* obj) {
+ return obj->getStyle();
}
- static void setStyle(JNIEnv* env, jobject clazz, jlong objHandle, jint styleHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkPaint::Style style = static_cast<SkPaint::Style>(styleHandle);
+ static void setStyle(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Style style) {
obj->setStyle(style);
}
static jint getColor(JNIEnv* env, jobject paint) {
NPE_CHECK_RETURN_ZERO(env, paint);
- int color;
- color = GraphicsJNI::getNativePaint(env, paint)->getColor();
- return static_cast<jint>(color);
+ return GraphicsJNI::getNativePaint(env, paint)->getColor();
}
static jint getAlpha(JNIEnv* env, jobject paint) {
NPE_CHECK_RETURN_ZERO(env, paint);
- int alpha;
- alpha = GraphicsJNI::getNativePaint(env, paint)->getAlpha();
- return static_cast<jint>(alpha);
+ return GraphicsJNI::getNativePaint(env, paint)->getAlpha();
}
static void setColor(JNIEnv* env, jobject paint, jint color) {
GraphicsJNI::getNativePaint(env, paint)->setStrokeMiter(SkFloatToScalar(miter));
}
- static jint getStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- return static_cast<jint>(obj->getStrokeCap());
+ static jint getStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj) {
+ return obj->getStrokeCap();
}
- static void setStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle, jint capHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkPaint::Cap cap = static_cast<SkPaint::Cap>(capHandle);
+ static void setStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Cap cap) {
obj->setStrokeCap(cap);
}
- static jint getStrokeJoin(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- return static_cast<jint>(obj->getStrokeJoin());
+ static jint getStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj) {
+ return obj->getStrokeJoin();
}
- static void setStrokeJoin(JNIEnv* env, jobject clazz, jlong objHandle, jint joinHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkPaint::Join join = (SkPaint::Join) joinHandle;
+ static void setStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Join join) {
obj->setStrokeJoin(join);
}
- static jboolean getFillPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong dstHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
- SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
- return obj->getFillPath(*src, dst) ? JNI_TRUE : JNI_FALSE;
+ static jboolean getFillPath(JNIEnv* env, jobject clazz, SkPaint* obj, SkPath* src, SkPath* dst) {
+ return obj->getFillPath(*src, dst);
}
- static jlong setShader(JNIEnv* env, jobject clazz, jlong objHandle, jlong shaderHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
- return reinterpret_cast<jlong>(obj->setShader(shader));
+ static SkShader* setShader(JNIEnv* env, jobject clazz, SkPaint* obj, SkShader* shader) {
+ return obj->setShader(shader);
}
- static jlong setColorFilter(JNIEnv* env, jobject clazz, jlong objHandle, jlong filterHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint *>(objHandle);
- SkColorFilter* filter = reinterpret_cast<SkColorFilter *>(filterHandle);
- return reinterpret_cast<jlong>(obj->setColorFilter(filter));
+ static SkColorFilter* setColorFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkColorFilter* filter) {
+ return obj->setColorFilter(filter);
}
- static jlong setXfermode(JNIEnv* env, jobject clazz, jlong objHandle, jlong xfermodeHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkXfermode* xfermode = reinterpret_cast<SkXfermode*>(xfermodeHandle);
- return reinterpret_cast<jlong>(obj->setXfermode(xfermode));
+ static SkXfermode* setXfermode(JNIEnv* env, jobject clazz, SkPaint* obj, SkXfermode* xfermode) {
+ return obj->setXfermode(xfermode);
}
- static jlong setPathEffect(JNIEnv* env, jobject clazz, jlong objHandle, jlong effectHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkPathEffect* effect = reinterpret_cast<SkPathEffect*>(effectHandle);
- return reinterpret_cast<jlong>(obj->setPathEffect(effect));
+ static SkPathEffect* setPathEffect(JNIEnv* env, jobject clazz, SkPaint* obj, SkPathEffect* effect) {
+ return obj->setPathEffect(effect);
}
- static jlong setMaskFilter(JNIEnv* env, jobject clazz, jlong objHandle, jlong maskfilterHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkMaskFilter* maskfilter = reinterpret_cast<SkMaskFilter*>(maskfilterHandle);
- return reinterpret_cast<jlong>(obj->setMaskFilter(maskfilter));
+ static SkMaskFilter* setMaskFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkMaskFilter* maskfilter) {
+ return obj->setMaskFilter(maskfilter);
}
- static jlong setTypeface(JNIEnv* env, jobject clazz, jlong objHandle, jlong typefaceHandle) {
+ static SkTypeface* setTypeface(JNIEnv* env, jobject clazz, SkPaint* obj, SkTypeface* typeface) {
#ifndef USE_MINIKIN
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkTypeface* typeface = reinterpret_cast<SkTypeface*>(typefaceHandle);
- return reinterpret_cast<jlong>(obj->setTypeface(typeface));
+ return obj->setTypeface(typeface);
#else
// TODO(raph): not yet implemented
return NULL;
#endif
}
- static jlong setRasterizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong rasterizerHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkRasterizer* rasterizer = reinterpret_cast<SkRasterizer*>(rasterizerHandle);
- return reinterpret_cast<jlong>(obj->setRasterizer(rasterizer));
+ static SkRasterizer* setRasterizer(JNIEnv* env, jobject clazz, SkPaint* obj, SkRasterizer* rasterizer) {
+ return obj->setRasterizer(rasterizer);
}
- static jint getTextAlign(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- return static_cast<jint>(obj->getTextAlign());
+ static jint getTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj) {
+ return obj->getTextAlign();
}
- static void setTextAlign(JNIEnv* env, jobject clazz, jlong objHandle, jint alignHandle) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
- SkPaint::Align align = static_cast<SkPaint::Align>(alignHandle);
+ static void setTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Align align) {
obj->setTextAlign(align);
}
output[0] = '\0';
}
- static void setTextLocale(JNIEnv* env, jobject clazz, jlong objHandle, jstring locale) {
- SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle);
+ static void setTextLocale(JNIEnv* env, jobject clazz, SkPaint* obj, jstring locale) {
ScopedUtfChars localeChars(env, locale);
char langTag[ULOC_FULLNAME_CAPACITY];
toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, localeChars.c_str());
return descent - ascent + leading;
}
- static jfloat measureText_CIII(JNIEnv* env, jobject jpaint, jcharArray text, jint index, jint count,
+ static jfloat measureText_CIII(JNIEnv* env, jobject jpaint, jcharArray text, int index, int count,
jint bidiFlags) {
NPE_CHECK_RETURN_ZERO(env, jpaint);
NPE_CHECK_RETURN_ZERO(env, text);
return result;
}
- static jfloat measureText_StringIII(JNIEnv* env, jobject jpaint, jstring text, jint start, jint end,
+ static jfloat measureText_StringIII(JNIEnv* env, jobject jpaint, jstring text, int start, int end,
jint bidiFlags) {
NPE_CHECK_RETURN_ZERO(env, jpaint);
NPE_CHECK_RETURN_ZERO(env, text);
return count;
}
- static jint getTextWidths___CIII_F(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text,
- jint index, jint count, jint bidiFlags, jfloatArray widths) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ static int getTextWidths___CIII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text,
+ int index, int count, jint bidiFlags, jfloatArray widths) {
const jchar* textArray = env->GetCharArrayElements(text, NULL);
count = dotextwidths(env, paint, textArray + index, count, widths, bidiFlags);
env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
return count;
}
- static jint getTextWidths__StringIII_F(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text,
- jint start, jint end, jint bidiFlags, jfloatArray widths) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ static int getTextWidths__StringIII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text,
+ int start, int end, jint bidiFlags, jfloatArray widths) {
const jchar* textArray = env->GetStringChars(text, NULL);
int count = dotextwidths(env, paint, textArray + start, end - start, widths, bidiFlags);
env->ReleaseStringChars(text, textArray);
return glyphsCount;
}
- static jint getTextGlyphs__StringIIIII_C(JNIEnv* env, jobject clazz, jlong paintHandle,
+ static int getTextGlyphs__StringIIIII_C(JNIEnv* env, jobject clazz, SkPaint* paint,
jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint flags,
jcharArray glyphs) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
const jchar* textArray = env->GetStringChars(text, NULL);
int count = doTextGlyphs(env, paint, textArray + contextStart, start - contextStart,
end - start, contextEnd - contextStart, flags, glyphs);
return totalAdvance;
}
- static jfloat getTextRunAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle,
+ static float getTextRunAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, SkPaint* paint,
jcharArray text, jint index, jint count, jint contextIndex, jint contextCount,
jint flags, jfloatArray advances, jint advancesIndex) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
jchar* textArray = env->GetCharArrayElements(text, NULL);
jfloat result = doTextRunAdvances(env, paint, textArray + contextIndex,
index - contextIndex, count, contextCount, flags, advances, advancesIndex);
return result;
}
- static jfloat getTextRunAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle,
+ static float getTextRunAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, SkPaint* paint,
jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint flags,
jfloatArray advances, jint advancesIndex) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
const jchar* textArray = env->GetStringChars(text, NULL);
jfloat result = doTextRunAdvances(env, paint, textArray + contextStart,
start - contextStart, end - start, contextEnd - contextStart, flags,
return pos;
}
- static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text,
+ static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text,
jint contextStart, jint contextCount, jint flags, jint offset, jint cursorOpt) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
jchar* textArray = env->GetCharArrayElements(text, NULL);
jint result = doTextRunCursor(env, paint, textArray, contextStart, contextCount, flags,
offset, cursorOpt);
return result;
}
- static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text,
+ static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text,
jint contextStart, jint contextEnd, jint flags, jint offset, jint cursorOpt) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
const jchar* textArray = env->GetStringChars(text, NULL);
jint result = doTextRunCursor(env, paint, textArray, contextStart,
contextEnd - contextStart, flags, offset, cursorOpt);
TextLayout::getTextPath(paint, text, count, bidiFlags, x, y, path);
}
- static void getTextPath___C(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags,
- jcharArray text, jint index, jint count, jfloat x, jfloat y, jlong pathHandle) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
- SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
+ static void getTextPath___C(JNIEnv* env, jobject clazz, SkPaint* paint, jint bidiFlags,
+ jcharArray text, int index, int count, jfloat x, jfloat y, SkPath* path) {
const jchar* textArray = env->GetCharArrayElements(text, NULL);
getTextPath(env, paint, textArray + index, count, bidiFlags, x, y, path);
env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), JNI_ABORT);
}
- static void getTextPath__String(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags,
- jstring text, jint start, jint end, jfloat x, jfloat y, jlong pathHandle) {
- SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
- SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
+ static void getTextPath__String(JNIEnv* env, jobject clazz, SkPaint* paint, jint bidiFlags,
+ jstring text, int start, int end, jfloat x, jfloat y, SkPath* path) {
const jchar* textArray = env->GetStringChars(text, NULL);
getTextPath(env, paint, textArray + start, end - start, bidiFlags, x, y, path);
env->ReleaseStringChars(text, textArray);
}
static void setShadowLayer(JNIEnv* env, jobject jpaint, jfloat radius,
- jfloat dx, jfloat dy, jint color) {
+ jfloat dx, jfloat dy, int color) {
NPE_CHECK_RETURN_VOID(env, jpaint);
SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);
return bytes >> 1;
}
- static jint breakTextC(JNIEnv* env, jobject jpaint, jcharArray jtext,
- jint index, jint count, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) {
+ static int breakTextC(JNIEnv* env, jobject jpaint, jcharArray jtext,
+ int index, int count, float maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) {
NPE_CHECK_RETURN_ZERO(env, jpaint);
NPE_CHECK_RETURN_ZERO(env, jtext);
return count;
}
- static jint breakTextS(JNIEnv* env, jobject jpaint, jstring jtext,
- jboolean forwards, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) {
+ static int breakTextS(JNIEnv* env, jobject jpaint, jstring jtext,
+ bool forwards, float maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) {
NPE_CHECK_RETURN_ZERO(env, jpaint);
NPE_CHECK_RETURN_ZERO(env, jtext);
GraphicsJNI::irect_to_jrect(ir, env, bounds);
}
- static void getStringBounds(JNIEnv* env, jobject, jlong paintHandle,
- jstring text, jint start, jint end, jint bidiFlags, jobject bounds) {
- const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);;
+ static void getStringBounds(JNIEnv* env, jobject, const SkPaint* paint,
+ jstring text, int start, int end, jint bidiFlags, jobject bounds) {
const jchar* textArray = env->GetStringChars(text, NULL);
doTextBounds(env, textArray + start, end - start, bounds, *paint, bidiFlags);
env->ReleaseStringChars(text, textArray);
}
- static void getCharArrayBounds(JNIEnv* env, jobject, jlong paintHandle,
- jcharArray text, jint index, jint count, jint bidiFlags, jobject bounds) {
- const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ static void getCharArrayBounds(JNIEnv* env, jobject, const SkPaint* paint,
+ jcharArray text, int index, int count, jint bidiFlags, jobject bounds) {
const jchar* textArray = env->GetCharArrayElements(text, NULL);
doTextBounds(env, textArray + index, count, bounds, *paint, bidiFlags);
env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
};
static JNINativeMethod methods[] = {
- {"finalizer", "(J)V", (void*) SkPaintGlue::finalizer},
- {"native_init","()J", (void*) SkPaintGlue::init},
- {"native_initWithPaint","(J)J", (void*) SkPaintGlue::initWithPaint},
- {"native_reset","(J)V", (void*) SkPaintGlue::reset},
- {"native_set","(JJ)V", (void*) SkPaintGlue::assign},
+ {"finalizer", "(I)V", (void*) SkPaintGlue::finalizer},
+ {"native_init","()I", (void*) SkPaintGlue::init},
+ {"native_initWithPaint","(I)I", (void*) SkPaintGlue::intiWithPaint},
+ {"native_reset","(I)V", (void*) SkPaintGlue::reset},
+ {"native_set","(II)V", (void*) SkPaintGlue::assign},
{"getFlags","()I", (void*) SkPaintGlue::getFlags},
{"setFlags","(I)V", (void*) SkPaintGlue::setFlags},
{"getHinting","()I", (void*) SkPaintGlue::getHinting},
{"setFakeBoldText","(Z)V", (void*) SkPaintGlue::setFakeBoldText},
{"setFilterBitmap","(Z)V", (void*) SkPaintGlue::setFilterBitmap},
{"setDither","(Z)V", (void*) SkPaintGlue::setDither},
- {"native_getStyle","(J)I", (void*) SkPaintGlue::getStyle},
- {"native_setStyle","(JI)V", (void*) SkPaintGlue::setStyle},
+ {"native_getStyle","(I)I", (void*) SkPaintGlue::getStyle},
+ {"native_setStyle","(II)V", (void*) SkPaintGlue::setStyle},
{"getColor","()I", (void*) SkPaintGlue::getColor},
{"setColor","(I)V", (void*) SkPaintGlue::setColor},
{"getAlpha","()I", (void*) SkPaintGlue::getAlpha},
{"setStrokeWidth","(F)V", (void*) SkPaintGlue::setStrokeWidth},
{"getStrokeMiter","()F", (void*) SkPaintGlue::getStrokeMiter},
{"setStrokeMiter","(F)V", (void*) SkPaintGlue::setStrokeMiter},
- {"native_getStrokeCap","(J)I", (void*) SkPaintGlue::getStrokeCap},
- {"native_setStrokeCap","(JI)V", (void*) SkPaintGlue::setStrokeCap},
- {"native_getStrokeJoin","(J)I", (void*) SkPaintGlue::getStrokeJoin},
- {"native_setStrokeJoin","(JI)V", (void*) SkPaintGlue::setStrokeJoin},
- {"native_getFillPath","(JJJ)Z", (void*) SkPaintGlue::getFillPath},
- {"native_setShader","(JJ)J", (void*) SkPaintGlue::setShader},
- {"native_setColorFilter","(JJ)J", (void*) SkPaintGlue::setColorFilter},
- {"native_setXfermode","(JJ)J", (void*) SkPaintGlue::setXfermode},
- {"native_setPathEffect","(JJ)J", (void*) SkPaintGlue::setPathEffect},
- {"native_setMaskFilter","(JJ)J", (void*) SkPaintGlue::setMaskFilter},
- {"native_setTypeface","(JJ)J", (void*) SkPaintGlue::setTypeface},
- {"native_setRasterizer","(JJ)J", (void*) SkPaintGlue::setRasterizer},
- {"native_getTextAlign","(J)I", (void*) SkPaintGlue::getTextAlign},
- {"native_setTextAlign","(JI)V", (void*) SkPaintGlue::setTextAlign},
- {"native_setTextLocale","(JLjava/lang/String;)V", (void*) SkPaintGlue::setTextLocale},
+ {"native_getStrokeCap","(I)I", (void*) SkPaintGlue::getStrokeCap},
+ {"native_setStrokeCap","(II)V", (void*) SkPaintGlue::setStrokeCap},
+ {"native_getStrokeJoin","(I)I", (void*) SkPaintGlue::getStrokeJoin},
+ {"native_setStrokeJoin","(II)V", (void*) SkPaintGlue::setStrokeJoin},
+ {"native_getFillPath","(III)Z", (void*) SkPaintGlue::getFillPath},
+ {"native_setShader","(II)I", (void*) SkPaintGlue::setShader},
+ {"native_setColorFilter","(II)I", (void*) SkPaintGlue::setColorFilter},
+ {"native_setXfermode","(II)I", (void*) SkPaintGlue::setXfermode},
+ {"native_setPathEffect","(II)I", (void*) SkPaintGlue::setPathEffect},
+ {"native_setMaskFilter","(II)I", (void*) SkPaintGlue::setMaskFilter},
+ {"native_setTypeface","(II)I", (void*) SkPaintGlue::setTypeface},
+ {"native_setRasterizer","(II)I", (void*) SkPaintGlue::setRasterizer},
+ {"native_getTextAlign","(I)I", (void*) SkPaintGlue::getTextAlign},
+ {"native_setTextAlign","(II)V", (void*) SkPaintGlue::setTextAlign},
+ {"native_setTextLocale","(ILjava/lang/String;)V", (void*) SkPaintGlue::setTextLocale},
{"getTextSize","()F", (void*) SkPaintGlue::getTextSize},
{"setTextSize","(F)V", (void*) SkPaintGlue::setTextSize},
{"getTextScaleX","()F", (void*) SkPaintGlue::getTextScaleX},
{"native_measureText","(Ljava/lang/String;III)F", (void*) SkPaintGlue::measureText_StringIII},
{"native_breakText","([CIIFI[F)I", (void*) SkPaintGlue::breakTextC},
{"native_breakText","(Ljava/lang/String;ZFI[F)I", (void*) SkPaintGlue::breakTextS},
- {"native_getTextWidths","(J[CIII[F)I", (void*) SkPaintGlue::getTextWidths___CIII_F},
- {"native_getTextWidths","(JLjava/lang/String;III[F)I", (void*) SkPaintGlue::getTextWidths__StringIII_F},
- {"native_getTextRunAdvances","(J[CIIIII[FI)F",
+ {"native_getTextWidths","(I[CIII[F)I", (void*) SkPaintGlue::getTextWidths___CIII_F},
+ {"native_getTextWidths","(ILjava/lang/String;III[F)I", (void*) SkPaintGlue::getTextWidths__StringIII_F},
+ {"native_getTextRunAdvances","(I[CIIIII[FI)F",
(void*) SkPaintGlue::getTextRunAdvances___CIIIII_FI},
- {"native_getTextRunAdvances","(JLjava/lang/String;IIIII[FI)F",
+ {"native_getTextRunAdvances","(ILjava/lang/String;IIIII[FI)F",
(void*) SkPaintGlue::getTextRunAdvances__StringIIIII_FI},
- {"native_getTextGlyphs","(JLjava/lang/String;IIIII[C)I",
+ {"native_getTextGlyphs","(ILjava/lang/String;IIIII[C)I",
(void*) SkPaintGlue::getTextGlyphs__StringIIIII_C},
- {"native_getTextRunCursor", "(J[CIIIII)I", (void*) SkPaintGlue::getTextRunCursor___C},
- {"native_getTextRunCursor", "(JLjava/lang/String;IIIII)I",
+ {"native_getTextRunCursor", "(I[CIIIII)I", (void*) SkPaintGlue::getTextRunCursor___C},
+ {"native_getTextRunCursor", "(ILjava/lang/String;IIIII)I",
(void*) SkPaintGlue::getTextRunCursor__String},
- {"native_getTextPath","(JI[CIIFFJ)V", (void*) SkPaintGlue::getTextPath___C},
- {"native_getTextPath","(JILjava/lang/String;IIFFJ)V", (void*) SkPaintGlue::getTextPath__String},
- {"nativeGetStringBounds", "(JLjava/lang/String;IIILandroid/graphics/Rect;)V",
+ {"native_getTextPath","(II[CIIFFI)V", (void*) SkPaintGlue::getTextPath___C},
+ {"native_getTextPath","(IILjava/lang/String;IIFFI)V", (void*) SkPaintGlue::getTextPath__String},
+ {"nativeGetStringBounds", "(ILjava/lang/String;IIILandroid/graphics/Rect;)V",
(void*) SkPaintGlue::getStringBounds },
- {"nativeGetCharArrayBounds", "(J[CIIILandroid/graphics/Rect;)V",
+ {"nativeGetCharArrayBounds", "(I[CIIILandroid/graphics/Rect;)V",
(void*) SkPaintGlue::getCharArrayBounds },
{"nSetShadowLayer", "(FFFI)V", (void*)SkPaintGlue::setShadowLayer}
};
class SkPathGlue {
public:
- static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void finalizer(JNIEnv* env, jobject clazz, SkPath* obj) {
#ifdef USE_OPENGL_RENDERER
if (android::uirenderer::Caches::hasInstance()) {
android::uirenderer::Caches::getInstance().resourceCache.destructor(obj);
delete obj;
}
- static jlong init1(JNIEnv* env, jobject clazz) {
- return reinterpret_cast<jlong>(new SkPath());
+ static SkPath* init1(JNIEnv* env, jobject clazz) {
+ return new SkPath();
}
-
- static jlong init2(JNIEnv* env, jobject clazz, jlong valHandle) {
- SkPath* val = reinterpret_cast<SkPath*>(valHandle);
- return reinterpret_cast<jlong>(new SkPath(*val));
+
+ static SkPath* init2(JNIEnv* env, jobject clazz, SkPath* val) {
+ return new SkPath(*val);
}
-
- static void reset(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+
+ static void reset(JNIEnv* env, jobject clazz, SkPath* obj) {
obj->reset();
}
- static void rewind(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void rewind(JNIEnv* env, jobject clazz, SkPath* obj) {
obj->rewind();
}
- static void assign(JNIEnv* env, jobject clazz, jlong dstHandle, jlong srcHandle) {
- SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
- const SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
+ static void assign(JNIEnv* env, jobject clazz, SkPath* dst, const SkPath* src) {
*dst = *src;
}
-
- static jint getFillType(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+
+ static jint getFillType(JNIEnv* env, jobject clazz, SkPath* obj) {
return obj->getFillType();
}
- static void setFillType(JNIEnv* env, jobject clazz, jlong pathHandle, jint ftHandle) {
- SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
- SkPath::FillType ft = static_cast<SkPath::FillType>(ftHandle);
+ static void setFillType(JNIEnv* env, jobject clazz, SkPath* path, SkPath::FillType ft) {
path->setFillType(ft);
}
-
- static jboolean isEmpty(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+
+ static jboolean isEmpty(JNIEnv* env, jobject clazz, SkPath* obj) {
return obj->isEmpty();
}
- static jboolean isRect(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect) {
+ static jboolean isRect(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect) {
SkRect rect_;
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
jboolean result = obj->isRect(&rect_);
GraphicsJNI::rect_to_jrectf(rect_, env, rect);
return result;
}
- static void computeBounds(JNIEnv* env, jobject clazz, jlong objHandle, jobject bounds) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void computeBounds(JNIEnv* env, jobject clazz, SkPath* obj, jobject bounds) {
const SkRect& bounds_ = obj->getBounds();
GraphicsJNI::rect_to_jrectf(bounds_, env, bounds);
}
- static void incReserve(JNIEnv* env, jobject clazz, jlong objHandle, jint extraPtCount) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void incReserve(JNIEnv* env, jobject clazz, SkPath* obj, jint extraPtCount) {
obj->incReserve(extraPtCount);
}
- static void moveTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void moveTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) {
SkScalar x_ = SkFloatToScalar(x);
SkScalar y_ = SkFloatToScalar(y);
obj->moveTo(x_, y_);
}
- static void rMoveTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void rMoveTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
obj->rMoveTo(dx_, dy_);
}
- static void lineTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void lineTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) {
SkScalar x_ = SkFloatToScalar(x);
SkScalar y_ = SkFloatToScalar(y);
obj->lineTo(x_, y_);
}
- static void rLineTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void rLineTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
obj->rLineTo(dx_, dy_);
}
- static void quadTo__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void quadTo__FFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2) {
SkScalar x1_ = SkFloatToScalar(x1);
SkScalar y1_ = SkFloatToScalar(y1);
SkScalar x2_ = SkFloatToScalar(x2);
obj->quadTo(x1_, y1_, x2_, y2_);
}
- static void rQuadTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void rQuadTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) {
SkScalar dx1_ = SkFloatToScalar(dx1);
SkScalar dy1_ = SkFloatToScalar(dy1);
SkScalar dx2_ = SkFloatToScalar(dx2);
obj->rQuadTo(dx1_, dy1_, dx2_, dy2_);
}
- static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
SkScalar x1_ = SkFloatToScalar(x1);
SkScalar y1_ = SkFloatToScalar(y1);
SkScalar x2_ = SkFloatToScalar(x2);
obj->cubicTo(x1_, y1_, x2_, y2_, x3_, y3_);
}
- static void rCubicTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void rCubicTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
SkScalar x1_ = SkFloatToScalar(x1);
SkScalar y1_ = SkFloatToScalar(y1);
SkScalar x2_ = SkFloatToScalar(x2);
obj->rCubicTo(x1_, y1_, x2_, y2_, x3_, y3_);
}
- static void arcTo(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void arcTo(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) {
SkRect oval_;
GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
SkScalar startAngle_ = SkFloatToScalar(startAngle);
obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo);
}
- static void close(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void close(JNIEnv* env, jobject clazz, SkPath* obj) {
obj->close();
}
- static void addRect__RectFI(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect, jint dirHandle) {
+ static void addRect__RectFI(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, SkPath::Direction dir) {
SkRect rect_;
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
obj->addRect(rect_, dir);
}
- static void addRect__FFFFI(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
+ static void addRect__FFFFI(JNIEnv* env, jobject clazz, SkPath* obj, jfloat left, jfloat top, jfloat right, jfloat bottom, SkPath::Direction dir) {
SkScalar left_ = SkFloatToScalar(left);
SkScalar top_ = SkFloatToScalar(top);
SkScalar right_ = SkFloatToScalar(right);
obj->addRect(left_, top_, right_, bottom_, dir);
}
- static void addOval(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jint dirHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
+ static void addOval(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, SkPath::Direction dir) {
SkRect oval_;
GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
obj->addOval(oval_, dir);
}
- static void addCircle(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y, jfloat radius, jint dirHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
+ static void addCircle(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y, jfloat radius, SkPath::Direction dir) {
SkScalar x_ = SkFloatToScalar(x);
SkScalar y_ = SkFloatToScalar(y);
SkScalar radius_ = SkFloatToScalar(radius);
obj->addCircle(x_, y_, radius_, dir);
}
- static void addArc(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle) {
+ static void addArc(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle) {
SkRect oval_;
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
SkScalar startAngle_ = SkFloatToScalar(startAngle);
SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
obj->addArc(oval_, startAngle_, sweepAngle_);
}
- static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect,
- jfloat rx, jfloat ry, jint dirHandle) {
+ static void addRoundRectXY(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect,
+ jfloat rx, jfloat ry, SkPath::Direction dir) {
SkRect rect_;
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
SkScalar rx_ = SkFloatToScalar(rx);
SkScalar ry_ = SkFloatToScalar(ry);
obj->addRoundRect(rect_, rx_, ry_, dir);
}
- static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jobject rect,
- jfloatArray array, jint dirHandle) {
+ static void addRoundRect8(JNIEnv* env, jobject, SkPath* obj, jobject rect,
+ jfloatArray array, SkPath::Direction dir) {
SkRect rect_;
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
AutoJavaFloatArray afa(env, array, 8);
const float* src = afa.ptr();
obj->addRoundRect(rect_, dst, dir);
}
- static void addPath__PathFF(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jfloat dx, jfloat dy) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
+ static void addPath__PathFF(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, jfloat dx, jfloat dy) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
obj->addPath(*src, dx_, dy_);
}
- static void addPath__Path(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
+ static void addPath__Path(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src) {
obj->addPath(*src);
}
- static void addPath__PathMatrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong matrixHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+ static void addPath__PathMatrix(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, SkMatrix* matrix) {
obj->addPath(*src, *matrix);
}
- static void offset__FFPath(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy, jlong dstHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
+ static void offset__FFPath(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy, SkPath* dst) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
obj->offset(dx_, dy_, dst);
}
- static void offset__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void offset__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
obj->offset(dx_, dy_);
}
- static void setLastPoint(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ static void setLastPoint(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
SkScalar dx_ = SkFloatToScalar(dx);
SkScalar dy_ = SkFloatToScalar(dy);
obj->setLastPt(dx_, dy_);
}
- static void transform__MatrixPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle, jlong dstHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
- SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
+ static void transform__MatrixPath(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix, SkPath* dst) {
obj->transform(*matrix, dst);
}
- static void transform__Matrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle) {
- SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
- SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
+ static void transform__Matrix(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix) {
obj->transform(*matrix);
}
- static jboolean op(JNIEnv* env, jobject clazz, jlong p1Handle, jlong p2Handle, jint opHandle, jlong rHandle) {
- SkPath* p1 = reinterpret_cast<SkPath*>(p1Handle);
- SkPath* p2 = reinterpret_cast<SkPath*>(p2Handle);
- SkPathOp op = static_cast<SkPathOp>(opHandle);
- SkPath* r = reinterpret_cast<SkPath*>(rHandle);
- return Op(*p1, *p2, op, r);
+ static jboolean op(JNIEnv* env, jobject clazz, SkPath* p1, SkPath* p2, SkPathOp op, SkPath* r) {
+ return Op(*p1, *p2, op, r);
}
typedef SkPoint (*bezierCalculation)(float t, const SkPoint* points);
// Note that more than one point may have the same length along the path in
// the case of a move.
// NULL can be returned if the Path is empty.
- static jfloatArray approximate(JNIEnv* env, jclass, jlong pathHandle, float acceptableError)
+ static jfloatArray approximate(JNIEnv* env, jclass, SkPath* path, float acceptableError)
{
- SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
SkASSERT(path);
SkPath::Iter pathIter(*path, false);
SkPath::Verb verb;
return result;
}
- static SkPathMeasure* trim(JNIEnv* env, jobject clazz, jlong inPathPtr, jlong outPathPtr,
- jlong pathMeasurePtr, jfloat trimStart, jfloat trimEnd, jfloat trimOffset) {
- SkPath* inPath = reinterpret_cast<SkPath*>(inPathPtr);
- SkPath* outPath = reinterpret_cast<SkPath*>(outPathPtr);
- SkPathMeasure* pathMeasure = reinterpret_cast<SkPathMeasure*>(pathMeasurePtr);
+ static SkPathMeasure* trim(JNIEnv* env, jobject clazz, SkPath* inPath, SkPath* outPath,
+ SkPathMeasure* pathMeasure, jfloat trimStart, jfloat trimEnd, jfloat trimOffset) {
if (trimStart == 0 && trimEnd == 1) {
if (outPath != NULL) {
*outPath = *inPath;
return pathMeasure;
}
- static void destroyMeasure(JNIEnv* env, jobject clazz, jlong measure) {
- delete reinterpret_cast<SkPathMeasure*>(measure);
+ static void destroyMeasure(JNIEnv* env, jobject clazz, SkPathMeasure* measure) {
+ delete measure;
}
};
static JNINativeMethod methods[] = {
- {"finalizer", "(J)V", (void*) SkPathGlue::finalizer},
- {"init1","()J", (void*) SkPathGlue::init1},
- {"init2","(J)J", (void*) SkPathGlue::init2},
- {"native_reset","(J)V", (void*) SkPathGlue::reset},
- {"native_rewind","(J)V", (void*) SkPathGlue::rewind},
- {"native_set","(JJ)V", (void*) SkPathGlue::assign},
- {"native_getFillType","(J)I", (void*) SkPathGlue::getFillType},
- {"native_setFillType","(JI)V", (void*) SkPathGlue::setFillType},
- {"native_isEmpty","(J)Z", (void*) SkPathGlue::isEmpty},
- {"native_isRect","(JLandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect},
- {"native_computeBounds","(JLandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds},
- {"native_incReserve","(JI)V", (void*) SkPathGlue::incReserve},
- {"native_moveTo","(JFF)V", (void*) SkPathGlue::moveTo__FF},
- {"native_rMoveTo","(JFF)V", (void*) SkPathGlue::rMoveTo},
- {"native_lineTo","(JFF)V", (void*) SkPathGlue::lineTo__FF},
- {"native_rLineTo","(JFF)V", (void*) SkPathGlue::rLineTo},
- {"native_quadTo","(JFFFF)V", (void*) SkPathGlue::quadTo__FFFF},
- {"native_rQuadTo","(JFFFF)V", (void*) SkPathGlue::rQuadTo},
- {"native_cubicTo","(JFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF},
- {"native_rCubicTo","(JFFFFFF)V", (void*) SkPathGlue::rCubicTo},
- {"native_arcTo","(JLandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo},
- {"native_close","(J)V", (void*) SkPathGlue::close},
- {"native_addRect","(JLandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI},
- {"native_addRect","(JFFFFI)V", (void*) SkPathGlue::addRect__FFFFI},
- {"native_addOval","(JLandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval},
- {"native_addCircle","(JFFFI)V", (void*) SkPathGlue::addCircle},
- {"native_addArc","(JLandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc},
- {"native_addRoundRect","(JLandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY},
- {"native_addRoundRect","(JLandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8},
- {"native_addPath","(JJFF)V", (void*) SkPathGlue::addPath__PathFF},
- {"native_addPath","(JJ)V", (void*) SkPathGlue::addPath__Path},
- {"native_addPath","(JJJ)V", (void*) SkPathGlue::addPath__PathMatrix},
- {"native_offset","(JFFJ)V", (void*) SkPathGlue::offset__FFPath},
- {"native_offset","(JFF)V", (void*) SkPathGlue::offset__FF},
- {"native_setLastPoint","(JFF)V", (void*) SkPathGlue::setLastPoint},
- {"native_transform","(JJJ)V", (void*) SkPathGlue::transform__MatrixPath},
- {"native_transform","(JJ)V", (void*) SkPathGlue::transform__Matrix},
- {"native_op","(JJIJ)Z", (void*) SkPathGlue::op},
- {"native_approximate", "(JF)[F", (void*) SkPathGlue::approximate},
- {"native_destroyMeasure","(J)V", (void*) SkPathGlue::destroyMeasure},
- {"native_trim","(JJJFFF)I", (void*) SkPathGlue::trim},
+ {"finalizer", "(I)V", (void*) SkPathGlue::finalizer},
+ {"init1","()I", (void*) SkPathGlue::init1},
+ {"init2","(I)I", (void*) SkPathGlue::init2},
+ {"native_reset","(I)V", (void*) SkPathGlue::reset},
+ {"native_rewind","(I)V", (void*) SkPathGlue::rewind},
+ {"native_set","(II)V", (void*) SkPathGlue::assign},
+ {"native_getFillType","(I)I", (void*) SkPathGlue::getFillType},
+ {"native_setFillType","(II)V", (void*) SkPathGlue::setFillType},
+ {"native_isEmpty","(I)Z", (void*) SkPathGlue::isEmpty},
+ {"native_isRect","(ILandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect},
+ {"native_computeBounds","(ILandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds},
+ {"native_incReserve","(II)V", (void*) SkPathGlue::incReserve},
+ {"native_moveTo","(IFF)V", (void*) SkPathGlue::moveTo__FF},
+ {"native_rMoveTo","(IFF)V", (void*) SkPathGlue::rMoveTo},
+ {"native_lineTo","(IFF)V", (void*) SkPathGlue::lineTo__FF},
+ {"native_rLineTo","(IFF)V", (void*) SkPathGlue::rLineTo},
+ {"native_quadTo","(IFFFF)V", (void*) SkPathGlue::quadTo__FFFF},
+ {"native_rQuadTo","(IFFFF)V", (void*) SkPathGlue::rQuadTo},
+ {"native_cubicTo","(IFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF},
+ {"native_rCubicTo","(IFFFFFF)V", (void*) SkPathGlue::rCubicTo},
+ {"native_arcTo","(ILandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo},
+ {"native_close","(I)V", (void*) SkPathGlue::close},
+ {"native_addRect","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI},
+ {"native_addRect","(IFFFFI)V", (void*) SkPathGlue::addRect__FFFFI},
+ {"native_addOval","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval},
+ {"native_addCircle","(IFFFI)V", (void*) SkPathGlue::addCircle},
+ {"native_addArc","(ILandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc},
+ {"native_addRoundRect","(ILandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY},
+ {"native_addRoundRect","(ILandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8},
+ {"native_addPath","(IIFF)V", (void*) SkPathGlue::addPath__PathFF},
+ {"native_addPath","(II)V", (void*) SkPathGlue::addPath__Path},
+ {"native_addPath","(III)V", (void*) SkPathGlue::addPath__PathMatrix},
+ {"native_offset","(IFFI)V", (void*) SkPathGlue::offset__FFPath},
+ {"native_offset","(IFF)V", (void*) SkPathGlue::offset__FF},
+ {"native_setLastPoint","(IFF)V", (void*) SkPathGlue::setLastPoint},
+ {"native_transform","(III)V", (void*) SkPathGlue::transform__MatrixPath},
+ {"native_transform","(II)V", (void*) SkPathGlue::transform__Matrix},
+ {"native_op","(IIII)Z", (void*) SkPathGlue::op},
+ {"native_approximate", "(IF)[F", (void*) SkPathGlue::approximate},
+ {"native_destroyMeasure","(I)V", (void*) SkPathGlue::destroyMeasure},
+ {"native_trim","(IIIFFF)I", (void*) SkPathGlue::trim},
};
int register_android_graphics_Path(JNIEnv* env) {
class SkPathEffectGlue {
public:
- static void destructor(JNIEnv* env, jobject, jlong effectHandle) {
- SkPathEffect* effect = reinterpret_cast<SkPathEffect*>(effectHandle);
+ static void destructor(JNIEnv* env, jobject, SkPathEffect* effect) {
SkSafeUnref(effect);
}
- static jlong Compose_constructor(JNIEnv* env, jobject,
- jlong outerHandle, jlong innerHandle) {
- SkPathEffect* outer = reinterpret_cast<SkPathEffect*>(outerHandle);
- SkPathEffect* inner = reinterpret_cast<SkPathEffect*>(innerHandle);
- SkPathEffect* effect = new SkComposePathEffect(outer, inner);
- return reinterpret_cast<jlong>(effect);
+ static SkPathEffect* Compose_constructor(JNIEnv* env, jobject,
+ SkPathEffect* outer, SkPathEffect* inner) {
+ return new SkComposePathEffect(outer, inner);
}
- static jlong Sum_constructor(JNIEnv* env, jobject,
- jlong firstHandle, jlong secondHandle) {
- SkPathEffect* first = reinterpret_cast<SkPathEffect*>(firstHandle);
- SkPathEffect* second = reinterpret_cast<SkPathEffect*>(secondHandle);
- SkPathEffect* effect = new SkSumPathEffect(first, second);
- return reinterpret_cast<jlong>(effect);
+ static SkPathEffect* Sum_constructor(JNIEnv* env, jobject,
+ SkPathEffect* first, SkPathEffect* second) {
+ return new SkSumPathEffect(first, second);
}
- static jlong Dash_constructor(JNIEnv* env, jobject,
- jfloatArray intervalArray, jfloat phase) {
+ static SkPathEffect* Dash_constructor(JNIEnv* env, jobject,
+ jfloatArray intervalArray, float phase) {
AutoJavaFloatArray autoInterval(env, intervalArray);
int count = autoInterval.length() & ~1; // even number
float* values = autoInterval.ptr();
for (int i = 0; i < count; i++) {
intervals[i] = SkFloatToScalar(values[i]);
}
- SkPathEffect* effect = new SkDashPathEffect(intervals, count, SkFloatToScalar(phase));
- return reinterpret_cast<jlong>(effect);
+ return new SkDashPathEffect(intervals, count, SkFloatToScalar(phase));
}
- static jlong OneD_constructor(JNIEnv* env, jobject,
- jlong shapeHandle, jfloat advance, jfloat phase, jint style) {
- const SkPath* shape = reinterpret_cast<SkPath*>(shapeHandle);
+ static SkPathEffect* OneD_constructor(JNIEnv* env, jobject,
+ const SkPath* shape, float advance, float phase, int style) {
SkASSERT(shape != NULL);
- SkPathEffect* effect = new SkPath1DPathEffect(*shape, SkFloatToScalar(advance),
+ return new SkPath1DPathEffect(*shape, SkFloatToScalar(advance),
SkFloatToScalar(phase), (SkPath1DPathEffect::Style)style);
- return reinterpret_cast<jlong>(effect);
}
- static jlong Corner_constructor(JNIEnv* env, jobject, jfloat radius){
- SkPathEffect* effect = new SkCornerPathEffect(SkFloatToScalar(radius));
- return reinterpret_cast<jlong>(effect);
+ static SkPathEffect* Corner_constructor(JNIEnv* env, jobject, float radius){
+ return new SkCornerPathEffect(SkFloatToScalar(radius));
}
- static jlong Discrete_constructor(JNIEnv* env, jobject,
- jfloat length, jfloat deviation) {
- SkPathEffect* effect = new SkDiscretePathEffect(SkFloatToScalar(length),
+ static SkPathEffect* Discrete_constructor(JNIEnv* env, jobject,
+ float length, float deviation) {
+ return new SkDiscretePathEffect(SkFloatToScalar(length),
SkFloatToScalar(deviation));
- return reinterpret_cast<jlong>(effect);
}
};
////////////////////////////////////////////////////////////////////////////////////////////////////////
static JNINativeMethod gPathEffectMethods[] = {
- { "nativeDestructor", "(J)V", (void*)SkPathEffectGlue::destructor }
+ { "nativeDestructor", "(I)V", (void*)SkPathEffectGlue::destructor }
};
static JNINativeMethod gComposePathEffectMethods[] = {
- { "nativeCreate", "(JJ)J", (void*)SkPathEffectGlue::Compose_constructor }
+ { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Compose_constructor }
};
static JNINativeMethod gSumPathEffectMethods[] = {
- { "nativeCreate", "(JJ)J", (void*)SkPathEffectGlue::Sum_constructor }
+ { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Sum_constructor }
};
static JNINativeMethod gDashPathEffectMethods[] = {
- { "nativeCreate", "([FF)J", (void*)SkPathEffectGlue::Dash_constructor }
+ { "nativeCreate", "([FF)I", (void*)SkPathEffectGlue::Dash_constructor }
};
static JNINativeMethod gPathDashPathEffectMethods[] = {
- { "nativeCreate", "(JFFI)J", (void*)SkPathEffectGlue::OneD_constructor }
+ { "nativeCreate", "(IFFI)I", (void*)SkPathEffectGlue::OneD_constructor }
};
static JNINativeMethod gCornerPathEffectMethods[] = {
- { "nativeCreate", "(F)J", (void*)SkPathEffectGlue::Corner_constructor }
+ { "nativeCreate", "(F)I", (void*)SkPathEffectGlue::Corner_constructor }
};
static JNINativeMethod gDiscretePathEffectMethods[] = {
- { "nativeCreate", "(FF)J", (void*)SkPathEffectGlue::Discrete_constructor }
+ { "nativeCreate", "(FF)I", (void*)SkPathEffectGlue::Discrete_constructor }
};
#include <android_runtime/AndroidRuntime.h>
class SkPictureGlue {
public:
- static jlong newPicture(JNIEnv* env, jobject, jlong srcHandle) {
- const SkPicture* src = reinterpret_cast<SkPicture*>(srcHandle);
+ static SkPicture* newPicture(JNIEnv* env, jobject, const SkPicture* src) {
if (src) {
- return reinterpret_cast<jlong>(new SkPicture(*src));
+ return new SkPicture(*src);
} else {
- return reinterpret_cast<jlong>(new SkPicture);
+ return new SkPicture;
}
}
-
- static jlong deserialize(JNIEnv* env, jobject, jobject jstream,
- jbyteArray jstorage) {
+
+ static SkPicture* deserialize(JNIEnv* env, jobject, jobject jstream,
+ jbyteArray jstorage) {
SkPicture* picture = NULL;
SkStream* strm = CreateJavaInputStreamAdaptor(env, jstream, jstorage);
if (strm) {
picture = SkPicture::CreateFromStream(strm);
delete strm;
}
- return reinterpret_cast<jlong>(picture);
+ return picture;
}
-
- static void killPicture(JNIEnv* env, jobject, jlong pictureHandle) {
- SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle);
+
+ static void killPicture(JNIEnv* env, jobject, SkPicture* picture) {
SkASSERT(picture);
picture->unref();
}
-
- static void draw(JNIEnv* env, jobject, jlong canvasHandle,
- jlong pictureHandle) {
- SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
- SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle);
+
+ static void draw(JNIEnv* env, jobject, SkCanvas* canvas,
+ SkPicture* picture) {
SkASSERT(canvas);
SkASSERT(picture);
picture->draw(canvas);
}
-
- static jboolean serialize(JNIEnv* env, jobject, jlong pictureHandle,
+
+ static bool serialize(JNIEnv* env, jobject, SkPicture* picture,
jobject jstream, jbyteArray jstorage) {
- SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle);
SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
if (NULL != strm) {
picture->serialize(strm);
delete strm;
- return JNI_TRUE;
+ return true;
}
- return JNI_FALSE;
+ return false;
}
-
- static jint getWidth(JNIEnv* env, jobject jpic) {
+
+ static int getWidth(JNIEnv* env, jobject jpic) {
NPE_CHECK_RETURN_ZERO(env, jpic);
- int width = GraphicsJNI::getNativePicture(env, jpic)->width();
- return static_cast<jint>(width);
+ return GraphicsJNI::getNativePicture(env, jpic)->width();
}
-
- static jint getHeight(JNIEnv* env, jobject jpic) {
+
+ static int getHeight(JNIEnv* env, jobject jpic) {
NPE_CHECK_RETURN_ZERO(env, jpic);
- int height = GraphicsJNI::getNativePicture(env, jpic)->height();
- return static_cast<jint>(height);
+ return GraphicsJNI::getNativePicture(env, jpic)->height();
}
-
- static jlong beginRecording(JNIEnv* env, jobject, jlong pictHandle,
- jint w, jint h) {
- SkPicture* pict = reinterpret_cast<SkPicture*>(pictHandle);
+
+ static SkCanvas* beginRecording(JNIEnv* env, jobject, SkPicture* pict,
+ int w, int h) {
// beginRecording does not ref its return value, it just returns it.
SkCanvas* canvas = pict->beginRecording(w, h);
// the java side will wrap this guy in a Canvas.java, which will call
// unref in its finalizer, so we have to ref it here, so that both that
// Canvas.java and our picture can both be owners
canvas->ref();
- return reinterpret_cast<jlong>(canvas);
+ return canvas;
}
-
- static void endRecording(JNIEnv* env, jobject, jlong pictHandle) {
- SkPicture* pict = reinterpret_cast<SkPicture*>(pictHandle);
+
+ static void endRecording(JNIEnv* env, jobject, SkPicture* pict) {
pict->endRecording();
}
};
static JNINativeMethod gPictureMethods[] = {
{"getWidth", "()I", (void*) SkPictureGlue::getWidth},
{"getHeight", "()I", (void*) SkPictureGlue::getHeight},
- {"nativeConstructor", "(J)J", (void*) SkPictureGlue::newPicture},
- {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)J", (void*)SkPictureGlue::deserialize},
- {"nativeBeginRecording", "(JII)J", (void*) SkPictureGlue::beginRecording},
- {"nativeEndRecording", "(J)V", (void*) SkPictureGlue::endRecording},
- {"nativeDraw", "(JJ)V", (void*) SkPictureGlue::draw},
- {"nativeWriteToStream", "(JLjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize},
- {"nativeDestructor","(J)V", (void*) SkPictureGlue::killPicture}
+ {"nativeConstructor", "(I)I", (void*) SkPictureGlue::newPicture},
+ {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)I", (void*)SkPictureGlue::deserialize},
+ {"nativeBeginRecording", "(III)I", (void*) SkPictureGlue::beginRecording},
+ {"nativeEndRecording", "(I)V", (void*) SkPictureGlue::endRecording},
+ {"nativeDraw", "(II)V", (void*) SkPictureGlue::draw},
+ {"nativeWriteToStream", "(ILjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize},
+ {"nativeDestructor","(I)V", (void*) SkPictureGlue::killPicture}
};
#include <android_runtime/AndroidRuntime.h>
-
+
#define REG(env, name, array) \
result = android::AndroidRuntime::registerNativeMethods(env, name, array, \
SK_ARRAY_COUNT(array)); \
if (result < 0) return result
-
+
int register_android_graphics_Picture(JNIEnv* env) {
int result;
-
+
REG(env, "android/graphics/Picture", gPictureMethods);
-
+
return result;
}
-
+
}
class SkPorterDuffGlue {
public:
- static jlong CreateXfermode(JNIEnv* env, jobject, jint modeHandle) {
- SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle);
- return reinterpret_cast<jlong>(SkPorterDuff::CreateXfermode(mode));
+ static SkXfermode* CreateXfermode(JNIEnv* env, jobject,
+ SkPorterDuff::Mode mode) {
+ return SkPorterDuff::CreateXfermode(mode);
}
};
static JNINativeMethod methods[] = {
- {"nativeCreateXfermode","(I)J", (void*) SkPorterDuffGlue::CreateXfermode},
+ {"nativeCreateXfermode","(I)I", (void*) SkPorterDuffGlue::CreateXfermode},
};
int register_android_graphics_PorterDuff(JNIEnv* env) {
class SkRasterizerGlue {
public:
- static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) {
- SkRasterizer* obj = reinterpret_cast<SkRasterizer *>(objHandle);
+ static void finalizer(JNIEnv* env, jobject clazz, SkRasterizer* obj) {
SkSafeUnref(obj);
}
};
static JNINativeMethod methods[] = {
- {"finalizer", "(J)V", (void*) SkRasterizerGlue::finalizer}
+ {"finalizer", "(I)V", (void*) SkRasterizerGlue::finalizer}
};
int register_android_graphics_Rasterizer(JNIEnv* env) {
static jfieldID gRegion_nativeInstanceFieldID;
-static inline jboolean boolTojboolean(bool value) {
- return value ? JNI_TRUE : JNI_FALSE;
-}
-
static inline SkRegion* GetSkRegion(JNIEnv* env, jobject regionObject) {
- jlong regionHandle = env->GetLongField(regionObject, gRegion_nativeInstanceFieldID);
- SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
- SkASSERT(region != NULL);
- return region;
+ SkRegion* rgn = (SkRegion*)env->GetIntField(regionObject, gRegion_nativeInstanceFieldID);
+ SkASSERT(rgn != NULL);
+ return rgn;
}
-static jlong Region_constructor(JNIEnv* env, jobject) {
- return reinterpret_cast<jlong>(new SkRegion);
+static SkRegion* Region_constructor(JNIEnv* env, jobject) {
+ return new SkRegion;
}
-static void Region_destructor(JNIEnv* env, jobject, jlong regionHandle) {
- SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
+static void Region_destructor(JNIEnv* env, jobject, SkRegion* region) {
SkASSERT(region);
delete region;
}
-static void Region_setRegion(JNIEnv* env, jobject, jlong dstHandle, jlong srcHandle) {
- SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle);
- const SkRegion* src = reinterpret_cast<SkRegion*>(srcHandle);
+static void Region_setRegion(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* src) {
SkASSERT(dst && src);
*dst = *src;
}
-static jboolean Region_setRect(JNIEnv* env, jobject, jlong dstHandle, jint left, jint top, jint right, jint bottom) {
- SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle);
- bool result = dst->setRect(left, top, right, bottom);
- return boolTojboolean(result);
+static jboolean Region_setRect(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom) {
+ return dst->setRect(left, top, right, bottom);
}
-static jboolean Region_setPath(JNIEnv* env, jobject, jlong dstHandle,
- jlong pathHandle, jlong clipHandle) {
- SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle);
- const SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
- const SkRegion* clip = reinterpret_cast<SkRegion*>(clipHandle);
+static jboolean Region_setPath(JNIEnv* env, jobject, SkRegion* dst,
+ const SkPath* path, const SkRegion* clip) {
SkASSERT(dst && path && clip);
- bool result = dst->setPath(*path, *clip);
- return boolTojboolean(result);
-
+ return dst->setPath(*path, *clip);
}
-static jboolean Region_getBounds(JNIEnv* env, jobject, jlong regionHandle, jobject rectBounds) {
- SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
+static jboolean Region_getBounds(JNIEnv* env, jobject, SkRegion* region, jobject rectBounds) {
GraphicsJNI::irect_to_jrect(region->getBounds(), env, rectBounds);
- bool result = !region->isEmpty();
- return boolTojboolean(result);
+ return !region->isEmpty();
}
-static jboolean Region_getBoundaryPath(JNIEnv* env, jobject, jlong regionHandle, jlong pathHandle) {
- const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
- SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
- bool result = region->getBoundaryPath(path);
- return boolTojboolean(result);
+static jboolean Region_getBoundaryPath(JNIEnv* env, jobject, const SkRegion* region, SkPath* path) {
+ return region->getBoundaryPath(path);
}
-static jboolean Region_op0(JNIEnv* env, jobject, jlong dstHandle, jint left, jint top, jint right, jint bottom, jint op) {
- SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle);
+static jboolean Region_op0(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom, int op) {
SkIRect ir;
ir.set(left, top, right, bottom);
- bool result = dst->op(ir, (SkRegion::Op)op);
- return boolTojboolean(result);
+ return dst->op(ir, (SkRegion::Op)op);
}
-static jboolean Region_op1(JNIEnv* env, jobject, jlong dstHandle, jobject rectObject, jlong regionHandle, jint op) {
- SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle);
- const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
+static jboolean Region_op1(JNIEnv* env, jobject, SkRegion* dst, jobject rectObject, const SkRegion* region, int op) {
SkIRect ir;
GraphicsJNI::jrect_to_irect(env, rectObject, &ir);
- bool result = dst->op(ir, *region, (SkRegion::Op)op);
- return boolTojboolean(result);
+ return dst->op(ir, *region, (SkRegion::Op)op);
}
-static jboolean Region_op2(JNIEnv* env, jobject, jlong dstHandle, jlong region1Handle, jlong region2Handle, jint op) {
- SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle);
- const SkRegion* region1 = reinterpret_cast<SkRegion*>(region1Handle);
- const SkRegion* region2 = reinterpret_cast<SkRegion*>(region2Handle);
- bool result = dst->op(*region1, *region2, (SkRegion::Op)op);
- return boolTojboolean(result);
+static jboolean Region_op2(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* region1, const SkRegion* region2, int op) {
+ return dst->op(*region1, *region2, (SkRegion::Op)op);
}
//////////////////////////////////// These are methods, not static
static jboolean Region_isEmpty(JNIEnv* env, jobject region) {
- bool result = GetSkRegion(env, region)->isEmpty();
- return boolTojboolean(result);
+ return GetSkRegion(env, region)->isEmpty();
}
static jboolean Region_isRect(JNIEnv* env, jobject region) {
- bool result = GetSkRegion(env, region)->isRect();
- return boolTojboolean(result);
+ return GetSkRegion(env, region)->isRect();
}
static jboolean Region_isComplex(JNIEnv* env, jobject region) {
- bool result = GetSkRegion(env, region)->isComplex();
- return boolTojboolean(result);
+ return GetSkRegion(env, region)->isComplex();
}
-static jboolean Region_contains(JNIEnv* env, jobject region, jint x, jint y) {
- bool result = GetSkRegion(env, region)->contains(x, y);
- return boolTojboolean(result);
+static jboolean Region_contains(JNIEnv* env, jobject region, int x, int y) {
+ return GetSkRegion(env, region)->contains(x, y);
}
-static jboolean Region_quickContains(JNIEnv* env, jobject region, jint left, jint top, jint right, jint bottom) {
- bool result = GetSkRegion(env, region)->quickContains(left, top, right, bottom);
- return boolTojboolean(result);
+static jboolean Region_quickContains(JNIEnv* env, jobject region, int left, int top, int right, int bottom) {
+ return GetSkRegion(env, region)->quickContains(left, top, right, bottom);
}
-static jboolean Region_quickRejectIIII(JNIEnv* env, jobject region, jint left, jint top, jint right, jint bottom) {
+static jboolean Region_quickRejectIIII(JNIEnv* env, jobject region, int left, int top, int right, int bottom) {
SkIRect ir;
ir.set(left, top, right, bottom);
- bool result = GetSkRegion(env, region)->quickReject(ir);
- return boolTojboolean(result);
+ return GetSkRegion(env, region)->quickReject(ir);
}
static jboolean Region_quickRejectRgn(JNIEnv* env, jobject region, jobject other) {
- bool result = GetSkRegion(env, region)->quickReject(*GetSkRegion(env, other));
- return boolTojboolean(result);
+ return GetSkRegion(env, region)->quickReject(*GetSkRegion(env, other));
}
-static void Region_translate(JNIEnv* env, jobject region, jint x, jint y, jobject dst) {
+static void Region_translate(JNIEnv* env, jobject region, int x, int y, jobject dst) {
SkRegion* rgn = GetSkRegion(env, region);
if (dst)
rgn->translate(x, y, GetSkRegion(env, dst));
scale_rgn(rgn, *rgn, scale);
}
-static jstring Region_toString(JNIEnv* env, jobject clazz, jlong regionHandle) {
- SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
+static jstring Region_toString(JNIEnv* env, jobject clazz, SkRegion* region) {
char* str = region->toString();
if (str == NULL) {
return NULL;
////////////////////////////////////////////////////////////////////////////////////////////////////////////
-static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
+static SkRegion* Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
{
if (parcel == NULL) {
return NULL;
size_t size = p->readInt32();
region->readFromMemory(p->readInplace(size));
- return reinterpret_cast<jlong>(region);
+ return region;
}
-static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, jlong regionHandle, jobject parcel)
+static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, const SkRegion* region, jobject parcel)
{
- const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
if (parcel == NULL) {
- return JNI_FALSE;
+ return false;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
p->writeInt32(size);
region->writeToMemory(p->writeInplace(size));
- return JNI_TRUE;
+ return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
-static jboolean Region_equals(JNIEnv* env, jobject clazz, jlong r1Handle, jlong r2Handle)
+static jboolean Region_equals(JNIEnv* env, jobject clazz, const SkRegion *r1, const SkRegion* r2)
{
- const SkRegion *r1 = reinterpret_cast<SkRegion*>(r1Handle);
- const SkRegion *r2 = reinterpret_cast<SkRegion*>(r2Handle);
- return boolTojboolean(*r1 == *r2);
+ return (jboolean) (*r1 == *r2);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
};
-static jlong RegionIter_constructor(JNIEnv* env, jobject, jlong regionHandle)
+static RgnIterPair* RegionIter_constructor(JNIEnv* env, jobject, const SkRegion* region)
{
- const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
SkASSERT(region);
- return reinterpret_cast<jlong>(new RgnIterPair(*region));
+ return new RgnIterPair(*region);
}
-static void RegionIter_destructor(JNIEnv* env, jobject, jlong pairHandle)
+static void RegionIter_destructor(JNIEnv* env, jobject, RgnIterPair* pair)
{
- RgnIterPair* pair = reinterpret_cast<RgnIterPair*>(pairHandle);
SkASSERT(pair);
delete pair;
}
-static jboolean RegionIter_next(JNIEnv* env, jobject, jlong pairHandle, jobject rectObject)
+static jboolean RegionIter_next(JNIEnv* env, jobject, RgnIterPair* pair, jobject rectObject)
{
- RgnIterPair* pair = reinterpret_cast<RgnIterPair*>(pairHandle);
// the caller has checked that rectObject is not nul
SkASSERT(pair);
SkASSERT(rectObject);
if (!pair->fIter.done()) {
GraphicsJNI::irect_to_jrect(pair->fIter.rect(), env, rectObject);
pair->fIter.next();
- return JNI_TRUE;
+ return true;
}
- return JNI_FALSE;
+ return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
static JNINativeMethod gRegionIterMethods[] = {
- { "nativeConstructor", "(J)J", (void*)RegionIter_constructor },
- { "nativeDestructor", "(J)V", (void*)RegionIter_destructor },
- { "nativeNext", "(JLandroid/graphics/Rect;)Z", (void*)RegionIter_next }
+ { "nativeConstructor", "(I)I", (void*)RegionIter_constructor },
+ { "nativeDestructor", "(I)V", (void*)RegionIter_destructor },
+ { "nativeNext", "(ILandroid/graphics/Rect;)Z", (void*)RegionIter_next }
};
static JNINativeMethod gRegionMethods[] = {
// these are static methods
- { "nativeConstructor", "()J", (void*)Region_constructor },
- { "nativeDestructor", "(J)V", (void*)Region_destructor },
- { "nativeSetRegion", "(JJ)V", (void*)Region_setRegion },
- { "nativeSetRect", "(JIIII)Z", (void*)Region_setRect },
- { "nativeSetPath", "(JJJ)Z", (void*)Region_setPath },
- { "nativeGetBounds", "(JLandroid/graphics/Rect;)Z", (void*)Region_getBounds },
- { "nativeGetBoundaryPath", "(JJ)Z", (void*)Region_getBoundaryPath },
- { "nativeOp", "(JIIIII)Z", (void*)Region_op0 },
- { "nativeOp", "(JLandroid/graphics/Rect;JI)Z", (void*)Region_op1 },
- { "nativeOp", "(JJJI)Z", (void*)Region_op2 },
+ { "nativeConstructor", "()I", (void*)Region_constructor },
+ { "nativeDestructor", "(I)V", (void*)Region_destructor },
+ { "nativeSetRegion", "(II)V", (void*)Region_setRegion },
+ { "nativeSetRect", "(IIIII)Z", (void*)Region_setRect },
+ { "nativeSetPath", "(III)Z", (void*)Region_setPath },
+ { "nativeGetBounds", "(ILandroid/graphics/Rect;)Z", (void*)Region_getBounds },
+ { "nativeGetBoundaryPath", "(II)Z", (void*)Region_getBoundaryPath },
+ { "nativeOp", "(IIIIII)Z", (void*)Region_op0 },
+ { "nativeOp", "(ILandroid/graphics/Rect;II)Z", (void*)Region_op1 },
+ { "nativeOp", "(IIII)Z", (void*)Region_op2 },
// these are methods that take the java region object
{ "isEmpty", "()Z", (void*)Region_isEmpty },
{ "isRect", "()Z", (void*)Region_isRect },
{ "quickReject", "(Landroid/graphics/Region;)Z", (void*)Region_quickRejectRgn },
{ "scale", "(FLandroid/graphics/Region;)V", (void*)Region_scale },
{ "translate", "(IILandroid/graphics/Region;)V", (void*)Region_translate },
- { "nativeToString", "(J)Ljava/lang/String;", (void*)Region_toString },
+ { "nativeToString", "(I)Ljava/lang/String;", (void*)Region_toString },
// parceling methods
- { "nativeCreateFromParcel", "(Landroid/os/Parcel;)J", (void*)Region_createFromParcel },
- { "nativeWriteToParcel", "(JLandroid/os/Parcel;)Z", (void*)Region_writeToParcel },
- { "nativeEquals", "(JJ)Z", (void*)Region_equals },
+ { "nativeCreateFromParcel", "(Landroid/os/Parcel;)I", (void*)Region_createFromParcel },
+ { "nativeWriteToParcel", "(ILandroid/os/Parcel;)Z", (void*)Region_writeToParcel },
+ { "nativeEquals", "(II)Z", (void*)Region_equals },
};
int register_android_graphics_Region(JNIEnv* env)
jclass clazz = env->FindClass("android/graphics/Region");
SkASSERT(clazz);
- gRegion_nativeInstanceFieldID = env->GetFieldID(clazz, "mNativeRegion", "J");
+ gRegion_nativeInstanceFieldID = env->GetFieldID(clazz, "mNativeRegion", "I");
SkASSERT(gRegion_nativeInstanceFieldID);
int result = android::AndroidRuntime::registerNativeMethods(env, "android/graphics/Region",
}
}
-static void Color_RGBToHSV(JNIEnv* env, jobject, jint red, jint green, jint blue, jfloatArray hsvArray)
+static void Color_RGBToHSV(JNIEnv* env, jobject, int red, int green, int blue, jfloatArray hsvArray)
{
SkScalar hsv[3];
SkRGBToHSV(red, green, blue, hsv);
}
}
-static jint Color_HSVToColor(JNIEnv* env, jobject, jint alpha, jfloatArray hsvArray)
+static int Color_HSVToColor(JNIEnv* env, jobject, int alpha, jfloatArray hsvArray)
{
AutoJavaFloatArray autoHSV(env, hsvArray, 3);
float* values = autoHSV.ptr();;
hsv[i] = SkFloatToScalar(values[i]);
}
- return static_cast<jint>(SkHSVToColor(alpha, hsv));
+ return SkHSVToColor(alpha, hsv);
}
///////////////////////////////////////////////////////////////////////////////////////////////
-static void Shader_destructor(JNIEnv* env, jobject o, jlong shaderHandle, jlong skiaShaderHandle)
+static void Shader_destructor(JNIEnv* env, jobject o, SkShader* shader, SkiaShader* skiaShader)
{
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
- SkiaShader* skiaShader = reinterpret_cast<SkiaShader*>(skiaShaderHandle);
SkSafeUnref(shader);
// skiaShader == NULL when not !USE_OPENGL_RENDERER, so no need to delete it outside the ifdef
#ifdef USE_OPENGL_RENDERER
#endif
}
-static void Shader_setLocalMatrix(JNIEnv* env, jobject o, jlong shaderHandle,
- jlong skiaShaderHandle, jlong matrixHandle)
+static void Shader_setLocalMatrix(JNIEnv* env, jobject o, SkShader* shader, SkiaShader* skiaShader,
+ const SkMatrix* matrix)
{
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
- SkiaShader* skiaShader = reinterpret_cast<SkiaShader*>(skiaShaderHandle);
- const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
if (shader) {
if (NULL == matrix) {
shader->resetLocalMatrix();
///////////////////////////////////////////////////////////////////////////////////////////////
-static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong bitmapHandle,
- jint tileModeX, jint tileModeY)
+static SkShader* BitmapShader_constructor(JNIEnv* env, jobject o, const SkBitmap* bitmap,
+ int tileModeX, int tileModeY)
{
- const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkShader* s = SkShader::CreateBitmapShader(*bitmap,
(SkShader::TileMode)tileModeX,
(SkShader::TileMode)tileModeY);
ThrowIAE_IfNull(env, s);
- return reinterpret_cast<jlong>(s);
+ return s;
}
-static jlong BitmapShader_postConstructor(JNIEnv* env, jobject o, jlong shaderHandle,
- jlong bitmapHandle, jint tileModeX, jint tileModeY) {
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+static SkiaShader* BitmapShader_postConstructor(JNIEnv* env, jobject o, SkShader* shader,
+ SkBitmap* bitmap, int tileModeX, int tileModeY) {
#ifdef USE_OPENGL_RENDERER
SkiaShader* skiaShader = new SkiaBitmapShader(bitmap, shader,
static_cast<SkShader::TileMode>(tileModeX), static_cast<SkShader::TileMode>(tileModeY),
NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);
- return reinterpret_cast<jlong>(skiaShader);
+ return skiaShader;
#else
return NULL;
#endif
///////////////////////////////////////////////////////////////////////////////////////////////
-static jlong LinearGradient_create1(JNIEnv* env, jobject o,
- jfloat x0, jfloat y0, jfloat x1, jfloat y1,
- jintArray colorArray, jfloatArray posArray, jint tileMode)
+static SkShader* LinearGradient_create1(JNIEnv* env, jobject o,
+ float x0, float y0, float x1, float y1,
+ jintArray colorArray, jfloatArray posArray, int tileMode)
{
SkPoint pts[2];
pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0));
env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);
ThrowIAE_IfNull(env, shader);
- return reinterpret_cast<jlong>(shader);
+ return shader;
}
-static jlong LinearGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle,
- jfloat x0, jfloat y0, jfloat x1, jfloat y1, jintArray colorArray,
- jfloatArray posArray, jint tileMode) {
+static SkiaShader* LinearGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader,
+ float x0, float y0, float x1, float y1, jintArray colorArray,
+ jfloatArray posArray, int tileMode) {
#ifdef USE_OPENGL_RENDERER
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
size_t count = env->GetArrayLength(colorArray);
const jint* colorValues = env->GetIntArrayElements(colorArray, NULL);
(shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);
env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);
- return reinterpret_cast<jlong>(skiaShader);
+ return skiaShader;
#else
return NULL;
#endif
}
-static jlong LinearGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle,
- jfloat x0, jfloat y0, jfloat x1, jfloat y1, jint color0, jint color1, jint tileMode) {
+static SkiaShader* LinearGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader,
+ float x0, float y0, float x1, float y1, int color0, int color1, int tileMode) {
#ifdef USE_OPENGL_RENDERER
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
float* storedBounds = new float[4];
storedBounds[0] = x0; storedBounds[1] = y0;
storedBounds[2] = x1; storedBounds[3] = y1;
storedPositions, 2, shader, static_cast<SkShader::TileMode>(tileMode), NULL,
(shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);
- return reinterpret_cast<jlong>(skiaShader);
+ return skiaShader;
#else
return NULL;
#endif
}
-static jlong LinearGradient_create2(JNIEnv* env, jobject o,
- jfloat x0, jfloat y0, jfloat x1, jfloat y1,
- jint color0, jint color1, jint tileMode)
+static SkShader* LinearGradient_create2(JNIEnv* env, jobject o,
+ float x0, float y0, float x1, float y1,
+ int color0, int color1, int tileMode)
{
SkPoint pts[2];
pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0));
SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, (SkShader::TileMode)tileMode);
ThrowIAE_IfNull(env, s);
- return reinterpret_cast<jlong>(s);
+ return s;
}
///////////////////////////////////////////////////////////////////////////////////////////////
-static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius,
- jintArray colorArray, jfloatArray posArray, jint tileMode) {
+static SkShader* RadialGradient_create1(JNIEnv* env, jobject, float x, float y, float radius,
+ jintArray colorArray, jfloatArray posArray, int tileMode) {
SkPoint center;
center.set(SkFloatToScalar(x), SkFloatToScalar(y));
JNI_ABORT);
ThrowIAE_IfNull(env, shader);
- return reinterpret_cast<jlong>(shader);
+ return shader;
}
-static jlong RadialGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius,
- jint color0, jint color1, jint tileMode) {
+static SkShader* RadialGradient_create2(JNIEnv* env, jobject, float x, float y, float radius,
+ int color0, int color1, int tileMode) {
SkPoint center;
center.set(SkFloatToScalar(x), SkFloatToScalar(y));
SkShader* s = SkGradientShader::CreateRadial(center, SkFloatToScalar(radius), colors, NULL,
2, (SkShader::TileMode)tileMode);
ThrowIAE_IfNull(env, s);
- return reinterpret_cast<jlong>(s);
+ return s;
}
-static jlong RadialGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle,
- jfloat x, jfloat y, jfloat radius, jintArray colorArray, jfloatArray posArray, jint tileMode) {
+static SkiaShader* RadialGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader,
+ float x, float y, float radius, jintArray colorArray, jfloatArray posArray, int tileMode) {
#ifdef USE_OPENGL_RENDERER
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
size_t count = env->GetArrayLength(colorArray);
const jint* colorValues = env->GetIntArrayElements(colorArray, NULL);
(shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);
env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);
- return reinterpret_cast<jlong>(skiaShader);
+ return skiaShader;
#else
return NULL;
#endif
}
-static jlong RadialGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle,
- jfloat x, jfloat y, jfloat radius, jint color0, jint color1, jint tileMode) {
+static SkiaShader* RadialGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader,
+ float x, float y, float radius, int color0, int color1, int tileMode) {
#ifdef USE_OPENGL_RENDERER
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
float* storedPositions = new float[2];
storedPositions[0] = 0.0f;
storedPositions[1] = 1.0f;
storedPositions, 2, shader, (SkShader::TileMode) tileMode, NULL,
(shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);
- return reinterpret_cast<jlong>(skiaShader);
+ return skiaShader;
#else
return NULL;
#endif
///////////////////////////////////////////////////////////////////////////////
-static jlong SweepGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y,
+static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y,
jintArray jcolors, jfloatArray jpositions) {
size_t count = env->GetArrayLength(jcolors);
const jint* colors = env->GetIntArrayElements(jcolors, NULL);
env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors),
JNI_ABORT);
ThrowIAE_IfNull(env, shader);
- return reinterpret_cast<jlong>(shader);
+ return shader;
}
-static jlong SweepGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y,
+static SkShader* SweepGradient_create2(JNIEnv* env, jobject, float x, float y,
int color0, int color1) {
SkColor colors[2];
colors[0] = color0;
SkShader* s = SkGradientShader::CreateSweep(SkFloatToScalar(x), SkFloatToScalar(y),
colors, NULL, 2);
ThrowIAE_IfNull(env, s);
- return reinterpret_cast<jlong>(s);
+ return s;
}
-static jlong SweepGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle,
- jfloat x, jfloat y, jintArray colorArray, jfloatArray posArray) {
+static SkiaShader* SweepGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader,
+ float x, float y, jintArray colorArray, jfloatArray posArray) {
#ifdef USE_OPENGL_RENDERER
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
size_t count = env->GetArrayLength(colorArray);
const jint* colorValues = env->GetIntArrayElements(colorArray, NULL);
shader, NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);
env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);
- return reinterpret_cast<jlong>(skiaShader);
+ return skiaShader;
#else
return NULL;
#endif
}
-static jlong SweepGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle,
- jfloat x, jfloat y, jint color0, jint color1) {
+static SkiaShader* SweepGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader,
+ float x, float y, int color0, int color1) {
#ifdef USE_OPENGL_RENDERER
- SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
float* storedPositions = new float[2];
storedPositions[0] = 0.0f;
storedPositions[1] = 1.0f;
SkiaShader* skiaShader = new SkiaSweepGradientShader(x, y, storedColors, storedPositions, 2,
shader, NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);
- return reinterpret_cast<jlong>(skiaShader);
+ return skiaShader;
#else
return NULL;
#endif
///////////////////////////////////////////////////////////////////////////////////////////////
-static jlong ComposeShader_create1(JNIEnv* env, jobject o,
- jlong shaderAHandle, jlong shaderBHandle, jlong modeHandle)
+static SkShader* ComposeShader_create1(JNIEnv* env, jobject o,
+ SkShader* shaderA, SkShader* shaderB, SkXfermode* mode)
{
- SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle);
- SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle);
- SkXfermode* mode = reinterpret_cast<SkXfermode *>(modeHandle);
- SkShader* shader = new SkComposeShader(shaderA, shaderB, mode);
- return reinterpret_cast<jlong>(shader);
+ return new SkComposeShader(shaderA, shaderB, mode);
}
-static jlong ComposeShader_create2(JNIEnv* env, jobject o,
- jlong shaderAHandle, jlong shaderBHandle, jint porterDuffModeHandle)
+static SkShader* ComposeShader_create2(JNIEnv* env, jobject o,
+ SkShader* shaderA, SkShader* shaderB, SkPorterDuff::Mode porterDuffMode)
{
- SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle);
- SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle);
- SkPorterDuff::Mode porterDuffMode = static_cast<SkPorterDuff::Mode>(porterDuffModeHandle);
SkAutoUnref au(SkPorterDuff::CreateXfermode(porterDuffMode));
SkXfermode* mode = (SkXfermode*) au.get();
- SkShader* shader = new SkComposeShader(shaderA, shaderB, mode);
- return reinterpret_cast<jlong>(shader);
+ return new SkComposeShader(shaderA, shaderB, mode);
}
-static jlong ComposeShader_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle,
- jlong shaderAHandle, jlong shaderBHandle, jint porterDuffModeHandle) {
+static SkiaShader* ComposeShader_postCreate2(JNIEnv* env, jobject o, SkShader* shader,
+ SkiaShader* shaderA, SkiaShader* shaderB, SkPorterDuff::Mode porterDuffMode) {
#ifdef USE_OPENGL_RENDERER
- SkShader* shader = reinterpret_cast<SkShader *>(shaderHandle);
- SkiaShader* shaderA = reinterpret_cast<SkiaShader *>(shaderAHandle);
- SkiaShader* shaderB = reinterpret_cast<SkiaShader *>(shaderBHandle);
- SkPorterDuff::Mode porterDuffMode = static_cast<SkPorterDuff::Mode>(porterDuffModeHandle);
SkXfermode::Mode mode = SkPorterDuff::ToXfermodeMode(porterDuffMode);
- SkiaShader* skiaShader = new SkiaComposeShader(shaderA, shaderB, mode, shader);
- return reinterpret_cast<jlong>(skiaShader);
+ return new SkiaComposeShader(shaderA, shaderB, mode, shader);
#else
return NULL;
#endif
}
-static jlong ComposeShader_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle,
- jlong shaderAHandle, jlong shaderBHandle, jlong modeHandle) {
+static SkiaShader* ComposeShader_postCreate1(JNIEnv* env, jobject o, SkShader* shader,
+ SkiaShader* shaderA, SkiaShader* shaderB, SkXfermode* mode) {
#ifdef USE_OPENGL_RENDERER
- SkShader* shader = reinterpret_cast<SkShader *>(shaderHandle);
- SkiaShader* shaderA = reinterpret_cast<SkiaShader *>(shaderAHandle);
- SkiaShader* shaderB = reinterpret_cast<SkiaShader *>(shaderBHandle);
- SkXfermode* mode = reinterpret_cast<SkXfermode *>(modeHandle);
SkXfermode::Mode skiaMode;
if (!SkXfermode::IsMode(mode, &skiaMode)) {
// TODO: Support other modes
skiaMode = SkXfermode::kSrcOver_Mode;
}
- SkiaShader* skiaShader = new SkiaComposeShader(shaderA, shaderB, skiaMode, shader);
- return reinterpret_cast<jlong>(skiaShader);
+ return new SkiaComposeShader(shaderA, shaderB, skiaMode, shader);
#else
return NULL;
#endif
};
static JNINativeMethod gShaderMethods[] = {
- { "nativeDestructor", "(JJ)V", (void*)Shader_destructor },
- { "nativeSetLocalMatrix", "(JJJ)V", (void*)Shader_setLocalMatrix }
+ { "nativeDestructor", "(II)V", (void*)Shader_destructor },
+ { "nativeSetLocalMatrix", "(III)V", (void*)Shader_setLocalMatrix }
};
static JNINativeMethod gBitmapShaderMethods[] = {
- { "nativeCreate", "(JII)J", (void*)BitmapShader_constructor },
- { "nativePostCreate", "(JJII)J", (void*)BitmapShader_postConstructor }
+ { "nativeCreate", "(III)I", (void*)BitmapShader_constructor },
+ { "nativePostCreate", "(IIII)I", (void*)BitmapShader_postConstructor }
};
static JNINativeMethod gLinearGradientMethods[] = {
- { "nativeCreate1", "(FFFF[I[FI)J", (void*)LinearGradient_create1 },
- { "nativeCreate2", "(FFFFIII)J", (void*)LinearGradient_create2 },
- { "nativePostCreate1", "(JFFFF[I[FI)J", (void*)LinearGradient_postCreate1 },
- { "nativePostCreate2", "(JFFFFIII)J", (void*)LinearGradient_postCreate2 }
+ { "nativeCreate1", "(FFFF[I[FI)I", (void*)LinearGradient_create1 },
+ { "nativeCreate2", "(FFFFIII)I", (void*)LinearGradient_create2 },
+ { "nativePostCreate1", "(IFFFF[I[FI)I", (void*)LinearGradient_postCreate1 },
+ { "nativePostCreate2", "(IFFFFIII)I", (void*)LinearGradient_postCreate2 }
};
static JNINativeMethod gRadialGradientMethods[] = {
- { "nativeCreate1", "(FFF[I[FI)J", (void*)RadialGradient_create1 },
- { "nativeCreate2", "(FFFIII)J", (void*)RadialGradient_create2 },
- { "nativePostCreate1", "(JFFF[I[FI)J", (void*)RadialGradient_postCreate1 },
- { "nativePostCreate2", "(JFFFIII)J", (void*)RadialGradient_postCreate2 }
+ { "nativeCreate1", "(FFF[I[FI)I", (void*)RadialGradient_create1 },
+ { "nativeCreate2", "(FFFIII)I", (void*)RadialGradient_create2 },
+ { "nativePostCreate1", "(IFFF[I[FI)I", (void*)RadialGradient_postCreate1 },
+ { "nativePostCreate2", "(IFFFIII)I", (void*)RadialGradient_postCreate2 }
};
static JNINativeMethod gSweepGradientMethods[] = {
- { "nativeCreate1", "(FF[I[F)J", (void*)SweepGradient_create1 },
- { "nativeCreate2", "(FFII)J", (void*)SweepGradient_create2 },
- { "nativePostCreate1", "(JFF[I[F)J", (void*)SweepGradient_postCreate1 },
- { "nativePostCreate2", "(JFFII)J", (void*)SweepGradient_postCreate2 }
+ { "nativeCreate1", "(FF[I[F)I", (void*)SweepGradient_create1 },
+ { "nativeCreate2", "(FFII)I", (void*)SweepGradient_create2 },
+ { "nativePostCreate1", "(IFF[I[F)I", (void*)SweepGradient_postCreate1 },
+ { "nativePostCreate2", "(IFFII)I", (void*)SweepGradient_postCreate2 }
};
static JNINativeMethod gComposeShaderMethods[] = {
- { "nativeCreate1", "(JJJ)J", (void*)ComposeShader_create1 },
- { "nativeCreate2", "(JJI)J", (void*)ComposeShader_create2 },
- { "nativePostCreate1", "(JJJJ)J", (void*)ComposeShader_postCreate1 },
- { "nativePostCreate2", "(JJJI)J", (void*)ComposeShader_postCreate2 }
+ { "nativeCreate1", "(III)I", (void*)ComposeShader_create1 },
+ { "nativeCreate2", "(III)I", (void*)ComposeShader_create2 },
+ { "nativePostCreate1", "(IIII)I", (void*)ComposeShader_postCreate1 },
+ { "nativePostCreate2", "(IIII)I", (void*)ComposeShader_postCreate2 }
};
#include <android_runtime/AndroidRuntime.h>
const char* fCStr;
};
-static jlong Typeface_create(JNIEnv* env, jobject, jstring name,
- jint styleHandle) {
- SkTypeface::Style style = static_cast<SkTypeface::Style>(styleHandle);
+static TypefaceImpl* Typeface_create(JNIEnv* env, jobject, jstring name,
+ SkTypeface::Style style) {
TypefaceImpl* face = NULL;
if (NULL != name) {
if (NULL == face) {
face = TypefaceImpl_createFromName(NULL, style);
}
- return reinterpret_cast<jlong>(face);
+ return face;
}
-static jlong Typeface_createFromTypeface(JNIEnv* env, jobject, jlong familyHandle, jint style) {
- SkTypeface* family = reinterpret_cast<SkTypeface*>(familyHandle);
+static TypefaceImpl* Typeface_createFromTypeface(JNIEnv* env, jobject, TypefaceImpl* family, int style) {
TypefaceImpl* face = TypefaceImpl_createFromTypeface(family, (SkTypeface::Style)style);
// Try to find the closest matching font, using the standard heuristic
if (NULL == face) {
if (NULL == face) {
face = TypefaceImpl_createFromName(NULL, (SkTypeface::Style)style);
}
- return reinterpret_cast<jlong>(face);
+ return face;
}
-static void Typeface_unref(JNIEnv* env, jobject obj, jlong faceHandle) {
- TypefaceImpl* face = reinterpret_cast<TypefaceImpl*>(faceHandle);
+static void Typeface_unref(JNIEnv* env, jobject obj, TypefaceImpl* face) {
TypefaceImpl_unref(face);
}
-static jint Typeface_getStyle(JNIEnv* env, jobject obj, jlong faceHandle) {
- TypefaceImpl* face = reinterpret_cast<TypefaceImpl*>(faceHandle);
+static int Typeface_getStyle(JNIEnv* env, jobject obj, TypefaceImpl* face) {
return TypefaceImpl_getStyle(face);
}
-static jlong Typeface_createFromAsset(JNIEnv* env, jobject,
- jobject jassetMgr,
- jstring jpath) {
+static TypefaceImpl* Typeface_createFromAsset(JNIEnv* env, jobject,
+ jobject jassetMgr,
+ jstring jpath) {
+
NPE_CHECK_RETURN_ZERO(env, jassetMgr);
NPE_CHECK_RETURN_ZERO(env, jpath);
return NULL;
}
- AutoJavaStringToUTF8 str(env, jpath);
+ AutoJavaStringToUTF8 str(env, jpath);
Asset* asset = mgr->open(str.c_str(), Asset::ACCESS_BUFFER);
if (NULL == asset) {
return NULL;
}
- return reinterpret_cast<jlong>(TypefaceImpl_createFromAsset(asset));
+ return TypefaceImpl_createFromAsset(asset);
}
-static jlong Typeface_createFromFile(JNIEnv* env, jobject, jstring jpath) {
+static TypefaceImpl* Typeface_createFromFile(JNIEnv* env, jobject, jstring jpath) {
NPE_CHECK_RETURN_ZERO(env, jpath);
AutoJavaStringToUTF8 str(env, jpath);
- return reinterpret_cast<jlong>(TypefaceImpl_createFromFile(str.c_str()));
+
+ return TypefaceImpl_createFromFile(str.c_str());
}
///////////////////////////////////////////////////////////////////////////////
static JNINativeMethod gTypefaceMethods[] = {
- { "nativeCreate", "(Ljava/lang/String;I)J", (void*)Typeface_create },
- { "nativeCreateFromTypeface", "(JI)J", (void*)Typeface_createFromTypeface },
- { "nativeUnref", "(J)V", (void*)Typeface_unref },
- { "nativeGetStyle", "(J)I", (void*)Typeface_getStyle },
- { "nativeCreateFromAsset", "(Landroid/content/res/AssetManager;Ljava/lang/String;)J",
+ { "nativeCreate", "(Ljava/lang/String;I)I", (void*)Typeface_create },
+ { "nativeCreateFromTypeface", "(II)I", (void*)Typeface_createFromTypeface },
+ { "nativeUnref", "(I)V", (void*)Typeface_unref },
+ { "nativeGetStyle", "(I)I", (void*)Typeface_getStyle },
+ { "nativeCreateFromAsset", "(Landroid/content/res/AssetManager;Ljava/lang/String;)I",
(void*)Typeface_createFromAsset },
- { "nativeCreateFromFile", "(Ljava/lang/String;)J",
+ { "nativeCreateFromFile", "(Ljava/lang/String;)I",
(void*)Typeface_createFromFile },
};
class SkXfermodeGlue {
public:
- static void finalizer(JNIEnv* env, jobject, jlong objHandle)
+ static void finalizer(JNIEnv* env, jobject, SkXfermode* obj)
{
- SkXfermode* obj = reinterpret_cast<SkXfermode *>(objHandle);
SkSafeUnref(obj);
}
- static jlong avoid_create(JNIEnv* env, jobject, jint opColor,
- jint tolerance, jint modeHandle)
+ static SkXfermode* avoid_create(JNIEnv* env, jobject, SkColor opColor,
+ U8CPU tolerance, SkAvoidXfermode::Mode mode)
{
- SkAvoidXfermode::Mode mode = static_cast<SkAvoidXfermode::Mode>(modeHandle);
- return reinterpret_cast<jlong>(new SkAvoidXfermode(opColor, tolerance, mode));
+ return new SkAvoidXfermode(opColor, tolerance, mode);
}
-
- static jlong pixelxor_create(JNIEnv* env, jobject, jint opColor)
+
+ static SkXfermode* pixelxor_create(JNIEnv* env, jobject, SkColor opColor)
{
- return reinterpret_cast<jlong>(new SkPixelXorXfermode(opColor));
+ return new SkPixelXorXfermode(opColor);
}
};
///////////////////////////////////////////////////////////////////////////////
static JNINativeMethod gXfermodeMethods[] = {
- {"finalizer", "(J)V", (void*) SkXfermodeGlue::finalizer}
+ {"finalizer", "(I)V", (void*) SkXfermodeGlue::finalizer}
};
static JNINativeMethod gAvoidMethods[] = {
- {"nativeCreate", "(III)J", (void*) SkXfermodeGlue::avoid_create}
+ {"nativeCreate", "(III)I", (void*) SkXfermodeGlue::avoid_create}
};
static JNINativeMethod gPixelXorMethods[] = {
- {"nativeCreate", "(I)J", (void*) SkXfermodeGlue::pixelxor_create}
+ {"nativeCreate", "(I)I", (void*) SkXfermodeGlue::pixelxor_create}
};
#include <android_runtime/AndroidRuntime.h>
}
static
-jint util_frustumCullSpheres(JNIEnv *env, jclass clazz,
+int util_frustumCullSpheres(JNIEnv *env, jclass clazz,
jfloatArray mvp_ref, jint mvpOffset,
jfloatArray spheres_ref, jint spheresOffset, jint spheresCount,
jintArray results_ref, jint resultsOffset, jint resultsCapacity) {
*/
static
-jint util_visibilityTest(JNIEnv *env, jclass clazz,
+int util_visibilityTest(JNIEnv *env, jclass clazz,
jfloatArray ws_ref, jint wsOffset,
jfloatArray positions_ref, jint positionsOffset,
jcharArray indices_ref, jint indicesOffset, jint indexCount) {
void nativeUtilsClassInit(JNIEnv *env, jclass clazz)
{
jclass bitmapClass = env->FindClass("android/graphics/Bitmap");
- nativeBitmapID = env->GetFieldID(bitmapClass, "mNativeBitmap", "J");
+ nativeBitmapID = env->GetFieldID(bitmapClass, "mNativeBitmap", "I");
}
extern void setGLDebugLevel(int level);
jobject jbitmap)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)env->GetLongField(jbitmap, nativeBitmapID);
+ (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
SkBitmap::Config config = bitmap.config();
return getInternalFormat(config);
jobject jbitmap)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)env->GetLongField(jbitmap, nativeBitmapID);
+ (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
SkBitmap::Config config = bitmap.config();
return getType(config);
jobject jbitmap, jint type, jint border)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)env->GetLongField(jbitmap, nativeBitmapID);
+ (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
SkBitmap::Config config = bitmap.config();
if (internalformat < 0) {
jobject jbitmap, jint format, jint type)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)env->GetLongField(jbitmap, nativeBitmapID);
+ (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
SkBitmap::Config config = bitmap.config();
if (format < 0) {
pointer = _env->CallStaticLongMethod(nioAccessClass,
getBasePointerID, buffer);
if (pointer != 0L) {
- return reinterpret_cast<void *>(pointer);
+ return (void *) (jint) pointer;
}
return NULL;
}
result = etc1_pkm_is_valid((etc1_byte*) headerB.getData());
}
}
- return result ? JNI_TRUE : JNI_FALSE;
+ return result;
}
/**
/**
* Read the image height from a PKM header
*/
-static jint etc1_getHeight(JNIEnv *env, jclass clazz,
+static int etc1_getHeight(JNIEnv *env, jclass clazz,
jobject header) {
jint result = 0;
BufferHelper headerB(env, header);
// ----------------------------------------------------------------------------
static void android_view_DisplayList_reset(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->reset();
}
static jint android_view_DisplayList_getDisplayListSize(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getSize();
}
static void android_view_DisplayList_setDisplayListName(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jstring name) {
+ jobject clazz, jint displayListPtr, jstring name) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
if (name != NULL) {
const char* textArray = env->GetStringUTFChars(name, NULL);
}
static void android_view_DisplayList_output(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->output();
}
static void android_view_DisplayList_destroyDisplayList(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
DisplayList::destroyDisplayListDeferred(displayList);
}
// ----------------------------------------------------------------------------
static void android_view_DisplayList_setCaching(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean caching) {
+ jobject clazz, jint displayListPtr, jboolean caching) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setCaching(caching);
}
static void android_view_DisplayList_setStaticMatrix(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jlong matrixPtr) {
+ jobject clazz, jint displayListPtr, jint matrixPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
displayList->setStaticMatrix(matrix);
}
static void android_view_DisplayList_setAnimationMatrix(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jlong matrixPtr) {
+ jobject clazz, jint displayListPtr, jint matrixPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
displayList->setAnimationMatrix(matrix);
}
static void android_view_DisplayList_setClipToBounds(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean clipToBounds) {
+ jobject clazz, jint displayListPtr, jboolean clipToBounds) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setClipToBounds(clipToBounds);
}
static void android_view_DisplayList_setIsContainedVolume(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean isContainedVolume) {
+ jobject clazz, jint displayListPtr, jboolean isContainedVolume) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setIsContainedVolume(isContainedVolume);
}
static void android_view_DisplayList_setProjectToContainedVolume(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean shouldProject) {
+ jobject clazz, jint displayListPtr, jboolean shouldProject) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setProjectToContainedVolume(shouldProject);
}
static void android_view_DisplayList_setAlpha(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float alpha) {
+ jobject clazz, jint displayListPtr, float alpha) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setAlpha(alpha);
}
static void android_view_DisplayList_setHasOverlappingRendering(JNIEnv* env,
- jobject clazz, jlong displayListPtr, bool hasOverlappingRendering) {
+ jobject clazz, jint displayListPtr, bool hasOverlappingRendering) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setHasOverlappingRendering(hasOverlappingRendering);
}
static void android_view_DisplayList_setTranslationX(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float tx) {
+ jobject clazz, jint displayListPtr, float tx) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setTranslationX(tx);
}
static void android_view_DisplayList_setTranslationY(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float ty) {
+ jobject clazz, jint displayListPtr, float ty) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setTranslationY(ty);
}
static void android_view_DisplayList_setTranslationZ(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float tz) {
+ jobject clazz, jint displayListPtr, float tz) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setTranslationZ(tz);
}
static void android_view_DisplayList_setRotation(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float rotation) {
+ jobject clazz, jint displayListPtr, float rotation) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setRotation(rotation);
}
static void android_view_DisplayList_setRotationX(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float rx) {
+ jobject clazz, jint displayListPtr, float rx) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setRotationX(rx);
}
static void android_view_DisplayList_setRotationY(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float ry) {
+ jobject clazz, jint displayListPtr, float ry) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setRotationY(ry);
}
static void android_view_DisplayList_setScaleX(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float sx) {
+ jobject clazz, jint displayListPtr, float sx) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setScaleX(sx);
}
static void android_view_DisplayList_setScaleY(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float sy) {
+ jobject clazz, jint displayListPtr, float sy) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setScaleY(sy);
}
static void android_view_DisplayList_setTransformationInfo(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float alpha,
+ jobject clazz, jint displayListPtr, float alpha,
float translationX, float translationY, float translationZ,
float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
}
static void android_view_DisplayList_setPivotX(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float px) {
+ jobject clazz, jint displayListPtr, float px) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setPivotX(px);
}
static void android_view_DisplayList_setPivotY(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float py) {
+ jobject clazz, jint displayListPtr, float py) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setPivotY(py);
}
static void android_view_DisplayList_setCameraDistance(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float distance) {
+ jobject clazz, jint displayListPtr, float distance) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setCameraDistance(distance);
}
static void android_view_DisplayList_setLeft(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int left) {
+ jobject clazz, jint displayListPtr, int left) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setLeft(left);
}
static void android_view_DisplayList_setTop(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int top) {
+ jobject clazz, jint displayListPtr, int top) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setTop(top);
}
static void android_view_DisplayList_setRight(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int right) {
+ jobject clazz, jint displayListPtr, int right) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setRight(right);
}
static void android_view_DisplayList_setBottom(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int bottom) {
+ jobject clazz, jint displayListPtr, int bottom) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setBottom(bottom);
}
static void android_view_DisplayList_setLeftTopRightBottom(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int left, int top,
+ jobject clazz, jint displayListPtr, int left, int top,
int right, int bottom) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setLeftTopRightBottom(left, top, right, bottom);
}
static void android_view_DisplayList_offsetLeftAndRight(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float offset) {
+ jobject clazz, jint displayListPtr, float offset) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->offsetLeftRight(offset);
}
static void android_view_DisplayList_offsetTopAndBottom(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float offset) {
+ jobject clazz, jint displayListPtr, float offset) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->offsetTopBottom(offset);
}
static void android_view_DisplayList_getMatrix(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jlong matrixPtr) {
+ jobject clazz, jint displayListPtr, jint matrixPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
SkMatrix* source = displayList->getStaticMatrix();
}
static jboolean android_view_DisplayList_hasOverlappingRendering(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->hasOverlappingRendering();
}
static jfloat android_view_DisplayList_getAlpha(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getAlpha();
}
static jfloat android_view_DisplayList_getLeft(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getLeft();
}
static jfloat android_view_DisplayList_getTop(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getTop();
}
static jfloat android_view_DisplayList_getRight(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getRight();
}
static jfloat android_view_DisplayList_getBottom(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getBottom();
}
static jfloat android_view_DisplayList_getCameraDistance(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getCameraDistance();
}
static jfloat android_view_DisplayList_getScaleX(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getScaleX();
}
static jfloat android_view_DisplayList_getScaleY(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getScaleY();
}
static jfloat android_view_DisplayList_getTranslationX(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getTranslationX();
}
static jfloat android_view_DisplayList_getTranslationY(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getTranslationY();
}
static jfloat android_view_DisplayList_getRotation(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getRotation();
}
static jfloat android_view_DisplayList_getRotationX(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getRotationX();
}
static jfloat android_view_DisplayList_getRotationY(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getRotationY();
}
static jfloat android_view_DisplayList_getPivotX(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getPivotX();
}
static jfloat android_view_DisplayList_getPivotY(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
+ jobject clazz, jint displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getPivotY();
}
static JNINativeMethod gMethods[] = {
#ifdef USE_OPENGL_RENDERER
- { "nDestroyDisplayList", "(J)V", (void*) android_view_DisplayList_destroyDisplayList },
- { "nGetDisplayListSize", "(J)I", (void*) android_view_DisplayList_getDisplayListSize },
- { "nSetDisplayListName", "(JLjava/lang/String;)V",
+ { "nDestroyDisplayList", "(I)V", (void*) android_view_DisplayList_destroyDisplayList },
+ { "nGetDisplayListSize", "(I)I", (void*) android_view_DisplayList_getDisplayListSize },
+ { "nSetDisplayListName", "(ILjava/lang/String;)V",
(void*) android_view_DisplayList_setDisplayListName },
- { "nOutput", "(J)V", (void*) android_view_DisplayList_output },
-
- { "nReset", "(J)V", (void*) android_view_DisplayList_reset },
- { "nSetCaching", "(JZ)V", (void*) android_view_DisplayList_setCaching },
- { "nSetStaticMatrix", "(JJ)V", (void*) android_view_DisplayList_setStaticMatrix },
- { "nSetAnimationMatrix", "(JJ)V", (void*) android_view_DisplayList_setAnimationMatrix },
- { "nSetClipToBounds", "(JZ)V", (void*) android_view_DisplayList_setClipToBounds },
- { "nSetIsContainedVolume", "(JZ)V", (void*) android_view_DisplayList_setIsContainedVolume },
- { "nSetProjectToContainedVolume", "(JZ)V",
+ { "nOutput", "(I)V", (void*) android_view_DisplayList_output },
+
+ { "nReset", "(I)V", (void*) android_view_DisplayList_reset },
+ { "nSetCaching", "(IZ)V", (void*) android_view_DisplayList_setCaching },
+ { "nSetStaticMatrix", "(II)V", (void*) android_view_DisplayList_setStaticMatrix },
+ { "nSetAnimationMatrix", "(II)V", (void*) android_view_DisplayList_setAnimationMatrix },
+ { "nSetClipToBounds", "(IZ)V", (void*) android_view_DisplayList_setClipToBounds },
+ { "nSetIsContainedVolume", "(IZ)V", (void*) android_view_DisplayList_setIsContainedVolume },
+ { "nSetProjectToContainedVolume", "(IZ)V",
(void*) android_view_DisplayList_setProjectToContainedVolume },
- { "nSetAlpha", "(JF)V", (void*) android_view_DisplayList_setAlpha },
- { "nSetHasOverlappingRendering", "(JZ)V",
+ { "nSetAlpha", "(IF)V", (void*) android_view_DisplayList_setAlpha },
+ { "nSetHasOverlappingRendering", "(IZ)V",
(void*) android_view_DisplayList_setHasOverlappingRendering },
- { "nSetTranslationX", "(JF)V", (void*) android_view_DisplayList_setTranslationX },
- { "nSetTranslationY", "(JF)V", (void*) android_view_DisplayList_setTranslationY },
- { "nSetTranslationZ", "(JF)V", (void*) android_view_DisplayList_setTranslationZ },
- { "nSetRotation", "(JF)V", (void*) android_view_DisplayList_setRotation },
- { "nSetRotationX", "(JF)V", (void*) android_view_DisplayList_setRotationX },
- { "nSetRotationY", "(JF)V", (void*) android_view_DisplayList_setRotationY },
- { "nSetScaleX", "(JF)V", (void*) android_view_DisplayList_setScaleX },
- { "nSetScaleY", "(JF)V", (void*) android_view_DisplayList_setScaleY },
- { "nSetTransformationInfo","(JFFFFFFFFF)V",
+ { "nSetTranslationX", "(IF)V", (void*) android_view_DisplayList_setTranslationX },
+ { "nSetTranslationY", "(IF)V", (void*) android_view_DisplayList_setTranslationY },
+ { "nSetTranslationZ", "(IF)V", (void*) android_view_DisplayList_setTranslationZ },
+ { "nSetRotation", "(IF)V", (void*) android_view_DisplayList_setRotation },
+ { "nSetRotationX", "(IF)V", (void*) android_view_DisplayList_setRotationX },
+ { "nSetRotationY", "(IF)V", (void*) android_view_DisplayList_setRotationY },
+ { "nSetScaleX", "(IF)V", (void*) android_view_DisplayList_setScaleX },
+ { "nSetScaleY", "(IF)V", (void*) android_view_DisplayList_setScaleY },
+ { "nSetTransformationInfo","(IFFFFFFFFF)V",
(void*) android_view_DisplayList_setTransformationInfo },
- { "nSetPivotX", "(JF)V", (void*) android_view_DisplayList_setPivotX },
- { "nSetPivotY", "(JF)V", (void*) android_view_DisplayList_setPivotY },
- { "nSetCameraDistance", "(JF)V", (void*) android_view_DisplayList_setCameraDistance },
- { "nSetLeft", "(JI)V", (void*) android_view_DisplayList_setLeft },
- { "nSetTop", "(JI)V", (void*) android_view_DisplayList_setTop },
- { "nSetRight", "(JI)V", (void*) android_view_DisplayList_setRight },
- { "nSetBottom", "(JI)V", (void*) android_view_DisplayList_setBottom },
- { "nSetLeftTopRightBottom","(JIIII)V", (void*) android_view_DisplayList_setLeftTopRightBottom },
- { "nOffsetLeftAndRight", "(JF)V", (void*) android_view_DisplayList_offsetLeftAndRight },
- { "nOffsetTopAndBottom", "(JF)V", (void*) android_view_DisplayList_offsetTopAndBottom },
-
- { "nGetMatrix", "(JJ)V", (void*) android_view_DisplayList_getMatrix },
- { "nHasOverlappingRendering", "(J)Z", (void*) android_view_DisplayList_hasOverlappingRendering },
- { "nGetAlpha", "(J)F", (void*) android_view_DisplayList_getAlpha },
- { "nGetLeft", "(J)F", (void*) android_view_DisplayList_getLeft },
- { "nGetTop", "(J)F", (void*) android_view_DisplayList_getTop },
- { "nGetRight", "(J)F", (void*) android_view_DisplayList_getRight },
- { "nGetBottom", "(J)F", (void*) android_view_DisplayList_getBottom },
- { "nGetCameraDistance", "(J)F", (void*) android_view_DisplayList_getCameraDistance },
- { "nGetScaleX", "(J)F", (void*) android_view_DisplayList_getScaleX },
- { "nGetScaleY", "(J)F", (void*) android_view_DisplayList_getScaleY },
- { "nGetTranslationX", "(J)F", (void*) android_view_DisplayList_getTranslationX },
- { "nGetTranslationY", "(J)F", (void*) android_view_DisplayList_getTranslationY },
- { "nGetRotation", "(J)F", (void*) android_view_DisplayList_getRotation },
- { "nGetRotationX", "(J)F", (void*) android_view_DisplayList_getRotationX },
- { "nGetRotationY", "(J)F", (void*) android_view_DisplayList_getRotationY },
- { "nGetPivotX", "(J)F", (void*) android_view_DisplayList_getPivotX },
- { "nGetPivotY", "(J)F", (void*) android_view_DisplayList_getPivotY },
+ { "nSetPivotX", "(IF)V", (void*) android_view_DisplayList_setPivotX },
+ { "nSetPivotY", "(IF)V", (void*) android_view_DisplayList_setPivotY },
+ { "nSetCameraDistance", "(IF)V", (void*) android_view_DisplayList_setCameraDistance },
+ { "nSetLeft", "(II)V", (void*) android_view_DisplayList_setLeft },
+ { "nSetTop", "(II)V", (void*) android_view_DisplayList_setTop },
+ { "nSetRight", "(II)V", (void*) android_view_DisplayList_setRight },
+ { "nSetBottom", "(II)V", (void*) android_view_DisplayList_setBottom },
+ { "nSetLeftTopRightBottom","(IIIII)V", (void*) android_view_DisplayList_setLeftTopRightBottom },
+ { "nOffsetLeftAndRight", "(IF)V", (void*) android_view_DisplayList_offsetLeftAndRight },
+ { "nOffsetTopAndBottom", "(IF)V", (void*) android_view_DisplayList_offsetTopAndBottom },
+
+ { "nGetMatrix", "(II)V", (void*) android_view_DisplayList_getMatrix },
+ { "nHasOverlappingRendering", "(I)Z", (void*) android_view_DisplayList_hasOverlappingRendering },
+ { "nGetAlpha", "(I)F", (void*) android_view_DisplayList_getAlpha },
+ { "nGetLeft", "(I)F", (void*) android_view_DisplayList_getLeft },
+ { "nGetTop", "(I)F", (void*) android_view_DisplayList_getTop },
+ { "nGetRight", "(I)F", (void*) android_view_DisplayList_getRight },
+ { "nGetBottom", "(I)F", (void*) android_view_DisplayList_getBottom },
+ { "nGetCameraDistance", "(I)F", (void*) android_view_DisplayList_getCameraDistance },
+ { "nGetScaleX", "(I)F", (void*) android_view_DisplayList_getScaleX },
+ { "nGetScaleY", "(I)F", (void*) android_view_DisplayList_getScaleY },
+ { "nGetTranslationX", "(I)F", (void*) android_view_DisplayList_getTranslationX },
+ { "nGetTranslationY", "(I)F", (void*) android_view_DisplayList_getTranslationY },
+ { "nGetRotation", "(I)F", (void*) android_view_DisplayList_getRotation },
+ { "nGetRotationX", "(I)F", (void*) android_view_DisplayList_getRotationX },
+ { "nGetRotationY", "(I)F", (void*) android_view_DisplayList_getRotationY },
+ { "nGetPivotX", "(I)F", (void*) android_view_DisplayList_getPivotX },
+ { "nGetPivotY", "(I)F", (void*) android_view_DisplayList_getPivotY },
#endif
};
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_flushCaches(JNIEnv* env, jobject clazz,
- jint mode) {
+ Caches::FlushMode mode) {
if (Caches::hasInstance()) {
- Caches::getInstance().flush(static_cast<Caches::FlushMode>(mode));
+ Caches::getInstance().flush(mode);
}
}
-static jboolean android_view_GLES20Canvas_initCaches(JNIEnv* env, jobject clazz) {
+static bool android_view_GLES20Canvas_initCaches(JNIEnv* env, jobject clazz) {
if (Caches::hasInstance()) {
- return Caches::getInstance().init() ? JNI_TRUE : JNI_FALSE;
+ return Caches::getInstance().init();
}
- return JNI_FALSE;
+ return false;
}
static void android_view_GLES20Canvas_terminateCaches(JNIEnv* env, jobject clazz) {
// Constructors
// ----------------------------------------------------------------------------
-static jlong android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject clazz) {
+static jint android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject clazz) {
RENDERER_LOGD("Create OpenGLRenderer");
OpenGLRenderer* renderer = new OpenGLRenderer();
renderer->initProperties();
- return reinterpret_cast<jlong>(renderer);
+ return reinterpret_cast<jint>(renderer);
}
static void android_view_GLES20Canvas_destroyRenderer(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
RENDERER_LOGD("Destroy OpenGLRenderer");
delete renderer;
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_setViewport(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint width, jint height) {
+ jint rendererPtr, jint width, jint height) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->setViewport(width, height);
}
static int android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jboolean opaque) {
+ jint rendererPtr, jboolean opaque) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->prepare(opaque);
}
static int android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint left, jint top, jint right, jint bottom,
+ jint rendererPtr, jint left, jint top, jint right, jint bottom,
jboolean opaque) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->prepareDirty(left, top, right, bottom, opaque);
}
static void android_view_GLES20Canvas_finish(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->finish();
}
}
static void android_view_GLES20Canvas_setCountOverdrawEnabled(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jboolean enabled) {
+ jint rendererPtr, jboolean enabled) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->setCountOverdrawEnabled(enabled);
}
static jfloat android_view_GLES20Canvas_getOverdraw(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->getOverdraw();
}
// ----------------------------------------------------------------------------
static jint android_view_GLES20Canvas_callDrawGLFunction(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong functorPtr) {
+ jint rendererPtr, jint functorPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
Functor* functor = reinterpret_cast<Functor*>(functorPtr);
android::uirenderer::Rect dirty;
}
static void android_view_GLES20Canvas_detachFunctor(JNIEnv* env,
- jobject clazz, jlong rendererPtr, jint functorPtr) {
+ jobject clazz, jint rendererPtr, jint functorPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
Functor* functor = reinterpret_cast<Functor*>(functorPtr);
renderer->detachFunctor(functor);
}
static void android_view_GLES20Canvas_attachFunctor(JNIEnv* env,
- jobject clazz, jlong rendererPtr, jlong functorPtr) {
+ jobject clazz, jint rendererPtr, jint functorPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
Functor* functor = reinterpret_cast<Functor*>(functorPtr);
renderer->attachFunctor(functor);
}
static jint android_view_GLES20Canvas_invokeFunctors(JNIEnv* env,
- jobject clazz, jlong rendererPtr, jobject dirty) {
+ jobject clazz, jint rendererPtr, jobject dirty) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
android::uirenderer::Rect bounds;
status_t status = renderer->invokeFunctors(bounds);
// State
// ----------------------------------------------------------------------------
-static jint android_view_GLES20Canvas_save(JNIEnv* env, jobject clazz, jlong rendererPtr,
+static jint android_view_GLES20Canvas_save(JNIEnv* env, jobject clazz, jint rendererPtr,
jint flags) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->save(flags);
}
static jint android_view_GLES20Canvas_getSaveCount(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->getSaveCount();
}
static void android_view_GLES20Canvas_restore(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->restore();
}
static void android_view_GLES20Canvas_restoreToCount(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint saveCount) {
+ jint rendererPtr, jint saveCount) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->restoreToCount(saveCount);
}
// ----------------------------------------------------------------------------
static jint android_view_GLES20Canvas_saveLayer(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
- jlong paintPtr, jint saveFlags) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint paintPtr, jint saveFlags) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
return renderer->saveLayer(left, top, right, bottom, paint, saveFlags);
}
static jint android_view_GLES20Canvas_saveLayerClip(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong paintPtr, jint saveFlags) {
+ jint rendererPtr, jint paintPtr, jint saveFlags) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
const android::uirenderer::Rect& bounds(renderer->getClipBounds());
}
static jint android_view_GLES20Canvas_saveLayerAlpha(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
jint alpha, jint saveFlags) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->saveLayerAlpha(left, top, right, bottom, alpha, saveFlags);
}
static jint android_view_GLES20Canvas_saveLayerAlphaClip(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint alpha, jint saveFlags) {
+ jint rendererPtr, jint alpha, jint saveFlags) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const android::uirenderer::Rect& bounds(renderer->getClipBounds());
return renderer->saveLayerAlpha(bounds.left, bounds.top, bounds.right, bounds.bottom,
// Clipping
// ----------------------------------------------------------------------------
-static jboolean android_view_GLES20Canvas_quickReject(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom) {
+static bool android_view_GLES20Canvas_quickReject(JNIEnv* env, jobject clazz,
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
- const bool result = renderer->quickRejectConservative(left, top, right, bottom);
- return result ? JNI_TRUE : JNI_FALSE;
+ return renderer->quickRejectConservative(left, top, right, bottom);
}
-static jboolean android_view_GLES20Canvas_clipRectF(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+static bool android_view_GLES20Canvas_clipRectF(JNIEnv* env, jobject clazz,
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
SkRegion::Op op) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
- const bool result = renderer->clipRect(left, top, right, bottom, op);
- return result ? JNI_TRUE : JNI_FALSE;
+ return renderer->clipRect(left, top, right, bottom, op);
}
-static jboolean android_view_GLES20Canvas_clipRect(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint left, jint top, jint right, jint bottom,
+static bool android_view_GLES20Canvas_clipRect(JNIEnv* env, jobject clazz,
+ jint rendererPtr, jint left, jint top, jint right, jint bottom,
SkRegion::Op op) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
- const bool result = renderer->clipRect(float(left), float(top), float(right),
- float(bottom), op);
- return result ? JNI_TRUE : JNI_FALSE;
+ return renderer->clipRect(float(left), float(top), float(right), float(bottom), op);
}
-static jboolean android_view_GLES20Canvas_clipPath(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint pathPtr, SkRegion::Op op) {
+static bool android_view_GLES20Canvas_clipPath(JNIEnv* env, jobject clazz,
+ jint rendererPtr, jint pathPtr, SkRegion::Op op) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
- const bool result = renderer->clipPath(path, op);
- return result ? JNI_TRUE : JNI_FALSE;
+ return renderer->clipPath(path, op);
}
-static jboolean android_view_GLES20Canvas_clipRegion(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint regionPtr, SkRegion::Op op) {
+static bool android_view_GLES20Canvas_clipRegion(JNIEnv* env, jobject clazz,
+ jint rendererPtr, jint regionPtr, SkRegion::Op op) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkRegion* region = reinterpret_cast<SkRegion*>(regionPtr);
- const bool result = renderer->clipRegion(region, op);
- return result ? JNI_TRUE : JNI_FALSE;
+ return renderer->clipRegion(region, op);
}
-static jboolean android_view_GLES20Canvas_getClipBounds(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jobject rect) {
+static bool android_view_GLES20Canvas_getClipBounds(JNIEnv* env, jobject clazz,
+ jint rendererPtr, jobject rect) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const android::uirenderer::Rect& bounds(renderer->getClipBounds());
env->CallVoidMethod(rect, gRectClassInfo.set,
int(bounds.left), int(bounds.top), int(bounds.right), int(bounds.bottom));
- return !bounds.isEmpty() ? JNI_TRUE : JNI_FALSE;
+ return !bounds.isEmpty();
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_translate(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat dx, jfloat dy) {
+ jint rendererPtr, jfloat dx, jfloat dy) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->translate(dx, dy);
}
static void android_view_GLES20Canvas_rotate(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat degrees) {
+ jint rendererPtr, jfloat degrees) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->rotate(degrees);
}
static void android_view_GLES20Canvas_scale(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat sx, jfloat sy) {
+ jint rendererPtr, jfloat sx, jfloat sy) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->scale(sx, sy);
}
static void android_view_GLES20Canvas_skew(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat sx, jfloat sy) {
+ jint rendererPtr, jfloat sx, jfloat sy) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->skew(sx, sy);
}
static void android_view_GLES20Canvas_setMatrix(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong matrixPtr) {
+ jint rendererPtr, jint matrixPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
renderer->setMatrix(matrix);
}
static void android_view_GLES20Canvas_getMatrix(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong matrixPtr) {
+ jint rendererPtr, jint matrixPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
renderer->getMatrix(matrix);
}
static void android_view_GLES20Canvas_concatMatrix(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong matrixPtr) {
+ jint rendererPtr, jint matrixPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
renderer->concatMatrix(matrix);
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_drawBitmap(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong bitmapPtr, jbyteArray buffer,
- jfloat left, jfloat top, jlong paintPtr) {
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer,
+ jfloat left, jfloat top, jint paintPtr) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
}
static void android_view_GLES20Canvas_drawBitmapRect(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong bitmapPtr, jbyteArray buffer,
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer,
float srcLeft, float srcTop, float srcRight, float srcBottom,
- float dstLeft, float dstTop, float dstRight, float dstBottom, jlong paintPtr) {
+ float dstLeft, float dstTop, float dstRight, float dstBottom, jint paintPtr) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
}
static void android_view_GLES20Canvas_drawBitmapMatrix(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong bitmapPtr, jbyteArray buffer,
- jlong matrixPtr, jlong paintPtr) {
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer,
+ jint matrixPtr, jint paintPtr) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
}
static void android_view_GLES20Canvas_drawBitmapData(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jintArray colors, jint offset, jint stride,
- jfloat left, jfloat top, jint width, jint height, jboolean hasAlpha, jlong paintPtr) {
+ jint rendererPtr, jintArray colors, jint offset, jint stride,
+ jfloat left, jfloat top, jint width, jint height, jboolean hasAlpha, jint paintPtr) {
SkBitmap* bitmap = new SkBitmap;
bitmap->setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config : SkBitmap::kRGB_565_Config,
width, height);
}
static void android_view_GLES20Canvas_drawBitmapMesh(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong bitmapPtr, jbyteArray buffer,
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer,
jint meshWidth, jint meshHeight, jfloatArray vertices, jint offset, jintArray colors,
- jint colorOffset, jlong paintPtr) {
+ jint colorOffset, jint paintPtr) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
}
static void android_view_GLES20Canvas_drawPatch(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong bitmapPtr, jbyteArray buffer, jlong patchPtr,
- float left, float top, float right, float bottom, jlong paintPtr) {
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer, jint patchPtr,
+ float left, float top, float right, float bottom, jint paintPtr) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
}
static void android_view_GLES20Canvas_drawColor(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint color, jint mode) {
+ jint rendererPtr, jint color, SkXfermode::Mode mode) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
- renderer->drawColor(color, static_cast<SkXfermode::Mode>(mode));
+ renderer->drawColor(color, mode);
}
static void android_view_GLES20Canvas_drawRect(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
- jlong paintPtr) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawRect(left, top, right, bottom, paint);
}
static void android_view_GLES20Canvas_drawRoundRect(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
- jfloat rx, jfloat ry, jlong paintPtr) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jfloat rx, jfloat ry, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawRoundRect(left, top, right, bottom, rx, ry, paint);
}
static void android_view_GLES20Canvas_drawCircle(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat x, jfloat y, jfloat radius, jlong paintPtr) {
+ jint rendererPtr, jfloat x, jfloat y, jfloat radius, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawCircle(x, y, radius, paint);
}
static void android_view_GLES20Canvas_drawOval(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
- jlong paintPtr) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawOval(left, top, right, bottom, paint);
}
static void android_view_GLES20Canvas_drawArc(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
- jfloat startAngle, jfloat sweepAngle, jboolean useCenter, jlong paintPtr) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jfloat startAngle, jfloat sweepAngle, jboolean useCenter, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawArc(left, top, right, bottom, startAngle, sweepAngle, useCenter, paint);
}
static void android_view_GLES20Canvas_drawRegionAsRects(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong regionPtr, jlong paintPtr) {
+ jint rendererPtr, jint regionPtr, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkRegion* region = reinterpret_cast<SkRegion*>(regionPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
}
static void android_view_GLES20Canvas_drawRects(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloatArray rects, jint count, jlong paintPtr) {
+ jint rendererPtr, jfloatArray rects, jint count, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jfloat* storage = env->GetFloatArrayElements(rects, NULL);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
}
static void android_view_GLES20Canvas_drawPoints(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloatArray points, jint offset, jint count, jlong paintPtr) {
+ jint rendererPtr, jfloatArray points, jint offset, jint count, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jfloat* storage = env->GetFloatArrayElements(points, NULL);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
}
static void android_view_GLES20Canvas_drawPath(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong pathPtr, jlong paintPtr) {
+ jint rendererPtr, jint pathPtr, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
}
static void android_view_GLES20Canvas_drawLines(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloatArray points, jint offset, jint count, jlong paintPtr) {
+ jint rendererPtr, jfloatArray points, jint offset, jint count, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jfloat* storage = env->GetFloatArrayElements(points, NULL);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_resetModifiers(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint modifiers) {
+ jint rendererPtr, jint modifiers) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
if (modifiers & MODIFIER_SHADOW) renderer->resetShadow();
if (modifiers & MODIFIER_SHADER) renderer->resetShader();
}
static void android_view_GLES20Canvas_setupShader(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong shaderPtr) {
+ jint rendererPtr, jint shaderPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkiaShader* shader = reinterpret_cast<SkiaShader*>(shaderPtr);
renderer->setupShader(shader);
}
static void android_view_GLES20Canvas_setupColorFilter(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong colorFilterPtr) {
+ jint rendererPtr, jint colorFilterPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterPtr);
renderer->setupColorFilter(colorFilter);
}
static void android_view_GLES20Canvas_setupShadow(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jfloat radius, jfloat dx, jfloat dy, jint color) {
+ jint rendererPtr, jfloat radius, jfloat dx, jfloat dy, jint color) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->setupShadow(radius, dx, dy, color);
}
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_setupPaintFilter(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jint clearBits, jint setBits) {
+ jint rendererPtr, jint clearBits, jint setBits) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->setupPaintFilter(clearBits, setBits);
}
static void android_view_GLES20Canvas_resetPaintFilter(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->resetPaintFilter();
}
}
static void android_view_GLES20Canvas_drawTextArray(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jcharArray text, jint index, jint count,
- jfloat x, jfloat y, jint flags, jlong paintPtr) {
+ jint rendererPtr, jcharArray text, jint index, jint count,
+ jfloat x, jfloat y, jint flags, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jchar* textArray = env->GetCharArrayElements(text, NULL);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
}
static void android_view_GLES20Canvas_drawText(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jstring text, jint start, jint end,
- jfloat x, jfloat y, jint flags, jlong paintPtr) {
+ jint rendererPtr, jstring text, jint start, jint end,
+ jfloat x, jfloat y, jint flags, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const jchar* textArray = env->GetStringChars(text, NULL);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
}
static void android_view_GLES20Canvas_drawTextArrayOnPath(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jcharArray text, jint index, jint count,
- jlong pathPtr, jfloat hOffset, jfloat vOffset, jint flags, jlong paintPtr) {
+ jint rendererPtr, jcharArray text, jint index, jint count,
+ jint pathPtr, jfloat hOffset, jfloat vOffset, jint flags, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jchar* textArray = env->GetCharArrayElements(text, NULL);
SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
}
static void android_view_GLES20Canvas_drawTextOnPath(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jstring text, jint start, jint end,
- jlong pathPtr, jfloat hOffset, jfloat vOffset, jint flags, jlong paintPtr) {
+ jint rendererPtr, jstring text, jint start, jint end,
+ jint pathPtr, jfloat hOffset, jfloat vOffset, jint flags, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const jchar* textArray = env->GetStringChars(text, NULL);
SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
}
static void android_view_GLES20Canvas_drawTextRunArray(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jcharArray text, jint index, jint count,
+ jint rendererPtr, jcharArray text, jint index, jint count,
jint contextIndex, jint contextCount, jfloat x, jfloat y, jint dirFlags,
- jlong paintPtr) {
+ jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jchar* textArray = env->GetCharArrayElements(text, NULL);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
}
static void android_view_GLES20Canvas_drawTextRun(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jstring text, jint start, jint end,
+ jint rendererPtr, jstring text, jint start, jint end,
jint contextStart, int contextEnd, jfloat x, jfloat y, jint dirFlags,
- jlong paintPtr) {
+ jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const jchar* textArray = env->GetStringChars(text, NULL);
jint count = end - start;
}
static void android_view_GLES20Canvas_drawPosTextArray(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jcharArray text, jint index, jint count,
- jfloatArray pos, jlong paintPtr) {
+ jint rendererPtr, jcharArray text, jint index, jint count,
+ jfloatArray pos, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jchar* textArray = env->GetCharArrayElements(text, NULL);
jfloat* positions = env->GetFloatArrayElements(pos, NULL);
}
static void android_view_GLES20Canvas_drawPosText(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jstring text, jint start, jint end,
- jfloatArray pos, jlong paintPtr) {
+ jint rendererPtr, jstring text, jint start, jint end,
+ jfloatArray pos, jint paintPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const jchar* textArray = env->GetStringChars(text, NULL);
jfloat* positions = env->GetFloatArrayElements(pos, NULL);
// ----------------------------------------------------------------------------
static jint android_view_GLES20Canvas_getDisplayList(JNIEnv* env,
- jobject clazz, jlong rendererPtr, jlong displayListPtr) {
+ jobject clazz, jint rendererPtr, jint displayListPtr) {
DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return reinterpret_cast<jint>(renderer->getDisplayList(displayList));
}
static void android_view_GLES20Canvas_resetDisplayListRenderer(JNIEnv* env,
- jobject clazz, jlong rendererPtr) {
+ jobject clazz, jint rendererPtr) {
DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);
renderer->reset();
}
static jint android_view_GLES20Canvas_drawDisplayList(JNIEnv* env,
- jobject clazz, jlong rendererPtr, jlong displayListPtr,
+ jobject clazz, jint rendererPtr, jint displayListPtr,
jobject dirty, jint flags) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_interrupt(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->interrupt();
}
static void android_view_GLES20Canvas_resume(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->resume();
}
static jint android_view_GLES20Canvas_createLayerRenderer(JNIEnv* env,
- jobject clazz, jlong layerPtr) {
+ jobject clazz, jint layerPtr) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (layer) {
OpenGLRenderer* renderer = new LayerRenderer(layer);
return NULL;
}
-static jlong android_view_GLES20Canvas_createTextureLayer(JNIEnv* env, jobject clazz,
+static jint android_view_GLES20Canvas_createTextureLayer(JNIEnv* env, jobject clazz,
jboolean isOpaque, jintArray layerInfo) {
Layer* layer = LayerRenderer::createTextureLayer(isOpaque);
env->ReleaseIntArrayElements(layerInfo, storage, 0);
}
- return reinterpret_cast<jlong>(layer);
+ return reinterpret_cast<jint>(layer);
}
-static jlong android_view_GLES20Canvas_createLayer(JNIEnv* env, jobject clazz,
+static jint android_view_GLES20Canvas_createLayer(JNIEnv* env, jobject clazz,
jint width, jint height, jboolean isOpaque, jintArray layerInfo) {
Layer* layer = LayerRenderer::createLayer(width, height, isOpaque);
env->ReleaseIntArrayElements(layerInfo, storage, 0);
}
- return reinterpret_cast<jlong>(layer);
+ return reinterpret_cast<jint>(layer);
}
-static jboolean android_view_GLES20Canvas_resizeLayer(JNIEnv* env, jobject clazz,
- jlong layerPtr, jint width, jint height, jintArray layerInfo) {
+static bool android_view_GLES20Canvas_resizeLayer(JNIEnv* env, jobject clazz,
+ jint layerPtr, jint width, jint height, jintArray layerInfo) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (LayerRenderer::resizeLayer(layer, width, height)) {
jint* storage = env->GetIntArrayElements(layerInfo, NULL);
storage[0] = layer->getWidth();
storage[1] = layer->getHeight();
env->ReleaseIntArrayElements(layerInfo, storage, 0);
- return JNI_TRUE;
+ return true;
}
- return JNI_FALSE;
+ return false;
}
static void android_view_GLES20Canvas_setLayerPaint(JNIEnv* env, jobject clazz,
- jlong layerPtr, jlong paintPtr) {
+ jint layerPtr, jint paintPtr) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (layer) {
SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
}
static void android_view_GLES20Canvas_setLayerColorFilter(JNIEnv* env, jobject clazz,
- jlong layerPtr, jint colorFilterPtr) {
+ jint layerPtr, jint colorFilterPtr) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (layer) {
SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterPtr);
}
static void android_view_GLES20Canvas_setOpaqueLayer(JNIEnv* env, jobject clazz,
- jlong layerPtr, jboolean isOpaque) {
+ jint layerPtr, jboolean isOpaque) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (layer) {
layer->setBlend(!isOpaque);
}
static void android_view_GLES20Canvas_updateTextureLayer(JNIEnv* env, jobject clazz,
- jlong layerPtr, jint width, jint height, jboolean isOpaque, jobject surface) {
+ jint layerPtr, jint width, jint height, jboolean isOpaque, jobject surface) {
float transform[16];
sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, surface));
}
static void android_view_GLES20Canvas_updateRenderLayer(JNIEnv* env, jobject clazz,
- jlong layerPtr, jlong rendererPtr, jlong displayListPtr,
+ jint layerPtr, jint rendererPtr, jint displayListPtr,
jint left, jint top, jint right, jint bottom) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
}
static void android_view_GLES20Canvas_clearLayerTexture(JNIEnv* env, jobject clazz,
- jlong layerPtr) {
+ jint layerPtr) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
layer->clearTexture();
}
static void android_view_GLES20Canvas_setTextureLayerTransform(JNIEnv* env, jobject clazz,
- jlong layerPtr, jlong matrixPtr) {
+ jint layerPtr, jint matrixPtr) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
layer->getTransform().load(*matrix);
}
-static void android_view_GLES20Canvas_destroyLayer(JNIEnv* env, jobject clazz, jlong layerPtr) {
+static void android_view_GLES20Canvas_destroyLayer(JNIEnv* env, jobject clazz, jint layerPtr) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
LayerRenderer::destroyLayer(layer);
}
static void android_view_GLES20Canvas_destroyLayerDeferred(JNIEnv* env,
- jobject clazz, jlong layerPtr) {
+ jobject clazz, jint layerPtr) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
LayerRenderer::destroyLayerDeferred(layer);
}
static void android_view_GLES20Canvas_drawLayer(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong layerPtr, jfloat x, jfloat y) {
+ jint rendererPtr, jint layerPtr, jfloat x, jfloat y) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
renderer->drawLayer(layer, x, y);
}
static jboolean android_view_GLES20Canvas_copyLayer(JNIEnv* env, jobject clazz,
- jlong layerPtr, jlong bitmapPtr) {
+ jint layerPtr, jint bitmapPtr) {
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
return LayerRenderer::copyLayer(layer, bitmap);
}
static void android_view_GLES20Canvas_pushLayerUpdate(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong layerPtr) {
+ jint rendererPtr, jint layerPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
renderer->pushLayerUpdate(layer);
}
static void android_view_GLES20Canvas_cancelLayerUpdate(JNIEnv* env, jobject clazz,
- jlong rendererPtr, jlong layerPtr) {
+ jint rendererPtr, jint layerPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
Layer* layer = reinterpret_cast<Layer*>(layerPtr);
renderer->cancelLayerUpdate(layer);
}
static void android_view_GLES20Canvas_clearLayerUpdates(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->clearLayerUpdates();
}
static void android_view_GLES20Canvas_flushLayerUpdates(JNIEnv* env, jobject clazz,
- jlong rendererPtr) {
+ jint rendererPtr) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->flushLayerUpdates();
}
{ "nInitAtlas", "(Landroid/view/GraphicBuffer;[II)V",
(void*) android_view_GLES20Canvas_initAtlas },
- { "nCreateRenderer", "()J", (void*) android_view_GLES20Canvas_createRenderer },
- { "nDestroyRenderer", "(J)V", (void*) android_view_GLES20Canvas_destroyRenderer },
- { "nSetViewport", "(JII)V", (void*) android_view_GLES20Canvas_setViewport },
- { "nPrepare", "(JZ)I", (void*) android_view_GLES20Canvas_prepare },
- { "nPrepareDirty", "(JIIIIZ)I", (void*) android_view_GLES20Canvas_prepareDirty },
- { "nFinish", "(J)V", (void*) android_view_GLES20Canvas_finish },
+ { "nCreateRenderer", "()I", (void*) android_view_GLES20Canvas_createRenderer },
+ { "nDestroyRenderer", "(I)V", (void*) android_view_GLES20Canvas_destroyRenderer },
+ { "nSetViewport", "(III)V", (void*) android_view_GLES20Canvas_setViewport },
+ { "nPrepare", "(IZ)I", (void*) android_view_GLES20Canvas_prepare },
+ { "nPrepareDirty", "(IIIIIZ)I", (void*) android_view_GLES20Canvas_prepareDirty },
+ { "nFinish", "(I)V", (void*) android_view_GLES20Canvas_finish },
{ "nSetProperty", "(Ljava/lang/String;Ljava/lang/String;)V",
(void*) android_view_GLES20Canvas_setProperty },
- { "nSetCountOverdrawEnabled", "(JZ)V", (void*) android_view_GLES20Canvas_setCountOverdrawEnabled },
- { "nGetOverdraw", "(J)F", (void*) android_view_GLES20Canvas_getOverdraw },
+ { "nSetCountOverdrawEnabled", "(IZ)V", (void*) android_view_GLES20Canvas_setCountOverdrawEnabled },
+ { "nGetOverdraw", "(I)F", (void*) android_view_GLES20Canvas_getOverdraw },
{ "nGetStencilSize", "()I", (void*) android_view_GLES20Canvas_getStencilSize },
- { "nCallDrawGLFunction", "(JJ)I", (void*) android_view_GLES20Canvas_callDrawGLFunction },
- { "nDetachFunctor", "(JJ)V", (void*) android_view_GLES20Canvas_detachFunctor },
- { "nAttachFunctor", "(JJ)V", (void*) android_view_GLES20Canvas_attachFunctor },
- { "nInvokeFunctors", "(JLandroid/graphics/Rect;)I",
+ { "nCallDrawGLFunction", "(II)I", (void*) android_view_GLES20Canvas_callDrawGLFunction },
+ { "nDetachFunctor", "(II)V", (void*) android_view_GLES20Canvas_detachFunctor },
+ { "nAttachFunctor", "(II)V", (void*) android_view_GLES20Canvas_attachFunctor },
+ { "nInvokeFunctors", "(ILandroid/graphics/Rect;)I",
(void*) android_view_GLES20Canvas_invokeFunctors },
- { "nSave", "(JI)I", (void*) android_view_GLES20Canvas_save },
- { "nRestore", "(J)V", (void*) android_view_GLES20Canvas_restore },
- { "nRestoreToCount", "(JI)V", (void*) android_view_GLES20Canvas_restoreToCount },
- { "nGetSaveCount", "(J)I", (void*) android_view_GLES20Canvas_getSaveCount },
-
- { "nSaveLayer", "(JFFFFJI)I", (void*) android_view_GLES20Canvas_saveLayer },
- { "nSaveLayer", "(JJI)I", (void*) android_view_GLES20Canvas_saveLayerClip },
- { "nSaveLayerAlpha", "(JFFFFII)I", (void*) android_view_GLES20Canvas_saveLayerAlpha },
- { "nSaveLayerAlpha", "(JII)I", (void*) android_view_GLES20Canvas_saveLayerAlphaClip },
-
- { "nQuickReject", "(JFFFF)Z", (void*) android_view_GLES20Canvas_quickReject },
- { "nClipRect", "(JFFFFI)Z", (void*) android_view_GLES20Canvas_clipRectF },
- { "nClipRect", "(JIIIII)Z", (void*) android_view_GLES20Canvas_clipRect },
- { "nClipPath", "(JJI)Z", (void*) android_view_GLES20Canvas_clipPath },
- { "nClipRegion", "(JJI)Z", (void*) android_view_GLES20Canvas_clipRegion },
-
- { "nTranslate", "(JFF)V", (void*) android_view_GLES20Canvas_translate },
- { "nRotate", "(JF)V", (void*) android_view_GLES20Canvas_rotate },
- { "nScale", "(JFF)V", (void*) android_view_GLES20Canvas_scale },
- { "nSkew", "(JFF)V", (void*) android_view_GLES20Canvas_skew },
-
- { "nSetMatrix", "(JJ)V", (void*) android_view_GLES20Canvas_setMatrix },
- { "nGetMatrix", "(JJ)V", (void*) android_view_GLES20Canvas_getMatrix },
- { "nConcatMatrix", "(JJ)V", (void*) android_view_GLES20Canvas_concatMatrix },
-
- { "nDrawBitmap", "(JJ[BFFJ)V", (void*) android_view_GLES20Canvas_drawBitmap },
- { "nDrawBitmap", "(JJ[BFFFFFFFFJ)V",(void*) android_view_GLES20Canvas_drawBitmapRect },
- { "nDrawBitmap", "(JJ[BJJ)V", (void*) android_view_GLES20Canvas_drawBitmapMatrix },
- { "nDrawBitmap", "(J[IIIFFIIZJ)V", (void*) android_view_GLES20Canvas_drawBitmapData },
-
- { "nDrawBitmapMesh", "(JJ[BII[FI[IIJ)V",(void*) android_view_GLES20Canvas_drawBitmapMesh },
-
- { "nDrawPatch", "(JJ[BJFFFFJ)V", (void*) android_view_GLES20Canvas_drawPatch },
-
- { "nDrawColor", "(JII)V", (void*) android_view_GLES20Canvas_drawColor },
- { "nDrawRect", "(JFFFFJ)V", (void*) android_view_GLES20Canvas_drawRect },
- { "nDrawRects", "(JJJ)V", (void*) android_view_GLES20Canvas_drawRegionAsRects },
- { "nDrawRects", "(J[FIJ)V", (void*) android_view_GLES20Canvas_drawRects },
- { "nDrawRoundRect", "(JFFFFFFJ)V", (void*) android_view_GLES20Canvas_drawRoundRect },
- { "nDrawCircle", "(JFFFJ)V", (void*) android_view_GLES20Canvas_drawCircle },
- { "nDrawOval", "(JFFFFJ)V", (void*) android_view_GLES20Canvas_drawOval },
- { "nDrawArc", "(JFFFFFFZJ)V", (void*) android_view_GLES20Canvas_drawArc },
- { "nDrawPoints", "(J[FIIJ)V", (void*) android_view_GLES20Canvas_drawPoints },
-
- { "nDrawPath", "(JJJ)V", (void*) android_view_GLES20Canvas_drawPath },
- { "nDrawLines", "(J[FIIJ)V", (void*) android_view_GLES20Canvas_drawLines },
-
- { "nResetModifiers", "(JI)V", (void*) android_view_GLES20Canvas_resetModifiers },
- { "nSetupShader", "(JJ)V", (void*) android_view_GLES20Canvas_setupShader },
- { "nSetupColorFilter", "(JJ)V", (void*) android_view_GLES20Canvas_setupColorFilter },
- { "nSetupShadow", "(JFFFI)V", (void*) android_view_GLES20Canvas_setupShadow },
-
- { "nSetupPaintFilter", "(JII)V", (void*) android_view_GLES20Canvas_setupPaintFilter },
- { "nResetPaintFilter", "(J)V", (void*) android_view_GLES20Canvas_resetPaintFilter },
-
- { "nDrawText", "(J[CIIFFIJ)V", (void*) android_view_GLES20Canvas_drawTextArray },
- { "nDrawText", "(JLjava/lang/String;IIFFIJ)V",
+ { "nSave", "(II)I", (void*) android_view_GLES20Canvas_save },
+ { "nRestore", "(I)V", (void*) android_view_GLES20Canvas_restore },
+ { "nRestoreToCount", "(II)V", (void*) android_view_GLES20Canvas_restoreToCount },
+ { "nGetSaveCount", "(I)I", (void*) android_view_GLES20Canvas_getSaveCount },
+
+ { "nSaveLayer", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayer },
+ { "nSaveLayer", "(III)I", (void*) android_view_GLES20Canvas_saveLayerClip },
+ { "nSaveLayerAlpha", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayerAlpha },
+ { "nSaveLayerAlpha", "(III)I", (void*) android_view_GLES20Canvas_saveLayerAlphaClip },
+
+ { "nQuickReject", "(IFFFF)Z", (void*) android_view_GLES20Canvas_quickReject },
+ { "nClipRect", "(IFFFFI)Z", (void*) android_view_GLES20Canvas_clipRectF },
+ { "nClipRect", "(IIIIII)Z", (void*) android_view_GLES20Canvas_clipRect },
+ { "nClipPath", "(III)Z", (void*) android_view_GLES20Canvas_clipPath },
+ { "nClipRegion", "(III)Z", (void*) android_view_GLES20Canvas_clipRegion },
+
+ { "nTranslate", "(IFF)V", (void*) android_view_GLES20Canvas_translate },
+ { "nRotate", "(IF)V", (void*) android_view_GLES20Canvas_rotate },
+ { "nScale", "(IFF)V", (void*) android_view_GLES20Canvas_scale },
+ { "nSkew", "(IFF)V", (void*) android_view_GLES20Canvas_skew },
+
+ { "nSetMatrix", "(II)V", (void*) android_view_GLES20Canvas_setMatrix },
+ { "nGetMatrix", "(II)V", (void*) android_view_GLES20Canvas_getMatrix },
+ { "nConcatMatrix", "(II)V", (void*) android_view_GLES20Canvas_concatMatrix },
+
+ { "nDrawBitmap", "(II[BFFI)V", (void*) android_view_GLES20Canvas_drawBitmap },
+ { "nDrawBitmap", "(II[BFFFFFFFFI)V",(void*) android_view_GLES20Canvas_drawBitmapRect },
+ { "nDrawBitmap", "(II[BII)V", (void*) android_view_GLES20Canvas_drawBitmapMatrix },
+ { "nDrawBitmap", "(I[IIIFFIIZI)V", (void*) android_view_GLES20Canvas_drawBitmapData },
+
+ { "nDrawBitmapMesh", "(II[BII[FI[III)V",(void*) android_view_GLES20Canvas_drawBitmapMesh },
+
+ { "nDrawPatch", "(II[BIFFFFI)V", (void*) android_view_GLES20Canvas_drawPatch },
+
+ { "nDrawColor", "(III)V", (void*) android_view_GLES20Canvas_drawColor },
+ { "nDrawRect", "(IFFFFI)V", (void*) android_view_GLES20Canvas_drawRect },
+ { "nDrawRects", "(III)V", (void*) android_view_GLES20Canvas_drawRegionAsRects },
+ { "nDrawRects", "(I[FII)V", (void*) android_view_GLES20Canvas_drawRects },
+ { "nDrawRoundRect", "(IFFFFFFI)V", (void*) android_view_GLES20Canvas_drawRoundRect },
+ { "nDrawCircle", "(IFFFI)V", (void*) android_view_GLES20Canvas_drawCircle },
+ { "nDrawOval", "(IFFFFI)V", (void*) android_view_GLES20Canvas_drawOval },
+ { "nDrawArc", "(IFFFFFFZI)V", (void*) android_view_GLES20Canvas_drawArc },
+ { "nDrawPoints", "(I[FIII)V", (void*) android_view_GLES20Canvas_drawPoints },
+
+ { "nDrawPath", "(III)V", (void*) android_view_GLES20Canvas_drawPath },
+ { "nDrawLines", "(I[FIII)V", (void*) android_view_GLES20Canvas_drawLines },
+
+ { "nResetModifiers", "(II)V", (void*) android_view_GLES20Canvas_resetModifiers },
+ { "nSetupShader", "(II)V", (void*) android_view_GLES20Canvas_setupShader },
+ { "nSetupColorFilter", "(II)V", (void*) android_view_GLES20Canvas_setupColorFilter },
+ { "nSetupShadow", "(IFFFI)V", (void*) android_view_GLES20Canvas_setupShadow },
+
+ { "nSetupPaintFilter", "(III)V", (void*) android_view_GLES20Canvas_setupPaintFilter },
+ { "nResetPaintFilter", "(I)V", (void*) android_view_GLES20Canvas_resetPaintFilter },
+
+ { "nDrawText", "(I[CIIFFII)V", (void*) android_view_GLES20Canvas_drawTextArray },
+ { "nDrawText", "(ILjava/lang/String;IIFFII)V",
(void*) android_view_GLES20Canvas_drawText },
- { "nDrawTextOnPath", "(J[CIIJFFIJ)V", (void*) android_view_GLES20Canvas_drawTextArrayOnPath },
- { "nDrawTextOnPath", "(JLjava/lang/String;IIJFFIJ)V",
+ { "nDrawTextOnPath", "(I[CIIIFFII)V", (void*) android_view_GLES20Canvas_drawTextArrayOnPath },
+ { "nDrawTextOnPath", "(ILjava/lang/String;IIIFFII)V",
(void*) android_view_GLES20Canvas_drawTextOnPath },
- { "nDrawTextRun", "(J[CIIIIFFIJ)V", (void*) android_view_GLES20Canvas_drawTextRunArray },
- { "nDrawTextRun", "(JLjava/lang/String;IIIIFFIJ)V",
+ { "nDrawTextRun", "(I[CIIIIFFII)V", (void*) android_view_GLES20Canvas_drawTextRunArray },
+ { "nDrawTextRun", "(ILjava/lang/String;IIIIFFII)V",
(void*) android_view_GLES20Canvas_drawTextRun },
- { "nDrawPosText", "(J[CII[FJ)V", (void*) android_view_GLES20Canvas_drawPosTextArray },
- { "nDrawPosText", "(JLjava/lang/String;II[FJ)V",
+ { "nDrawPosText", "(I[CII[FI)V", (void*) android_view_GLES20Canvas_drawPosTextArray },
+ { "nDrawPosText", "(ILjava/lang/String;II[FI)V",
(void*) android_view_GLES20Canvas_drawPosText },
- { "nGetClipBounds", "(JLandroid/graphics/Rect;)Z",
+ { "nGetClipBounds", "(ILandroid/graphics/Rect;)Z",
(void*) android_view_GLES20Canvas_getClipBounds },
- { "nGetDisplayList", "(JJ)J", (void*) android_view_GLES20Canvas_getDisplayList },
- { "nDrawDisplayList", "(JJLandroid/graphics/Rect;I)I",
+ { "nGetDisplayList", "(II)I", (void*) android_view_GLES20Canvas_getDisplayList },
+ { "nDrawDisplayList", "(IILandroid/graphics/Rect;I)I",
(void*) android_view_GLES20Canvas_drawDisplayList },
- { "nCreateDisplayListRenderer", "()J", (void*) android_view_GLES20Canvas_createDisplayListRenderer },
- { "nResetDisplayListRenderer", "(J)V", (void*) android_view_GLES20Canvas_resetDisplayListRenderer },
+ { "nCreateDisplayListRenderer", "()I", (void*) android_view_GLES20Canvas_createDisplayListRenderer },
+ { "nResetDisplayListRenderer", "(I)V", (void*) android_view_GLES20Canvas_resetDisplayListRenderer },
- { "nInterrupt", "(J)V", (void*) android_view_GLES20Canvas_interrupt },
- { "nResume", "(J)V", (void*) android_view_GLES20Canvas_resume },
+ { "nInterrupt", "(I)V", (void*) android_view_GLES20Canvas_interrupt },
+ { "nResume", "(I)V", (void*) android_view_GLES20Canvas_resume },
- { "nCreateLayerRenderer", "(J)J", (void*) android_view_GLES20Canvas_createLayerRenderer },
- { "nCreateLayer", "(IIZ[I)J", (void*) android_view_GLES20Canvas_createLayer },
- { "nResizeLayer", "(JII[I)Z" , (void*) android_view_GLES20Canvas_resizeLayer },
- { "nSetLayerPaint", "(JJ)V", (void*) android_view_GLES20Canvas_setLayerPaint },
- { "nSetLayerColorFilter", "(JJ)V", (void*) android_view_GLES20Canvas_setLayerColorFilter },
- { "nSetOpaqueLayer", "(JZ)V", (void*) android_view_GLES20Canvas_setOpaqueLayer },
- { "nCreateTextureLayer", "(Z[I)J", (void*) android_view_GLES20Canvas_createTextureLayer },
- { "nUpdateTextureLayer", "(JIIZLandroid/graphics/SurfaceTexture;)V",
+ { "nCreateLayerRenderer", "(I)I", (void*) android_view_GLES20Canvas_createLayerRenderer },
+ { "nCreateLayer", "(IIZ[I)I", (void*) android_view_GLES20Canvas_createLayer },
+ { "nResizeLayer", "(III[I)Z" , (void*) android_view_GLES20Canvas_resizeLayer },
+ { "nSetLayerPaint", "(II)V", (void*) android_view_GLES20Canvas_setLayerPaint },
+ { "nSetLayerColorFilter", "(II)V", (void*) android_view_GLES20Canvas_setLayerColorFilter },
+ { "nSetOpaqueLayer", "(IZ)V", (void*) android_view_GLES20Canvas_setOpaqueLayer },
+ { "nCreateTextureLayer", "(Z[I)I", (void*) android_view_GLES20Canvas_createTextureLayer },
+ { "nUpdateTextureLayer", "(IIIZLandroid/graphics/SurfaceTexture;)V",
(void*) android_view_GLES20Canvas_updateTextureLayer },
- { "nUpdateRenderLayer", "(JJJIIII)V", (void*) android_view_GLES20Canvas_updateRenderLayer },
- { "nClearLayerTexture", "(J)V", (void*) android_view_GLES20Canvas_clearLayerTexture },
- { "nDestroyLayer", "(J)V", (void*) android_view_GLES20Canvas_destroyLayer },
- { "nDestroyLayerDeferred", "(J)V", (void*) android_view_GLES20Canvas_destroyLayerDeferred },
- { "nDrawLayer", "(JJFF)V", (void*) android_view_GLES20Canvas_drawLayer },
- { "nCopyLayer", "(JJ)Z", (void*) android_view_GLES20Canvas_copyLayer },
- { "nClearLayerUpdates", "(J)V", (void*) android_view_GLES20Canvas_clearLayerUpdates },
- { "nFlushLayerUpdates", "(J)V", (void*) android_view_GLES20Canvas_flushLayerUpdates },
- { "nPushLayerUpdate", "(JJ)V", (void*) android_view_GLES20Canvas_pushLayerUpdate },
- { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_GLES20Canvas_cancelLayerUpdate },
-
- { "nSetTextureLayerTransform", "(JJ)V", (void*) android_view_GLES20Canvas_setTextureLayerTransform },
+ { "nUpdateRenderLayer", "(IIIIIII)V", (void*) android_view_GLES20Canvas_updateRenderLayer },
+ { "nClearLayerTexture", "(I)V", (void*) android_view_GLES20Canvas_clearLayerTexture },
+ { "nDestroyLayer", "(I)V", (void*) android_view_GLES20Canvas_destroyLayer },
+ { "nDestroyLayerDeferred", "(I)V", (void*) android_view_GLES20Canvas_destroyLayerDeferred },
+ { "nDrawLayer", "(IIFF)V", (void*) android_view_GLES20Canvas_drawLayer },
+ { "nCopyLayer", "(II)Z", (void*) android_view_GLES20Canvas_copyLayer },
+ { "nClearLayerUpdates", "(I)V", (void*) android_view_GLES20Canvas_clearLayerUpdates },
+ { "nFlushLayerUpdates", "(I)V", (void*) android_view_GLES20Canvas_flushLayerUpdates },
+ { "nPushLayerUpdate", "(II)V", (void*) android_view_GLES20Canvas_pushLayerUpdate },
+ { "nCancelLayerUpdate", "(II)V", (void*) android_view_GLES20Canvas_cancelLayerUpdate },
+
+ { "nSetTextureLayerTransform", "(II)V", (void*) android_view_GLES20Canvas_setTextureLayerTransform },
{ "nGetMaximumTextureWidth", "()I", (void*) android_view_GLES20Canvas_getMaxTextureWidth },
{ "nGetMaximumTextureHeight", "()I", (void*) android_view_GLES20Canvas_getMaxTextureHeight },
#define SET_INT(object, field, value) \
env->SetIntField(object, field, value)
-#define GET_LONG(object, field) \
- env->GetLongField(object, field)
-
-#define SET_LONG(object, field, value) \
- env->SetLongField(object, field, value)
-
#define INVOKEV(object, method, ...) \
env->CallVoidMethod(object, method, __VA_ARGS__)
// GraphicBuffer lifecycle
// ----------------------------------------------------------------------------
-static jlong android_view_GraphiceBuffer_create(JNIEnv* env, jobject clazz,
+static GraphicBufferWrapper* android_view_GraphiceBuffer_create(JNIEnv* env, jobject clazz,
jint width, jint height, jint format, jint usage) {
sp<ISurfaceComposer> composer(ComposerService::getComposerService());
return NULL;
}
- GraphicBufferWrapper* wrapper = new GraphicBufferWrapper(buffer);
- return reinterpret_cast<jlong>(wrapper);
+ return new GraphicBufferWrapper(buffer);
}
static void android_view_GraphiceBuffer_destroy(JNIEnv* env, jobject clazz,
- jlong wrapperHandle) {
- GraphicBufferWrapper* wrapper =
- reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle);
+ GraphicBufferWrapper* wrapper) {
delete wrapper;
}
static inline void swapCanvasPtr(JNIEnv* env, jobject canvasObj, SkCanvas* newCanvas) {
jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer);
SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>(
- GET_LONG(canvasObj, gCanvasClassInfo.mNativeCanvas));
- SET_LONG(canvasObj, gCanvasClassInfo.mNativeCanvas, (long) newCanvas);
- SET_LONG(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (long) newCanvas);
+ GET_INT(canvasObj, gCanvasClassInfo.mNativeCanvas));
+ SET_INT(canvasObj, gCanvasClassInfo.mNativeCanvas, (int) newCanvas);
+ SET_INT(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int) newCanvas);
SkSafeUnref(previousCanvas);
}
}
static jboolean android_view_GraphicBuffer_lockCanvas(JNIEnv* env, jobject,
- jlong wrapperHandle, jobject canvas, jobject dirtyRect) {
+ GraphicBufferWrapper* wrapper, jobject canvas, jobject dirtyRect) {
- GraphicBufferWrapper* wrapper =
- reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle);
if (!wrapper) {
- return JNI_FALSE;
+ return false;
}
sp<GraphicBuffer> buffer(wrapper->buffer);
void* bits = NULL;
status_t status = buffer->lock(LOCK_CANVAS_USAGE, rect, &bits);
- if (status) return JNI_FALSE;
+ if (status) return false;
if (!bits) {
buffer->unlock();
- return JNI_FALSE;
+ return false;
}
ssize_t bytesCount = buffer->getStride() * bytesPerPixel(buffer->getPixelFormat());
int(rect.left), int(rect.top), int(rect.right), int(rect.bottom));
}
- return JNI_TRUE;
+ return true;
}
static jboolean android_view_GraphicBuffer_unlockCanvasAndPost(JNIEnv* env, jobject,
- jlong wrapperHandle, jobject canvas) {
+ GraphicBufferWrapper* wrapper, jobject canvas) {
- GraphicBufferWrapper* wrapper =
- reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle);
SkCanvas* nativeCanvas = SkNEW(SkCanvas);
swapCanvasPtr(env, canvas, nativeCanvas);
if (wrapper) {
status_t status = wrapper->buffer->unlock();
- return status == 0 ? JNI_TRUE : JNI_FALSE;
+ return status == 0;
}
- return JNI_FALSE;
+ return false;
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
static void android_view_GraphiceBuffer_write(JNIEnv* env, jobject clazz,
- jlong wrapperHandle, jobject dest) {
- GraphicBufferWrapper* wrapper =
- reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle);
+ GraphicBufferWrapper* wrapper, jobject dest) {
Parcel* parcel = parcelForJavaObject(env, dest);
if (parcel) {
parcel->write(*wrapper->buffer);
}
}
-static jlong android_view_GraphiceBuffer_read(JNIEnv* env, jobject clazz,
+static GraphicBufferWrapper* android_view_GraphiceBuffer_read(JNIEnv* env, jobject clazz,
jobject in) {
Parcel* parcel = parcelForJavaObject(env, in);
if (parcel) {
sp<GraphicBuffer> buffer = new GraphicBuffer();
parcel->read(*buffer);
- return reinterpret_cast<jlong>(new GraphicBufferWrapper(buffer));
+ return new GraphicBufferWrapper(buffer);
}
return NULL;
sp<GraphicBuffer> graphicBufferForJavaObject(JNIEnv* env, jobject obj) {
if (obj) {
- jlong nativeObject = env->GetLongField(obj, gGraphicBufferClassInfo.mNativeObject);
+ jint nativeObject = env->GetIntField(obj, gGraphicBufferClassInfo.mNativeObject);
GraphicBufferWrapper* wrapper = (GraphicBufferWrapper*) nativeObject;
if (wrapper != NULL) {
sp<GraphicBuffer> buffer(wrapper->buffer);
const char* const kClassPathName = "android/view/GraphicBuffer";
static JNINativeMethod gMethods[] = {
- { "nCreateGraphicBuffer", "(IIII)J", (void*) android_view_GraphiceBuffer_create },
- { "nDestroyGraphicBuffer", "(J)V", (void*) android_view_GraphiceBuffer_destroy },
+ { "nCreateGraphicBuffer", "(IIII)I", (void*) android_view_GraphiceBuffer_create },
+ { "nDestroyGraphicBuffer", "(I)V", (void*) android_view_GraphiceBuffer_destroy },
- { "nWriteGraphicBufferToParcel", "(JLandroid/os/Parcel;)V",
+ { "nWriteGraphicBufferToParcel", "(ILandroid/os/Parcel;)V",
(void*) android_view_GraphiceBuffer_write },
- { "nReadGraphicBufferFromParcel", "(Landroid/os/Parcel;)J",
+ { "nReadGraphicBufferFromParcel", "(Landroid/os/Parcel;)I",
(void*) android_view_GraphiceBuffer_read },
- { "nLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)Z",
+ { "nLockCanvas", "(ILandroid/graphics/Canvas;Landroid/graphics/Rect;)Z",
(void*) android_view_GraphicBuffer_lockCanvas },
- { "nUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)Z",
+ { "nUnlockCanvasAndPost", "(ILandroid/graphics/Canvas;)Z",
(void*) android_view_GraphicBuffer_unlockCanvasAndPost },
};
int register_android_view_GraphicBuffer(JNIEnv* env) {
jclass clazz;
FIND_CLASS(clazz, "android/view/GraphicBuffer");
- GET_FIELD_ID(gGraphicBufferClassInfo.mNativeObject, clazz, "mNativeObject", "J");
+ GET_FIELD_ID(gGraphicBufferClassInfo.mNativeObject, clazz, "mNativeObject", "I");
FIND_CLASS(clazz, "android/graphics/Rect");
GET_METHOD_ID(gRectClassInfo.set, clazz, "set", "(IIII)V");
FIND_CLASS(clazz, "android/graphics/Canvas");
GET_FIELD_ID(gCanvasClassInfo.mFinalizer, clazz, "mFinalizer",
"Landroid/graphics/Canvas$CanvasFinalizer;");
- GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J");
+ GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I");
GET_FIELD_ID(gCanvasClassInfo.mSurfaceFormat, clazz, "mSurfaceFormat", "I");
FIND_CLASS(clazz, "android/graphics/Canvas$CanvasFinalizer");
- GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J");
+ GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I");
return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
}
gSurfaceClassInfo.mLock);
if (env->MonitorEnter(lock) == JNI_OK) {
sur = reinterpret_cast<Surface *>(
- env->GetLongField(surfaceObj, gSurfaceClassInfo.mNativeObject));
+ env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeObject));
env->MonitorExit(lock);
}
return sur;
// ----------------------------------------------------------------------------
-static jlong nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz,
+static jint nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz,
jobject surfaceTextureObj) {
sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, surfaceTextureObj));
if (producer == NULL) {
}
surface->incStrong(&sRefBaseOwner);
- return jlong(surface.get());
+ return int(surface.get());
}
-static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) {
+static void nativeRelease(JNIEnv* env, jclass clazz, jint nativeObject) {
sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
sur->decStrong(&sRefBaseOwner);
}
-static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jlong nativeObject) {
+static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jint nativeObject) {
sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE;
}
-static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jlong nativeObject) {
+static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jint nativeObject) {
sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(sur)) {
doThrowIAE(env);
static inline void swapCanvasPtr(JNIEnv* env, jobject canvasObj, SkCanvas* newCanvas) {
jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer);
SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>(
- env->GetLongField(canvasObj, gCanvasClassInfo.mNativeCanvas));
- env->SetLongField(canvasObj, gCanvasClassInfo.mNativeCanvas, (jlong)newCanvas);
- env->SetLongField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (jlong)newCanvas);
+ env->GetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas));
+ env->SetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas, (int)newCanvas);
+ env->SetIntField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int)newCanvas);
SkSafeUnref(previousCanvas);
}
-static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,
- jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) {
+static jint nativeLockCanvas(JNIEnv* env, jclass clazz,
+ jint nativeObject, jobject canvasObj, jobject dirtyRectObj) {
sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(surface)) {
// because the latter could be replaced while the surface is locked.
sp<Surface> lockedSurface(surface);
lockedSurface->incStrong(&sRefBaseOwner);
- return (jlong) lockedSurface.get();
+ return (int) lockedSurface.get();
}
static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,
- jlong nativeObject, jobject canvasObj) {
+ jint nativeObject, jobject canvasObj) {
sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(surface)) {
return;
// ----------------------------------------------------------------------------
-static jlong nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz,
- jlong surfaceControlNativeObj) {
+static jint nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz,
+ jint surfaceControlNativeObj) {
/*
* This is used by the WindowManagerService just after constructing
* a Surface and is necessary for returning the Surface reference to
if (surface != NULL) {
surface->incStrong(&sRefBaseOwner);
}
- return reinterpret_cast<jlong>(surface.get());
+ return reinterpret_cast<jint>(surface.get());
}
-static jlong nativeReadFromParcel(JNIEnv* env, jclass clazz,
- jlong nativeObject, jobject parcelObj) {
+static jint nativeReadFromParcel(JNIEnv* env, jclass clazz,
+ jint nativeObject, jobject parcelObj) {
Parcel* parcel = parcelForJavaObject(env, parcelObj);
if (parcel == NULL) {
doThrowNPE(env);
if (self != NULL
&& (self->getIGraphicBufferProducer()->asBinder() == binder)) {
// same IGraphicBufferProducer, return ourselves
- return jlong(self.get());
+ return int(self.get());
}
sp<Surface> sur;
self->decStrong(&sRefBaseOwner);
}
- return jlong(sur.get());
+ return int(sur.get());
}
static void nativeWriteToParcel(JNIEnv* env, jclass clazz,
- jlong nativeObject, jobject parcelObj) {
+ jint nativeObject, jobject parcelObj) {
Parcel* parcel = parcelForJavaObject(env, parcelObj);
if (parcel == NULL) {
doThrowNPE(env);
// ----------------------------------------------------------------------------
static JNINativeMethod gSurfaceMethods[] = {
- {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J",
+ {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)I",
(void*)nativeCreateFromSurfaceTexture },
- {"nativeRelease", "(J)V",
+ {"nativeRelease", "(I)V",
(void*)nativeRelease },
- {"nativeIsValid", "(J)Z",
+ {"nativeIsValid", "(I)Z",
(void*)nativeIsValid },
- {"nativeIsConsumerRunningBehind", "(J)Z",
+ {"nativeIsConsumerRunningBehind", "(I)Z",
(void*)nativeIsConsumerRunningBehind },
- {"nativeLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)J",
+ {"nativeLockCanvas", "(ILandroid/graphics/Canvas;Landroid/graphics/Rect;)I",
(void*)nativeLockCanvas },
- {"nativeUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V",
+ {"nativeUnlockCanvasAndPost", "(ILandroid/graphics/Canvas;)V",
(void*)nativeUnlockCanvasAndPost },
- {"nativeCreateFromSurfaceControl", "(J)J",
+ {"nativeCreateFromSurfaceControl", "(I)I",
(void*)nativeCreateFromSurfaceControl },
- {"nativeReadFromParcel", "(JLandroid/os/Parcel;)J",
+ {"nativeReadFromParcel", "(ILandroid/os/Parcel;)I",
(void*)nativeReadFromParcel },
- {"nativeWriteToParcel", "(JLandroid/os/Parcel;)V",
+ {"nativeWriteToParcel", "(ILandroid/os/Parcel;)V",
(void*)nativeWriteToParcel },
};
jclass clazz = env->FindClass("android/view/Surface");
gSurfaceClassInfo.clazz = jclass(env->NewGlobalRef(clazz));
gSurfaceClassInfo.mNativeObject =
- env->GetFieldID(gSurfaceClassInfo.clazz, "mNativeObject", "J");
+ env->GetFieldID(gSurfaceClassInfo.clazz, "mNativeObject", "I");
gSurfaceClassInfo.mLock =
env->GetFieldID(gSurfaceClassInfo.clazz, "mLock", "Ljava/lang/Object;");
- gSurfaceClassInfo.ctor = env->GetMethodID(gSurfaceClassInfo.clazz, "<init>", "(J)V");
+ gSurfaceClassInfo.ctor = env->GetMethodID(gSurfaceClassInfo.clazz, "<init>", "(I)V");
clazz = env->FindClass("android/graphics/Canvas");
gCanvasClassInfo.mFinalizer = env->GetFieldID(clazz, "mFinalizer", "Landroid/graphics/Canvas$CanvasFinalizer;");
- gCanvasClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "J");
+ gCanvasClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "I");
gCanvasClassInfo.mSurfaceFormat = env->GetFieldID(clazz, "mSurfaceFormat", "I");
clazz = env->FindClass("android/graphics/Canvas$CanvasFinalizer");
- gCanvasFinalizerClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "J");
+ gCanvasFinalizerClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "I");
clazz = env->FindClass("android/graphics/Rect");
gRectClassInfo.left = env->GetFieldID(clazz, "left", "I");
// ----------------------------------------------------------------------------
-static jlong nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj,
+static jint nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj,
jstring nameStr, jint w, jint h, jint format, jint flags) {
ScopedUtfChars name(env, nameStr);
sp<SurfaceComposerClient> client(android_view_SurfaceSession_getClient(env, sessionObj));
return 0;
}
surface->incStrong((void *)nativeCreate);
- return reinterpret_cast<jlong>(surface.get());
+ return int(surface.get());
}
-static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) {
+static void nativeRelease(JNIEnv* env, jclass clazz, jint nativeObject) {
sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(nativeObject));
ctrl->decStrong((void *)nativeCreate);
}
-static void nativeDestroy(JNIEnv* env, jclass clazz, jlong nativeObject) {
+static void nativeDestroy(JNIEnv* env, jclass clazz, jint nativeObject) {
sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(nativeObject));
ctrl->clear();
ctrl->decStrong((void *)nativeCreate);
SurfaceComposerClient::setAnimationTransaction();
}
-static void nativeSetLayer(JNIEnv* env, jclass clazz, jlong nativeObject, jint zorder) {
+static void nativeSetLayer(JNIEnv* env, jclass clazz, jint nativeObject, jint zorder) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
status_t err = ctrl->setLayer(zorder);
if (err < 0 && err != NO_INIT) {
}
}
-static void nativeSetPosition(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat x, jfloat y) {
+static void nativeSetPosition(JNIEnv* env, jclass clazz, jint nativeObject, jfloat x, jfloat y) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
status_t err = ctrl->setPosition(x, y);
if (err < 0 && err != NO_INIT) {
}
}
-static void nativeSetSize(JNIEnv* env, jclass clazz, jlong nativeObject, jint w, jint h) {
+static void nativeSetSize(JNIEnv* env, jclass clazz, jint nativeObject, jint w, jint h) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
status_t err = ctrl->setSize(w, h);
if (err < 0 && err != NO_INIT) {
}
}
-static void nativeSetFlags(JNIEnv* env, jclass clazz, jlong nativeObject, jint flags, jint mask) {
+static void nativeSetFlags(JNIEnv* env, jclass clazz, jint nativeObject, jint flags, jint mask) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
status_t err = ctrl->setFlags(flags, mask);
if (err < 0 && err != NO_INIT) {
}
}
-static void nativeSetTransparentRegionHint(JNIEnv* env, jclass clazz, jlong nativeObject, jobject regionObj) {
+static void nativeSetTransparentRegionHint(JNIEnv* env, jclass clazz, jint nativeObject, jobject regionObj) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
SkRegion* region = android_graphics_Region_getSkRegion(env, regionObj);
if (!region) {
}
}
-static void nativeSetAlpha(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat alpha) {
+static void nativeSetAlpha(JNIEnv* env, jclass clazz, jint nativeObject, jfloat alpha) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
status_t err = ctrl->setAlpha(alpha);
if (err < 0 && err != NO_INIT) {
}
}
-static void nativeSetMatrix(JNIEnv* env, jclass clazz, jlong nativeObject,
+static void nativeSetMatrix(JNIEnv* env, jclass clazz, jint nativeObject,
jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
status_t err = ctrl->setMatrix(dsdx, dtdx, dsdy, dtdy);
}
}
-static void nativeSetWindowCrop(JNIEnv* env, jclass clazz, jlong nativeObject,
+static void nativeSetWindowCrop(JNIEnv* env, jclass clazz, jint nativeObject,
jint l, jint t, jint r, jint b) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
Rect crop(l, t, r, b);
}
}
-static void nativeSetLayerStack(JNIEnv* env, jclass clazz, jlong nativeObject, jint layerStack) {
+static void nativeSetLayerStack(JNIEnv* env, jclass clazz, jint nativeObject, jint layerStack) {
SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
status_t err = ctrl->setLayerStack(layerStack);
if (err < 0 && err != NO_INIT) {
}
static void nativeSetDisplaySurface(JNIEnv* env, jclass clazz,
- jobject tokenObj, jlong nativeSurfaceObject) {
+ jobject tokenObj, jint nativeSurfaceObject) {
sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
if (token == NULL) return;
sp<IGraphicBufferProducer> bufferProducer;
// ----------------------------------------------------------------------------
static JNINativeMethod sSurfaceControlMethods[] = {
- {"nativeCreate", "(Landroid/view/SurfaceSession;Ljava/lang/String;IIII)J",
+ {"nativeCreate", "(Landroid/view/SurfaceSession;Ljava/lang/String;IIII)I",
(void*)nativeCreate },
- {"nativeRelease", "(J)V",
+ {"nativeRelease", "(I)V",
(void*)nativeRelease },
- {"nativeDestroy", "(J)V",
+ {"nativeDestroy", "(I)V",
(void*)nativeDestroy },
{"nativeScreenshot", "(Landroid/os/IBinder;IIIIZ)Landroid/graphics/Bitmap;",
(void*)nativeScreenshotBitmap },
(void*)nativeCloseTransaction },
{"nativeSetAnimationTransaction", "()V",
(void*)nativeSetAnimationTransaction },
- {"nativeSetLayer", "(JI)V",
+ {"nativeSetLayer", "(II)V",
(void*)nativeSetLayer },
- {"nativeSetPosition", "(JFF)V",
+ {"nativeSetPosition", "(IFF)V",
(void*)nativeSetPosition },
- {"nativeSetSize", "(JII)V",
+ {"nativeSetSize", "(III)V",
(void*)nativeSetSize },
- {"nativeSetTransparentRegionHint", "(JLandroid/graphics/Region;)V",
+ {"nativeSetTransparentRegionHint", "(ILandroid/graphics/Region;)V",
(void*)nativeSetTransparentRegionHint },
- {"nativeSetAlpha", "(JF)V",
+ {"nativeSetAlpha", "(IF)V",
(void*)nativeSetAlpha },
- {"nativeSetMatrix", "(JFFFF)V",
+ {"nativeSetMatrix", "(IFFFF)V",
(void*)nativeSetMatrix },
- {"nativeSetFlags", "(JII)V",
+ {"nativeSetFlags", "(III)V",
(void*)nativeSetFlags },
- {"nativeSetWindowCrop", "(JIIII)V",
+ {"nativeSetWindowCrop", "(IIIII)V",
(void*)nativeSetWindowCrop },
- {"nativeSetLayerStack", "(JI)V",
+ {"nativeSetLayerStack", "(II)V",
(void*)nativeSetLayerStack },
{"nativeGetBuiltInDisplay", "(I)Landroid/os/IBinder;",
(void*)nativeGetBuiltInDisplay },
(void*)nativeCreateDisplay },
{"nativeDestroyDisplay", "(Landroid/os/IBinder;)V",
(void*)nativeDestroyDisplay },
- {"nativeSetDisplaySurface", "(Landroid/os/IBinder;J)V",
+ {"nativeSetDisplaySurface", "(Landroid/os/IBinder;I)V",
(void*)nativeSetDisplaySurface },
{"nativeSetDisplayLayerStack", "(Landroid/os/IBinder;I)V",
(void*)nativeSetDisplayLayerStack },
#define GET_INT(object, field) \
env->GetIntField(object, field)
-#define GET_LONG(object, field) \
- env->GetLongField(object, field)
-
#define SET_INT(object, field, value) \
env->SetIntField(object, field, value)
-#define SET_LONG(object, field, value) \
- env->SetLongField(object, field, value)
-
#define INVOKEV(object, method, ...) \
env->CallVoidMethod(object, method, __VA_ARGS__)
sp<ANativeWindow> window = new Surface(producer, true);
window->incStrong((void*)android_view_TextureView_createNativeWindow);
- SET_LONG(textureView, gTextureViewClassInfo.nativeWindow, jlong(window.get()));
+ SET_INT(textureView, gTextureViewClassInfo.nativeWindow, jint(window.get()));
}
static void android_view_TextureView_destroyNativeWindow(JNIEnv* env, jobject textureView) {
ANativeWindow* nativeWindow = (ANativeWindow*)
- GET_LONG(textureView, gTextureViewClassInfo.nativeWindow);
+ GET_INT(textureView, gTextureViewClassInfo.nativeWindow);
if (nativeWindow) {
sp<ANativeWindow> window(nativeWindow);
window->decStrong((void*)android_view_TextureView_createNativeWindow);
- SET_LONG(textureView, gTextureViewClassInfo.nativeWindow, 0);
+ SET_INT(textureView, gTextureViewClassInfo.nativeWindow, 0);
}
}
jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer);
SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>(
env->GetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas));
- env->SetLongField(canvasObj, gCanvasClassInfo.mNativeCanvas, (jlong)newCanvas);
- env->SetLongField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (jlong)newCanvas);
+ env->SetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas, (int)newCanvas);
+ env->SetIntField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int)newCanvas);
SkSafeUnref(previousCanvas);
}
static jboolean android_view_TextureView_lockCanvas(JNIEnv* env, jobject,
- jlong nativeWindow, jobject canvas, jobject dirtyRect) {
+ jint nativeWindow, jobject canvas, jobject dirtyRect) {
if (!nativeWindow) {
- return JNI_FALSE;
+ return false;
}
ANativeWindow_Buffer buffer;
sp<ANativeWindow> window((ANativeWindow*) nativeWindow);
int32_t status = native_window_lock(window.get(), &buffer, &rect);
- if (status) return JNI_FALSE;
+ if (status) return false;
ssize_t bytesCount = buffer.stride * bytesPerPixel(buffer.format);
int(rect.left), int(rect.top), int(rect.right), int(rect.bottom));
}
- return JNI_TRUE;
+ return true;
}
static void android_view_TextureView_unlockCanvasAndPost(JNIEnv* env, jobject,
- jlong nativeWindow, jobject canvas) {
+ jint nativeWindow, jobject canvas) {
SkCanvas* nativeCanvas = SkNEW(SkCanvas);
swapCanvasPtr(env, canvas, nativeCanvas);
{ "nDestroyNativeWindow", "()V",
(void*) android_view_TextureView_destroyNativeWindow },
- { "nLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)Z",
+ { "nLockCanvas", "(ILandroid/graphics/Canvas;Landroid/graphics/Rect;)Z",
(void*) android_view_TextureView_lockCanvas },
- { "nUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V",
+ { "nUnlockCanvasAndPost", "(ILandroid/graphics/Canvas;)V",
(void*) android_view_TextureView_unlockCanvasAndPost },
};
FIND_CLASS(clazz, "android/graphics/Canvas");
GET_FIELD_ID(gCanvasClassInfo.mFinalizer, clazz, "mFinalizer",
"Landroid/graphics/Canvas$CanvasFinalizer;");
- GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J");
+ GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I");
GET_FIELD_ID(gCanvasClassInfo.mSurfaceFormat, clazz, "mSurfaceFormat", "I");
FIND_CLASS(clazz, "android/graphics/Canvas$CanvasFinalizer");
- GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J");
+ GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I");
FIND_CLASS(clazz, "android/view/TextureView");
- GET_FIELD_ID(gTextureViewClassInfo.nativeWindow, clazz, "mNativeWindow", "J");
+ GET_FIELD_ID(gTextureViewClassInfo.nativeWindow, clazz, "mNativeWindow", "I");
return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
}
gSurface_NativePixelRefFieldID = _env->GetFieldID(surface_class, "mNativePixelRef", "I");
jclass bitmap_class = _env->FindClass("android/graphics/Bitmap");
- gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "J");
+ gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "I");
}
static const jint gNull_attrib_base[] = {EGL_NONE};
jint* base = 0;
SkBitmap const * nativeBitmap =
- (SkBitmap const *)_env->GetLongField(native_pixmap,
+ (SkBitmap const *)_env->GetIntField(native_pixmap,
gBitmap_NativeBitmapFieldID);
SkPixelRef* ref = nativeBitmap ? nativeBitmap->pixelRef() : 0;
if (ref == NULL) {
native_instance = nativeCreate(opColor, tolerance, mode.nativeInt);
}
- private static native long nativeCreate(int opColor, int tolerance,
- int nativeMode);
+ private static native int nativeCreate(int opColor, int tolerance,
+ int nativeMode);
}
*
* @hide
*/
- public final long mNativeBitmap;
+ public final int mNativeBitmap;
/**
* Backing buffer for the Bitmap.
* int (pointer).
*/
@SuppressWarnings({"UnusedDeclaration"}) // called from JNI
- Bitmap(long nativeBitmap, byte[] buffer, int width, int height, int density,
+ Bitmap(int nativeBitmap, byte[] buffer, int width, int height, int density,
boolean isMutable, boolean isPremultiplied,
byte[] ninePatchChunk, int[] layoutBounds) {
if (nativeBitmap == 0) {
*/
public Bitmap extractAlpha(Paint paint, int[] offsetXY) {
checkRecycled("Can't extractAlpha on a recycled bitmap");
- long nativePaint = paint != null ? paint.mNativePaint : 0;
+ int nativePaint = paint != null ? paint.mNativePaint : 0;
Bitmap bm = nativeExtractAlpha(mNativeBitmap, nativePaint, offsetXY);
if (bm == null) {
throw new RuntimeException("Failed to extractAlpha on Bitmap");
}
private static class BitmapFinalizer {
- private final long mNativeBitmap;
+ private final int mNativeBitmap;
- BitmapFinalizer(long nativeBitmap) {
+ BitmapFinalizer(int nativeBitmap) {
mNativeBitmap = nativeBitmap;
}
private static native Bitmap nativeCreate(int[] colors, int offset,
int stride, int width, int height,
int nativeConfig, boolean mutable);
- private static native Bitmap nativeCopy(long nativeSrcBitmap, int nativeConfig,
+ private static native Bitmap nativeCopy(int srcBitmap, int nativeConfig,
boolean isMutable);
- private static native void nativeDestructor(long nativeBitmap);
- private static native boolean nativeRecycle(long nativeBitmap);
- private static native void nativeReconfigure(long nativeBitmap, int width, int height,
+ private static native void nativeDestructor(int nativeBitmap);
+ private static native boolean nativeRecycle(int nativeBitmap);
+ private static native void nativeReconfigure(int nativeBitmap, int width, int height,
int config, int allocSize);
- private static native boolean nativeCompress(long nativeBitmap, int format,
+ private static native boolean nativeCompress(int nativeBitmap, int format,
int quality, OutputStream stream,
byte[] tempStorage);
- private static native void nativeErase(long nativeBitmap, int color);
- private static native int nativeRowBytes(long nativeBitmap);
- private static native int nativeConfig(long nativeBitmap);
+ private static native void nativeErase(int nativeBitmap, int color);
+ private static native int nativeRowBytes(int nativeBitmap);
+ private static native int nativeConfig(int nativeBitmap);
- private static native int nativeGetPixel(long nativeBitmap, int x, int y,
+ private static native int nativeGetPixel(int nativeBitmap, int x, int y,
boolean isPremultiplied);
- private static native void nativeGetPixels(long nativeBitmap, int[] pixels,
+ private static native void nativeGetPixels(int nativeBitmap, int[] pixels,
int offset, int stride, int x, int y,
int width, int height, boolean isPremultiplied);
- private static native void nativeSetPixel(long nativeBitmap, int x, int y,
+ private static native void nativeSetPixel(int nativeBitmap, int x, int y,
int color, boolean isPremultiplied);
- private static native void nativeSetPixels(long nativeBitmap, int[] colors,
+ private static native void nativeSetPixels(int nativeBitmap, int[] colors,
int offset, int stride, int x, int y,
int width, int height, boolean isPremultiplied);
- private static native void nativeCopyPixelsToBuffer(long nativeBitmap,
+ private static native void nativeCopyPixelsToBuffer(int nativeBitmap,
Buffer dst);
- private static native void nativeCopyPixelsFromBuffer(long nativeBitmap, Buffer src);
- private static native int nativeGenerationId(long nativeBitmap);
+ private static native void nativeCopyPixelsFromBuffer(int nb, Buffer src);
+ private static native int nativeGenerationId(int nativeBitmap);
private static native Bitmap nativeCreateFromParcel(Parcel p);
// returns true on success
- private static native boolean nativeWriteToParcel(long nativeBitmap,
+ private static native boolean nativeWriteToParcel(int nativeBitmap,
boolean isMutable,
int density,
Parcel p);
// returns a new bitmap built from the native bitmap's alpha, and the paint
- private static native Bitmap nativeExtractAlpha(long nativeBitmap,
- long nativePaint,
+ private static native Bitmap nativeExtractAlpha(int nativeBitmap,
+ int nativePaint,
int[] offsetXY);
- private static native void nativePrepareToDraw(long nativeBitmap);
- private static native boolean nativeHasAlpha(long nativeBitmap);
- private static native void nativeSetAlphaAndPremultiplied(long nativeBitmap,
- boolean hasAlpha,
+ private static native void nativePrepareToDraw(int nativeBitmap);
+ private static native boolean nativeHasAlpha(int nativeBitmap);
+ private static native void nativeSetAlphaAndPremultiplied(int nBitmap, boolean hasAlpha,
boolean isPremul);
- private static native boolean nativeHasMipMap(long nativeBitmap);
- private static native void nativeSetHasMipMap(long nativeBitmap, boolean hasMipMap);
- private static native boolean nativeSameAs(long nativeBitmap0, long nativeBitmap1);
-
- /* package */ final long ni() {
+ private static native boolean nativeHasMipMap(int nativeBitmap);
+ private static native void nativeSetHasMipMap(int nBitmap, boolean hasMipMap);
+ private static native boolean nativeSameAs(int nb0, int nb1);
+
+ /* package */ final int ni() {
return mNativeBitmap;
}
}
Trace.traceBegin(Trace.TRACE_TAG_GRAPHICS, "decodeBitmap");
try {
if (is instanceof AssetManager.AssetInputStream) {
- final long asset = ((AssetManager.AssetInputStream) is).getNativeAsset();
+ final int asset = ((AssetManager.AssetInputStream) is).getAssetInt();
bm = nativeDecodeAsset(asset, outPadding, opts);
} else {
bm = decodeStreamInternal(is, outPadding, opts);
Rect padding, Options opts);
private static native Bitmap nativeDecodeFileDescriptor(FileDescriptor fd,
Rect padding, Options opts);
- private static native Bitmap nativeDecodeAsset(long nativeAsset, Rect padding, Options opts);
+ private static native Bitmap nativeDecodeAsset(int asset, Rect padding, Options opts);
private static native Bitmap nativeDecodeByteArray(byte[] data, int offset,
int length, Options opts);
private static native boolean nativeIsSeekable(FileDescriptor fd);
mBitmap = bitmap;
mTileX = tileX;
mTileY = tileY;
- final long b = bitmap.ni();
+ final int b = bitmap.ni();
native_instance = nativeCreate(b, tileX.nativeInt, tileY.nativeInt);
native_shader = nativePostCreate(native_instance, b, tileX.nativeInt, tileY.nativeInt);
}
return copy;
}
- private static native long nativeCreate(long native_bitmap, int shaderTileModeX,
+ private static native int nativeCreate(int native_bitmap, int shaderTileModeX,
int shaderTileModeY);
- private static native long nativePostCreate(long native_shader, long native_bitmap,
+ private static native int nativePostCreate(int native_shader, int native_bitmap,
int shaderTileModeX, int shaderTileModeY);
}
native_instance = nativeConstructor(radius, style.native_int);
}
- private static native long nativeConstructor(float radius, int style);
+ private static native int nativeConstructor(float radius, int style);
}
}
public native float dotWithNormal(float dx, float dy, float dz);
-
+
protected void finalize() throws Throwable {
try {
nativeDestructor();
private native void nativeConstructor();
private native void nativeDestructor();
- private native void nativeGetMatrix(long native_matrix);
- private native void nativeApplyToCanvas(long native_canvas);
-
- long native_instance;
+ private native void nativeGetMatrix(int native_matrix);
+ private native void nativeApplyToCanvas(int native_canvas);
+
+ int native_instance;
}
// assigned in constructors or setBitmap, freed in finalizer
/** @hide */
- public long mNativeCanvas;
+ public int mNativeCanvas;
// may be null
private Bitmap mBitmap;
private final CanvasFinalizer mFinalizer;
private static final class CanvasFinalizer {
- private long mNativeCanvas;
+ private int mNativeCanvas;
- public CanvasFinalizer(long nativeCanvas) {
+ public CanvasFinalizer(int nativeCanvas) {
mNativeCanvas = nativeCanvas;
}
}
/** @hide */
- public Canvas(long nativeCanvas) {
+ public Canvas(int nativeCanvas) {
if (nativeCanvas == 0) {
throw new IllegalStateException();
}
* Replace existing canvas while ensuring that the swap has occurred before
* the previous native canvas is unreferenced.
*/
- private void safeCanvasSwap(long nativeCanvas, boolean copyState) {
- final long oldCanvas = mNativeCanvas;
+ private void safeCanvasSwap(int nativeCanvas, boolean copyState) {
+ final int oldCanvas = mNativeCanvas;
mNativeCanvas = nativeCanvas;
mFinalizer.mNativeCanvas = nativeCanvas;
if (copyState) {
*
* @hide
*/
- public long getNativeCanvas() {
+ public int getNativeCanvas() {
return mNativeCanvas;
}
}
public void setDrawFilter(DrawFilter filter) {
- long nativeFilter = 0;
+ int nativeFilter = 0;
if (filter != null) {
nativeFilter = filter.mNativeInt;
}
vertOffset, texs, texOffset, colors, colorOffset,
indices, indexOffset, indexCount, paint.mNativePaint);
}
-
+
/**
* Draw the text, with origin at (x,y), using the specified paint. The
* origin is interpreted based on the Align setting in the paint.
*/
public static native void freeTextLayoutCaches();
- private static native long initRaster(long nativeBitmapOrZero);
- private static native void copyNativeCanvasState(long nativeSrcCanvas,
- long nativeDstCanvas);
- private static native int native_saveLayer(long nativeCanvas,
- RectF bounds,
- long nativePaint,
- int layerFlags);
- private static native int native_saveLayer(long nativeCanvas, float l,
+ private static native int initRaster(int nativeBitmapOrZero);
+ private static native void copyNativeCanvasState(int srcCanvas, int dstCanvas);
+ private static native int native_saveLayer(int nativeCanvas, RectF bounds,
+ int paint, int layerFlags);
+ private static native int native_saveLayer(int nativeCanvas, float l,
float t, float r, float b,
- long nativePaint,
- int layerFlags);
- private static native int native_saveLayerAlpha(long nativeCanvas,
+ int paint, int layerFlags);
+ private static native int native_saveLayerAlpha(int nativeCanvas,
RectF bounds, int alpha,
int layerFlags);
- private static native int native_saveLayerAlpha(long nativeCanvas, float l,
+ private static native int native_saveLayerAlpha(int nativeCanvas, float l,
float t, float r, float b,
int alpha, int layerFlags);
- private static native void native_concat(long nativeCanvas,
- long nativeMatrix);
- private static native void native_setMatrix(long nativeCanvas,
- long nativeMatrix);
- private static native boolean native_clipRect(long nativeCanvas,
+ private static native void native_concat(int nCanvas, int nMatrix);
+ private static native void native_setMatrix(int nCanvas, int nMatrix);
+ private static native boolean native_clipRect(int nCanvas,
float left, float top,
float right, float bottom,
int regionOp);
- private static native boolean native_clipPath(long nativeCanvas,
- long nativePath,
+ private static native boolean native_clipPath(int nativeCanvas,
+ int nativePath,
int regionOp);
- private static native boolean native_clipRegion(long nativeCanvas,
- long nativeRegion,
+ private static native boolean native_clipRegion(int nativeCanvas,
+ int nativeRegion,
int regionOp);
- private static native void nativeSetDrawFilter(long nativeCanvas,
- long nativeFilter);
- private static native boolean native_getClipBounds(long nativeCanvas,
+ private static native void nativeSetDrawFilter(int nativeCanvas,
+ int nativeFilter);
+ private static native boolean native_getClipBounds(int nativeCanvas,
Rect bounds);
- private static native void native_getCTM(long nativeCanvas,
- long nativeMatrix);
- private static native boolean native_quickReject(long nativeCanvas,
+ private static native void native_getCTM(int canvas, int matrix);
+ private static native boolean native_quickReject(int nativeCanvas,
RectF rect);
- private static native boolean native_quickReject(long nativeCanvas,
- long nativePath);
- private static native boolean native_quickReject(long nativeCanvas,
+ private static native boolean native_quickReject(int nativeCanvas,
+ int path);
+ private static native boolean native_quickReject(int nativeCanvas,
float left, float top,
float right, float bottom);
- private static native void native_drawRGB(long nativeCanvas, int r, int g,
+ private static native void native_drawRGB(int nativeCanvas, int r, int g,
int b);
- private static native void native_drawARGB(long nativeCanvas, int a, int r,
+ private static native void native_drawARGB(int nativeCanvas, int a, int r,
int g, int b);
- private static native void native_drawColor(long nativeCanvas, int color);
- private static native void native_drawColor(long nativeCanvas, int color,
+ private static native void native_drawColor(int nativeCanvas, int color);
+ private static native void native_drawColor(int nativeCanvas, int color,
int mode);
- private static native void native_drawPaint(long nativeCanvas,
- long nativePaint);
- private static native void native_drawLine(long nativeCanvas, float startX,
+ private static native void native_drawPaint(int nativeCanvas, int paint);
+ private static native void native_drawLine(int nativeCanvas, float startX,
float startY, float stopX,
- float stopY, long nativePaint);
- private static native void native_drawRect(long nativeCanvas, RectF rect,
- long nativePaint);
- private static native void native_drawRect(long nativeCanvas, float left,
+ float stopY, int paint);
+ private static native void native_drawRect(int nativeCanvas, RectF rect,
+ int paint);
+ private static native void native_drawRect(int nativeCanvas, float left,
float top, float right,
- float bottom,
- long nativePaint);
- private static native void native_drawOval(long nativeCanvas, RectF oval,
- long nativePaint);
- private static native void native_drawCircle(long nativeCanvas, float cx,
+ float bottom, int paint);
+ private static native void native_drawOval(int nativeCanvas, RectF oval,
+ int paint);
+ private static native void native_drawCircle(int nativeCanvas, float cx,
float cy, float radius,
- long nativePaint);
- private static native void native_drawArc(long nativeCanvas, RectF oval,
+ int paint);
+ private static native void native_drawArc(int nativeCanvas, RectF oval,
float startAngle, float sweep,
- boolean useCenter,
- long nativePaint);
- private static native void native_drawRoundRect(long nativeCanvas,
+ boolean useCenter, int paint);
+ private static native void native_drawRoundRect(int nativeCanvas,
RectF rect, float rx,
- float ry, long nativePaint);
- private static native void native_drawPath(long nativeCanvas,
- long nativePath,
- long nativePaint);
- private native void native_drawBitmap(long nativeCanvas, long nativeBitmap,
+ float ry, int paint);
+ private static native void native_drawPath(int nativeCanvas, int path,
+ int paint);
+ private native void native_drawBitmap(int nativeCanvas, int bitmap,
float left, float top,
- long nativePaintOrZero,
+ int nativePaintOrZero,
int canvasDensity,
int screenDensity,
int bitmapDensity);
- private native void native_drawBitmap(long nativeCanvas, long nativeBitmap,
+ private native void native_drawBitmap(int nativeCanvas, int bitmap,
Rect src, RectF dst,
- long nativePaintOrZero,
+ int nativePaintOrZero,
int screenDensity,
int bitmapDensity);
- private static native void native_drawBitmap(long nativeCanvas,
- long nativeBitmap,
+ private static native void native_drawBitmap(int nativeCanvas, int bitmap,
Rect src, Rect dst,
- long nativePaintOrZero,
+ int nativePaintOrZero,
int screenDensity,
int bitmapDensity);
- private static native void native_drawBitmap(long nativeCanvas, int[] colors,
+ private static native void native_drawBitmap(int nativeCanvas, int[] colors,
int offset, int stride, float x,
float y, int width, int height,
boolean hasAlpha,
- long nativePaintOrZero);
- private static native void nativeDrawBitmapMatrix(long nativeCanvas,
- long nativeBitmap,
- long nativeMatrix,
- long nativePaint);
- private static native void nativeDrawBitmapMesh(long nativeCanvas,
- long nativeBitmap,
+ int nativePaintOrZero);
+ private static native void nativeDrawBitmapMatrix(int nCanvas, int nBitmap,
+ int nMatrix, int nPaint);
+ private static native void nativeDrawBitmapMesh(int nCanvas, int nBitmap,
int meshWidth, int meshHeight,
float[] verts, int vertOffset,
- int[] colors, int colorOffset,
- long nativePaint);
- private static native void nativeDrawVertices(long nativeCanvas, int mode, int n,
+ int[] colors, int colorOffset, int nPaint);
+ private static native void nativeDrawVertices(int nCanvas, int mode, int n,
float[] verts, int vertOffset, float[] texs, int texOffset,
int[] colors, int colorOffset, short[] indices,
- int indexOffset, int indexCount, long nativePaint);
-
- private static native void native_drawText(long nativeCanvas, char[] text,
+ int indexOffset, int indexCount, int nPaint);
+
+ private static native void native_drawText(int nativeCanvas, char[] text,
int index, int count, float x,
- float y, int flags, long nativePaint,
- long nativeTypeface);
- private static native void native_drawText(long nativeCanvas, String text,
+ float y, int flags, int paint, int typeface);
+ private static native void native_drawText(int nativeCanvas, String text,
int start, int end, float x,
- float y, int flags, long nativePaint,
- long nativeTypeface);
+ float y, int flags, int paint, int typeface);
- private static native void native_drawTextRun(long nativeCanvas, String text,
+ private static native void native_drawTextRun(int nativeCanvas, String text,
int start, int end, int contextStart, int contextEnd,
- float x, float y, int flags, long nativePaint, long nativeTypeface);
+ float x, float y, int flags, int paint, int typeface);
- private static native void native_drawTextRun(long nativeCanvas, char[] text,
+ private static native void native_drawTextRun(int nativeCanvas, char[] text,
int start, int count, int contextStart, int contextCount,
- float x, float y, int flags, long nativePaint, long nativeTypeface);
+ float x, float y, int flags, int paint, int typeface);
- private static native void native_drawPosText(long nativeCanvas,
+ private static native void native_drawPosText(int nativeCanvas,
char[] text, int index,
int count, float[] pos,
- long nativePaint);
- private static native void native_drawPosText(long nativeCanvas,
+ int paint);
+ private static native void native_drawPosText(int nativeCanvas,
String text, float[] pos,
- long nativePaint);
- private static native void native_drawTextOnPath(long nativeCanvas,
+ int paint);
+ private static native void native_drawTextOnPath(int nativeCanvas,
char[] text, int index,
- int count, long nativePath,
+ int count, int path,
float hOffset,
float vOffset, int bidiFlags,
- long nativePaint);
- private static native void native_drawTextOnPath(long nativeCanvas,
- String text, long nativePath,
- float hOffset,
- float vOffset,
- int flags, long nativePaint);
- private static native void finalizer(long nativeCanvas);
+ int paint);
+ private static native void native_drawTextOnPath(int nativeCanvas,
+ String text, int path,
+ float hOffset,
+ float vOffset,
+ int flags, int paint);
+ private static native void finalizer(int nativeCanvas);
}
*/
public class ColorFilter {
// Holds the pointer to the native SkColorFilter instance
- long native_instance;
+ int native_instance;
/**
* Holds the pointer to the native SkiaColorFilter instance, from libhwui.
*
* @hide
*/
- public long nativeColorFilter;
+ public int nativeColorFilter;
@Override
protected void finalize() throws Throwable {
}
}
- static native void destroyFilter(long native_instance, long nativeColorFilter);
+ static native void destroyFilter(int native_instance, int nativeColorFilter);
}
nativeColorFilter = nColorMatrixFilter(native_instance, colorMatrix);
}
- private static native long nativeColorMatrixFilter(float[] array);
- private static native long nColorMatrixFilter(long nativeFilter, float[] array);
+ private static native int nativeColorMatrixFilter(float[] array);
+ private static native int nColorMatrixFilter(int nativeFilter, float[] array);
}
innerpe.native_instance);
}
- private static native long nativeCreate(long nativeOuterpe,
- long nativeInnerpe);
+ private static native int nativeCreate(int outerpe, int innerpe);
}
return copy;
}
- private static native long nativeCreate1(long native_shaderA, long native_shaderB,
- long native_mode);
- private static native long nativeCreate2(long native_shaderA, long native_shaderB,
+ private static native int nativeCreate1(int native_shaderA, int native_shaderB,
+ int native_mode);
+ private static native int nativeCreate2(int native_shaderA, int native_shaderB,
int porterDuffMode);
- private static native long nativePostCreate1(long native_shader, long native_skiaShaderA,
- long native_skiaShaderB, long native_mode);
- private static native long nativePostCreate2(long native_shader, long native_skiaShaderA,
- long native_skiaShaderB, int porterDuffMode);
+ private static native int nativePostCreate1(int native_shader, int native_skiaShaderA,
+ int native_skiaShaderB, int native_mode);
+ private static native int nativePostCreate2(int native_shader, int native_skiaShaderA,
+ int native_skiaShaderB, int porterDuffMode);
}
native_instance = nativeCreate(radius);
}
- private static native long nativeCreate(float radius);
+ private static native int nativeCreate(float radius);
}
native_instance = nativeCreate(intervals, phase);
}
- private static native long nativeCreate(float intervals[], float phase);
+ private static native int nativeCreate(float intervals[], float phase);
}
native_instance = nativeCreate(segmentLength, deviation);
}
- private static native long nativeCreate(float length, float deviation);
+ private static native int nativeCreate(float length, float deviation);
}
public class DrawFilter {
// this is set by subclasses, but don't make it public
- /* package */ long mNativeInt; // pointer to native object
+ /* package */ int mNativeInt; // pointer to native object
protected void finalize() throws Throwable {
try {
}
}
- private static native void nativeDestructor(long nativeDrawFilter);
+ private static native void nativeDestructor(int nativeDrawFilter);
}
native_instance = nativeConstructor(direction, ambient, specular, blurRadius);
}
- private static native long nativeConstructor(float[] direction, float ambient, float specular, float blurRadius);
+ private static native int nativeConstructor(float[] direction, float ambient, float specular, float blurRadius);
}
* @hide
*/
public final class LargeBitmap {
- private long mNativeLargeBitmap;
+ private int mNativeLargeBitmap;
private boolean mRecycled;
/* Private constructor that must received an already allocated native
This can be called from JNI code.
*/
- private LargeBitmap(long nativeLbm) {
- mNativeLargeBitmap = nativeLbm;
+ private LargeBitmap(int lbm) {
+ mNativeLargeBitmap = lbm;
mRecycled = false;
}
recycle();
}
- private static native Bitmap nativeDecodeRegion(long nativeLbm,
+ private static native Bitmap nativeDecodeRegion(int lbm,
int start_x, int start_y, int width, int height,
BitmapFactory.Options options);
- private static native int nativeGetWidth(long nativeLbm);
- private static native int nativeGetHeight(long nativeLbm);
- private static native void nativeClean(long nativeLbm);
+ private static native int nativeGetWidth(int lbm);
+ private static native int nativeGetHeight(int lbm);
+ private static native void nativeClean(int lbm);
}
nativeAddLayer(native_instance, paint.mNativePaint, 0, 0);
}
- private static native long nativeConstructor();
- private static native void nativeAddLayer(long native_layer, long native_paint, float dx, float dy);
+ private static native int nativeConstructor();
+ private static native void nativeAddLayer(int native_layer, int native_paint, float dx, float dy);
}
nativeColorFilter = nCreateLightingFilter(native_instance, mMul, mAdd);
}
- private static native long native_CreateLightingFilter(int mul, int add);
- private static native long nCreateLightingFilter(long nativeFilter, int mul, int add);
+ private static native int native_CreateLightingFilter(int mul, int add);
+ private static native int nCreateLightingFilter(int nativeFilter, int mul, int add);
}
return copy;
}
- private native long nativeCreate1(float x0, float y0, float x1, float y1,
+ private native int nativeCreate1(float x0, float y0, float x1, float y1,
int colors[], float positions[], int tileMode);
- private native long nativeCreate2(float x0, float y0, float x1, float y1,
+ private native int nativeCreate2(float x0, float y0, float x1, float y1,
int color0, int color1, int tileMode);
- private native long nativePostCreate1(long native_shader, float x0, float y0, float x1, float y1,
+ private native int nativePostCreate1(int native_shader, float x0, float y0, float x1, float y1,
int colors[], float positions[], int tileMode);
- private native long nativePostCreate2(long native_shader, float x0, float y0, float x1, float y1,
+ private native int nativePostCreate2(int native_shader, float x0, float y0, float x1, float y1,
int color0, int color1, int tileMode);
}
nativeDestructor(native_instance);
}
- private static native void nativeDestructor(long native_filter);
- long native_instance;
+ private static native void nativeDestructor(int native_filter);
+ int native_instance;
}
/**
* @hide
*/
- public long native_instance;
+ public int native_instance;
/**
* Create an identity matrix
}
}
- /*package*/ final long ni() {
+ /*package*/ final int ni() {
return native_instance;
}
- private static native long native_create(long native_src_or_zero);
- private static native boolean native_isIdentity(long native_object);
- private static native boolean native_rectStaysRect(long native_object);
- private static native void native_reset(long native_object);
- private static native void native_set(long native_object,
- long native_other);
- private static native void native_setTranslate(long native_object,
+ private static native int native_create(int native_src_or_zero);
+ private static native boolean native_isIdentity(int native_object);
+ private static native boolean native_rectStaysRect(int native_object);
+ private static native void native_reset(int native_object);
+ private static native void native_set(int native_object, int other);
+ private static native void native_setTranslate(int native_object,
float dx, float dy);
- private static native void native_setScale(long native_object,
+ private static native void native_setScale(int native_object,
float sx, float sy, float px, float py);
- private static native void native_setScale(long native_object,
+ private static native void native_setScale(int native_object,
float sx, float sy);
- private static native void native_setRotate(long native_object,
+ private static native void native_setRotate(int native_object,
float degrees, float px, float py);
- private static native void native_setRotate(long native_object,
+ private static native void native_setRotate(int native_object,
float degrees);
- private static native void native_setSinCos(long native_object,
+ private static native void native_setSinCos(int native_object,
float sinValue, float cosValue, float px, float py);
- private static native void native_setSinCos(long native_object,
+ private static native void native_setSinCos(int native_object,
float sinValue, float cosValue);
- private static native void native_setSkew(long native_object,
+ private static native void native_setSkew(int native_object,
float kx, float ky, float px, float py);
- private static native void native_setSkew(long native_object,
+ private static native void native_setSkew(int native_object,
float kx, float ky);
- private static native boolean native_setConcat(long native_object,
- long native_a,
- long native_b);
- private static native boolean native_preTranslate(long native_object,
+ private static native boolean native_setConcat(int native_object,
+ int a, int b);
+ private static native boolean native_preTranslate(int native_object,
float dx, float dy);
- private static native boolean native_preScale(long native_object,
+ private static native boolean native_preScale(int native_object,
float sx, float sy, float px, float py);
- private static native boolean native_preScale(long native_object,
+ private static native boolean native_preScale(int native_object,
float sx, float sy);
- private static native boolean native_preRotate(long native_object,
+ private static native boolean native_preRotate(int native_object,
float degrees, float px, float py);
- private static native boolean native_preRotate(long native_object,
+ private static native boolean native_preRotate(int native_object,
float degrees);
- private static native boolean native_preSkew(long native_object,
+ private static native boolean native_preSkew(int native_object,
float kx, float ky, float px, float py);
- private static native boolean native_preSkew(long native_object,
+ private static native boolean native_preSkew(int native_object,
float kx, float ky);
- private static native boolean native_preConcat(long native_object,
- long native_other_matrix);
- private static native boolean native_postTranslate(long native_object,
+ private static native boolean native_preConcat(int native_object,
+ int other_matrix);
+ private static native boolean native_postTranslate(int native_object,
float dx, float dy);
- private static native boolean native_postScale(long native_object,
+ private static native boolean native_postScale(int native_object,
float sx, float sy, float px, float py);
- private static native boolean native_postScale(long native_object,
+ private static native boolean native_postScale(int native_object,
float sx, float sy);
- private static native boolean native_postRotate(long native_object,
+ private static native boolean native_postRotate(int native_object,
float degrees, float px, float py);
- private static native boolean native_postRotate(long native_object,
+ private static native boolean native_postRotate(int native_object,
float degrees);
- private static native boolean native_postSkew(long native_object,
+ private static native boolean native_postSkew(int native_object,
float kx, float ky, float px, float py);
- private static native boolean native_postSkew(long native_object,
+ private static native boolean native_postSkew(int native_object,
float kx, float ky);
- private static native boolean native_postConcat(long native_object,
- long native_other_matrix);
- private static native boolean native_setRectToRect(long native_object,
+ private static native boolean native_postConcat(int native_object,
+ int other_matrix);
+ private static native boolean native_setRectToRect(int native_object,
RectF src, RectF dst, int stf);
- private static native boolean native_setPolyToPoly(long native_object,
+ private static native boolean native_setPolyToPoly(int native_object,
float[] src, int srcIndex, float[] dst, int dstIndex, int pointCount);
- private static native boolean native_invert(long native_object,
- long native_inverse);
- private static native void native_mapPoints(long native_object,
+ private static native boolean native_invert(int native_object, int inverse);
+ private static native void native_mapPoints(int native_object,
float[] dst, int dstIndex, float[] src, int srcIndex,
int ptCount, boolean isPts);
- private static native boolean native_mapRect(long native_object,
+ private static native boolean native_mapRect(int native_object,
RectF dst, RectF src);
- private static native float native_mapRadius(long native_object,
+ private static native float native_mapRadius(int native_object,
float radius);
- private static native void native_getValues(long native_object,
+ private static native void native_getValues(int native_object,
float[] values);
- private static native void native_setValues(long native_object,
+ private static native void native_setValues(int native_object,
float[] values);
- private static native boolean native_equals(long native_a, long native_b);
- private static native void finalizer(long native_instance);
+ private static native boolean native_equals(int native_a, int native_b);
+ private static native void finalizer(int native_instance);
}
*
* @hide
*/
- public final long mNativeChunk;
+ public final int mNativeChunk;
private Paint mPaint;
private String mSrcName;
* that are transparent.
*/
public final Region getTransparentRegion(Rect bounds) {
- long r = nativeGetTransparentRegion(mBitmap.ni(), mNativeChunk, bounds);
+ int r = nativeGetTransparentRegion(mBitmap.ni(), mNativeChunk, bounds);
return r != 0 ? new Region(r) : null;
}
* If validation is successful, this method returns a native Res_png_9patch*
* object used by the renderers.
*/
- private static native long validateNinePatchChunk(long bitmap, byte[] chunk);
- private static native void nativeFinalize(long chunk);
- private static native void nativeDraw(long canvas_instance, RectF loc, long bitmap_instance,
- long c, long paint_instance_or_null, int destDensity, int srcDensity);
- private static native void nativeDraw(long canvas_instance, Rect loc, long bitmap_instance,
- long c, long paint_instance_or_null, int destDensity, int srcDensity);
- private static native long nativeGetTransparentRegion(long bitmap, long chunk, Rect location);
+ private static native int validateNinePatchChunk(int bitmap, byte[] chunk);
+ private static native void nativeFinalize(int chunk);
+ private static native void nativeDraw(int canvas_instance, RectF loc, int bitmap_instance,
+ int c, int paint_instance_or_null, int destDensity, int srcDensity);
+ private static native void nativeDraw(int canvas_instance, Rect loc, int bitmap_instance,
+ int c, int paint_instance_or_null, int destDensity, int srcDensity);
+ private static native int nativeGetTransparentRegion(int bitmap, int chunk, Rect location);
}
/**
* @hide
*/
- public long mNativePaint;
+ public int mNativePaint;
/**
* @hide
*/
- public long mNativeTypeface;
+ public int mNativeTypeface;
private ColorFilter mColorFilter;
private MaskFilter mMaskFilter;
* @return shader
*/
public Shader setShader(Shader shader) {
- long shaderNative = 0;
+ int shaderNative = 0;
if (shader != null)
shaderNative = shader.native_instance;
native_setShader(mNativePaint, shaderNative);
* @return filter
*/
public ColorFilter setColorFilter(ColorFilter filter) {
- long filterNative = 0;
+ int filterNative = 0;
if (filter != null)
filterNative = filter.native_instance;
native_setColorFilter(mNativePaint, filterNative);
* @return xfermode
*/
public Xfermode setXfermode(Xfermode xfermode) {
- long xfermodeNative = 0;
+ int xfermodeNative = 0;
if (xfermode != null)
xfermodeNative = xfermode.native_instance;
native_setXfermode(mNativePaint, xfermodeNative);
* @return effect
*/
public PathEffect setPathEffect(PathEffect effect) {
- long effectNative = 0;
+ int effectNative = 0;
if (effect != null) {
effectNative = effect.native_instance;
}
* @return maskfilter
*/
public MaskFilter setMaskFilter(MaskFilter maskfilter) {
- long maskfilterNative = 0;
+ int maskfilterNative = 0;
if (maskfilter != null) {
maskfilterNative = maskfilter.native_instance;
}
* @return typeface
*/
public Typeface setTypeface(Typeface typeface) {
- long typefaceNative = 0;
+ int typefaceNative = 0;
if (typeface != null) {
typefaceNative = typeface.native_instance;
}
* @return rasterizer
*/
public Rasterizer setRasterizer(Rasterizer rasterizer) {
- long rasterizerNative = 0;
+ int rasterizerNative = 0;
if (rasterizer != null) {
rasterizerNative = rasterizer.native_instance;
}
}
}
- private static native long native_init();
- private static native long native_initWithPaint(long paint);
- private static native void native_reset(long native_object);
- private static native void native_set(long native_dst, long native_src);
- private static native int native_getStyle(long native_object);
- private static native void native_setStyle(long native_object, int style);
- private static native int native_getStrokeCap(long native_object);
- private static native void native_setStrokeCap(long native_object, int cap);
- private static native int native_getStrokeJoin(long native_object);
- private static native void native_setStrokeJoin(long native_object,
+ private static native int native_init();
+ private static native int native_initWithPaint(int paint);
+ private static native void native_reset(int native_object);
+ private static native void native_set(int native_dst, int native_src);
+ private static native int native_getStyle(int native_object);
+ private static native void native_setStyle(int native_object, int style);
+ private static native int native_getStrokeCap(int native_object);
+ private static native void native_setStrokeCap(int native_object, int cap);
+ private static native int native_getStrokeJoin(int native_object);
+ private static native void native_setStrokeJoin(int native_object,
int join);
- private static native boolean native_getFillPath(long native_object,
- long src, long dst);
- private static native long native_setShader(long native_object, long shader);
- private static native long native_setColorFilter(long native_object,
- long filter);
- private static native long native_setXfermode(long native_object,
- long xfermode);
- private static native long native_setPathEffect(long native_object,
- long effect);
- private static native long native_setMaskFilter(long native_object,
- long maskfilter);
- private static native long native_setTypeface(long native_object,
- long typeface);
- private static native long native_setRasterizer(long native_object,
- long rasterizer);
-
- private static native int native_getTextAlign(long native_object);
- private static native void native_setTextAlign(long native_object,
+ private static native boolean native_getFillPath(int native_object,
+ int src, int dst);
+ private static native int native_setShader(int native_object, int shader);
+ private static native int native_setColorFilter(int native_object,
+ int filter);
+ private static native int native_setXfermode(int native_object,
+ int xfermode);
+ private static native int native_setPathEffect(int native_object,
+ int effect);
+ private static native int native_setMaskFilter(int native_object,
+ int maskfilter);
+ private static native int native_setTypeface(int native_object,
+ int typeface);
+ private static native int native_setRasterizer(int native_object,
+ int rasterizer);
+
+ private static native int native_getTextAlign(int native_object);
+ private static native void native_setTextAlign(int native_object,
int align);
- private static native void native_setTextLocale(long native_object,
+ private static native void native_setTextLocale(int native_object,
String locale);
- private static native int native_getTextWidths(long native_object,
+ private static native int native_getTextWidths(int native_object,
char[] text, int index, int count, int bidiFlags, float[] widths);
- private static native int native_getTextWidths(long native_object,
+ private static native int native_getTextWidths(int native_object,
String text, int start, int end, int bidiFlags, float[] widths);
- private static native int native_getTextGlyphs(long native_object,
+ private static native int native_getTextGlyphs(int native_object,
String text, int start, int end, int contextStart, int contextEnd,
int flags, char[] glyphs);
- private static native float native_getTextRunAdvances(long native_object,
+ private static native float native_getTextRunAdvances(int native_object,
char[] text, int index, int count, int contextIndex, int contextCount,
int flags, float[] advances, int advancesIndex);
- private static native float native_getTextRunAdvances(long native_object,
+ private static native float native_getTextRunAdvances(int native_object,
String text, int start, int end, int contextStart, int contextEnd,
int flags, float[] advances, int advancesIndex);
- private native int native_getTextRunCursor(long native_object, char[] text,
+ private native int native_getTextRunCursor(int native_object, char[] text,
int contextStart, int contextLength, int flags, int offset, int cursorOpt);
- private native int native_getTextRunCursor(long native_object, String text,
+ private native int native_getTextRunCursor(int native_object, String text,
int contextStart, int contextEnd, int flags, int offset, int cursorOpt);
- private static native void native_getTextPath(long native_object, int bidiFlags,
- char[] text, int index, int count, float x, float y, long path);
- private static native void native_getTextPath(long native_object, int bidiFlags,
- String text, int start, int end, float x, float y, long path);
- private static native void nativeGetStringBounds(long nativePaint,
+ private static native void native_getTextPath(int native_object, int bidiFlags,
+ char[] text, int index, int count, float x, float y, int path);
+ private static native void native_getTextPath(int native_object, int bidiFlags,
+ String text, int start, int end, float x, float y, int path);
+ private static native void nativeGetStringBounds(int nativePaint,
String text, int start, int end, int bidiFlags, Rect bounds);
- private static native void nativeGetCharArrayBounds(long nativePaint,
+ private static native void nativeGetCharArrayBounds(int nativePaint,
char[] text, int index, int count, int bidiFlags, Rect bounds);
- private static native void finalizer(long nativePaint);
+ private static native void finalizer(int nativePaint);
}
mNativeInt = nativeConstructor(clearBits, setBits);
}
- private static native long nativeConstructor(int clearBits, int setBits);
+ private static native int nativeConstructor(int clearBits, int setBits);
}
/**
* @hide
*/
- public final long mNativePath;
- private long mNativePathMeasure;
+ public final int mNativePath;
+ private int mNativePathMeasure;
/**
* @hide
* @param src The path to copy from when initializing the new path
*/
public Path(Path src) {
- long valNative = 0;
+ int valNative = 0;
if (src != null) {
valNative = src.mNativePath;
isSimplePath = src.isSimplePath;
* the original path is modified.
*/
public void offset(float dx, float dy, Path dst) {
- long dstNative = 0;
+ int dstNative = 0;
if (dst != null) {
dstNative = dst.mNativePath;
dst.isSimplePath = false;
* then the the original path is modified
*/
public void transform(Matrix matrix, Path dst) {
- long dstNative = 0;
+ int dstNative = 0;
if (dst != null) {
dst.isSimplePath = false;
dstNative = dst.mNativePath;
}
}
- final long ni() {
+ final int ni() {
return mNativePath;
}
if (trimStart > trimEnd) {
throw new IllegalArgumentException("trim end cannot be less than start");
}
- long dstNative = 0;
+ int dstNative = 0;
if (dst != null) {
dstNative = dst.mNativePath;
dst.isSimplePath = false;
trimStart, trimEnd, trimOffset);
}
- private static native long init1();
- private static native long init2(long nPath);
- private static native void native_reset(long nPath);
- private static native void native_rewind(long nPath);
- private static native void native_set(long native_dst, long native_src);
- private static native int native_getFillType(long nPath);
- private static native void native_setFillType(long nPath, int ft);
- private static native boolean native_isEmpty(long nPath);
- private static native boolean native_isRect(long nPath, RectF rect);
- private static native void native_computeBounds(long nPath, RectF bounds);
- private static native void native_incReserve(long nPath, int extraPtCount);
- private static native void native_moveTo(long nPath, float x, float y);
- private static native void native_rMoveTo(long nPath, float dx, float dy);
- private static native void native_lineTo(long nPath, float x, float y);
- private static native void native_rLineTo(long nPath, float dx, float dy);
- private static native void native_quadTo(long nPath, float x1, float y1,
+ private static native int init1();
+ private static native int init2(int nPath);
+ private static native void native_reset(int nPath);
+ private static native void native_rewind(int nPath);
+ private static native void native_set(int native_dst, int native_src);
+ private static native int native_getFillType(int nPath);
+ private static native void native_setFillType(int nPath, int ft);
+ private static native boolean native_isEmpty(int nPath);
+ private static native boolean native_isRect(int nPath, RectF rect);
+ private static native void native_computeBounds(int nPath, RectF bounds);
+ private static native void native_incReserve(int nPath, int extraPtCount);
+ private static native void native_moveTo(int nPath, float x, float y);
+ private static native void native_rMoveTo(int nPath, float dx, float dy);
+ private static native void native_lineTo(int nPath, float x, float y);
+ private static native void native_rLineTo(int nPath, float dx, float dy);
+ private static native void native_quadTo(int nPath, float x1, float y1,
float x2, float y2);
- private static native void native_rQuadTo(long nPath, float dx1, float dy1,
+ private static native void native_rQuadTo(int nPath, float dx1, float dy1,
float dx2, float dy2);
- private static native void native_cubicTo(long nPath, float x1, float y1,
+ private static native void native_cubicTo(int nPath, float x1, float y1,
float x2, float y2, float x3, float y3);
- private static native void native_rCubicTo(long nPath, float x1, float y1,
+ private static native void native_rCubicTo(int nPath, float x1, float y1,
float x2, float y2, float x3, float y3);
- private static native void native_arcTo(long nPath, RectF oval,
+ private static native void native_arcTo(int nPath, RectF oval,
float startAngle, float sweepAngle, boolean forceMoveTo);
- private static native void native_close(long nPath);
- private static native void native_addRect(long nPath, RectF rect, int dir);
- private static native void native_addRect(long nPath, float left, float top,
+ private static native void native_close(int nPath);
+ private static native void native_addRect(int nPath, RectF rect, int dir);
+ private static native void native_addRect(int nPath, float left, float top,
float right, float bottom, int dir);
- private static native void native_addOval(long nPath, RectF oval, int dir);
- private static native void native_addCircle(long nPath, float x, float y, float radius, int dir);
- private static native void native_addArc(long nPath, RectF oval,
+ private static native void native_addOval(int nPath, RectF oval, int dir);
+ private static native void native_addCircle(int nPath, float x, float y, float radius, int dir);
+ private static native void native_addArc(int nPath, RectF oval,
float startAngle, float sweepAngle);
- private static native void native_addRoundRect(long nPath, RectF rect,
+ private static native void native_addRoundRect(int nPath, RectF rect,
float rx, float ry, int dir);
- private static native void native_addRoundRect(long nPath, RectF r, float[] radii, int dir);
- private static native void native_addPath(long nPath, long src, float dx, float dy);
- private static native void native_addPath(long nPath, long src);
- private static native void native_addPath(long nPath, long src, long matrix);
- private static native void native_offset(long nPath, float dx, float dy, long dst_path);
- private static native void native_offset(long nPath, float dx, float dy);
- private static native void native_setLastPoint(long nPath, float dx, float dy);
- private static native void native_transform(long nPath, long matrix, long dst_path);
- private static native void native_transform(long nPath, long matrix);
- private static native boolean native_op(long path1, long path2, int op, long result);
- private static native void finalizer(long nPath);
- private static native float[] native_approximate(long nPath, float error);
- private static native int native_trim(long nPath, long nTargetPath, long nPathMeasure,
+ private static native void native_addRoundRect(int nPath, RectF r, float[] radii, int dir);
+ private static native void native_addPath(int nPath, int src, float dx, float dy);
+ private static native void native_addPath(int nPath, int src);
+ private static native void native_addPath(int nPath, int src, int matrix);
+ private static native void native_offset(int nPath, float dx, float dy, int dst_path);
+ private static native void native_offset(int nPath, float dx, float dy);
+ private static native void native_setLastPoint(int nPath, float dx, float dy);
+ private static native void native_transform(int nPath, int matrix, int dst_path);
+ private static native void native_transform(int nPath, int matrix);
+ private static native boolean native_op(int path1, int path2, int op, int result);
+ private static native void finalizer(int nPath);
+ private static native float[] native_approximate(int nPath, float error);
+ private static native int native_trim(int nPath, int nTargetPath, int nPathMeasure,
float trimStart, float trimEnd, float trimOffset);
- private static native void native_destroyMeasure(long nPathMeasure);
+ private static native void native_destroyMeasure(int nPathMeasure);
}
style.native_style);
}
- private static native long nativeCreate(long native_path, float advance,
+ private static native int nativeCreate(int native_path, float advance,
float phase, int native_style);
}
nativeDestructor(native_instance);
}
- private static native void nativeDestructor(long native_patheffect);
- long native_instance;
+ private static native void nativeDestructor(int native_patheffect);
+ int native_instance;
}
*/
public class Picture {
private Canvas mRecordingCanvas;
- private final long mNativePicture;
+ private final int mNativePicture;
/**
* @hide
* into it.
*/
public Canvas beginRecording(int width, int height) {
- long ni = nativeBeginRecording(mNativePicture, width, height);
+ int ni = nativeBeginRecording(mNativePicture, width, height);
mRecordingCanvas = new RecordingCanvas(this, ni);
return mRecordingCanvas;
}
}
}
- final long ni() {
+ final int ni() {
return mNativePicture;
}
- private Picture(long nativePicture, boolean fromStream) {
+ private Picture(int nativePicture, boolean fromStream) {
if (nativePicture == 0) {
throw new RuntimeException();
}
}
// return empty picture if src is 0, or a copy of the native src
- private static native long nativeConstructor(long nativeSrcOr0);
- private static native long nativeCreateFromStream(InputStream stream,
+ private static native int nativeConstructor(int nativeSrcOr0);
+ private static native int nativeCreateFromStream(InputStream stream,
byte[] storage);
- private static native long nativeBeginRecording(long nativeCanvas,
+ private static native int nativeBeginRecording(int nativeCanvas,
int w, int h);
- private static native void nativeEndRecording(long nativeCanvas);
- private static native void nativeDraw(long nativeCanvas, long nativePicture);
- private static native boolean nativeWriteToStream(long nativePicture,
+ private static native void nativeEndRecording(int nativeCanvas);
+ private static native void nativeDraw(int nativeCanvas, int nativePicture);
+ private static native boolean nativeWriteToStream(int nativePicture,
OutputStream stream, byte[] storage);
- private static native void nativeDestructor(long nativePicture);
+ private static native void nativeDestructor(int nativePicture);
private static class RecordingCanvas extends Canvas {
private final Picture mPicture;
- public RecordingCanvas(Picture pict, long nativeCanvas) {
+ public RecordingCanvas(Picture pict, int nativeCanvas) {
super(nativeCanvas);
mPicture = pict;
}
native_instance = nativeCreate(opColor);
}
- private static native long nativeCreate(int opColor);
+ private static native int nativeCreate(int opColor);
}
nativeColorFilter = nCreatePorterDuffFilter(native_instance, mColor, mMode.nativeInt);
}
- private static native long native_CreatePorterDuffFilter(int srcColor, int porterDuffMode);
- private static native long nCreatePorterDuffFilter(long nativeFilter, int srcColor,
+ private static native int native_CreatePorterDuffFilter(int srcColor, int porterDuffMode);
+ private static native int nCreatePorterDuffFilter(int nativeFilter, int srcColor,
int porterDuffMode);
}
native_instance = nativeCreateXfermode(mode.nativeInt);
}
- private static native long nativeCreateXfermode(int mode);
+ private static native int nativeCreateXfermode(int mode);
}
return copy;
}
- private static native long nativeCreate1(float x, float y, float radius,
+ private static native int nativeCreate1(float x, float y, float radius,
int colors[], float positions[], int tileMode);
- private static native long nativeCreate2(float x, float y, float radius,
+ private static native int nativeCreate2(float x, float y, float radius,
int color0, int color1, int tileMode);
- private static native long nativePostCreate1(long native_shader, float x, float y, float radius,
+ private static native int nativePostCreate1(int native_shader, float x, float y, float radius,
int colors[], float positions[], int tileMode);
- private static native long nativePostCreate2(long native_shader, float x, float y, float radius,
+ private static native int nativePostCreate2(int native_shader, float x, float y, float radius,
int color0, int color1, int tileMode);
}
finalizer(native_instance);
}
- private static native void finalizer(long native_instance);
+ private static native void finalizer(int native_instance);
- long native_instance;
+ int native_instance;
}
/**
* @hide
*/
- public final long mNativeRegion;
+ public final int mNativeRegion;
// the native values for these must match up with the enum in SkRegion.h
public enum Op {
* @return a new region created from the data in the parcel
*/
public Region createFromParcel(Parcel p) {
- long ni = nativeCreateFromParcel(p);
+ int ni = nativeCreateFromParcel(p);
if (ni == 0) {
throw new RuntimeException();
}
}
}
- Region(long ni) {
+ Region(int ni) {
if (ni == 0) {
throw new RuntimeException();
}
/* add dummy parameter so constructor can be called from jni without
triggering 'not cloneable' exception */
- private Region(long ni, int dummy) {
+ private Region(int ni, int dummy) {
this(ni);
}
- final long ni() {
+ final int ni() {
return mNativeRegion;
}
- private static native boolean nativeEquals(long native_r1, long native_r2);
+ private static native boolean nativeEquals(int native_r1, int native_r2);
- private static native long nativeConstructor();
- private static native void nativeDestructor(long native_region);
+ private static native int nativeConstructor();
+ private static native void nativeDestructor(int native_region);
- private static native void nativeSetRegion(long native_dst, long native_src);
- private static native boolean nativeSetRect(long native_dst, int left,
+ private static native void nativeSetRegion(int native_dst, int native_src);
+ private static native boolean nativeSetRect(int native_dst, int left,
int top, int right, int bottom);
- private static native boolean nativeSetPath(long native_dst, long native_path,
- long native_clip);
- private static native boolean nativeGetBounds(long native_region, Rect rect);
- private static native boolean nativeGetBoundaryPath(long native_region,
- long native_path);
+ private static native boolean nativeSetPath(int native_dst, int native_path,
+ int native_clip);
+ private static native boolean nativeGetBounds(int native_region, Rect rect);
+ private static native boolean nativeGetBoundaryPath(int native_region,
+ int native_path);
- private static native boolean nativeOp(long native_dst, int left, int top,
+ private static native boolean nativeOp(int native_dst, int left, int top,
int right, int bottom, int op);
- private static native boolean nativeOp(long native_dst, Rect rect,
- long native_region, int op);
- private static native boolean nativeOp(long native_dst, long native_region1,
- long native_region2, int op);
+ private static native boolean nativeOp(int native_dst, Rect rect,
+ int native_region, int op);
+ private static native boolean nativeOp(int native_dst, int native_region1,
+ int native_region2, int op);
- private static native long nativeCreateFromParcel(Parcel p);
- private static native boolean nativeWriteToParcel(long native_region,
+ private static native int nativeCreateFromParcel(Parcel p);
+ private static native boolean nativeWriteToParcel(int native_region,
Parcel p);
- private static native String nativeToString(long native_region);
+ private static native String nativeToString(int native_region);
}
nativeDestructor(mNativeIter);
}
- private static native long nativeConstructor(long native_region);
- private static native void nativeDestructor(long native_iter);
- private static native boolean nativeNext(long native_iter, Rect r);
-
- private final long mNativeIter;
+ private static native int nativeConstructor(int native_region);
+ private static native void nativeDestructor(int native_iter);
+ private static native boolean nativeNext(int native_iter, Rect r);
+
+ private final int mNativeIter;
}
*
* @hide
*/
- public long native_instance;
+ public int native_instance;
/**
* @hide
*/
- public long native_shader;
+ public int native_shader;
private Matrix mLocalMatrix;
}
}
- private static native void nativeDestructor(long native_shader, long native_skiaShader);
- private static native void nativeSetLocalMatrix(long native_shader,
- long native_skiaShader, long matrix_instance);
+ private static native void nativeDestructor(int native_shader, int native_skiaShader);
+ private static native void nativeSetLocalMatrix(int native_shader,
+ int native_skiaShader, int matrix_instance);
}
second.native_instance);
}
- private static native long nativeCreate(long first, long second);
+ private static native int nativeCreate(int first, int second);
}
return copy;
}
- private static native long nativeCreate1(float x, float y, int colors[], float positions[]);
- private static native long nativeCreate2(float x, float y, int color0, int color1);
+ private static native int nativeCreate1(float x, float y, int colors[], float positions[]);
+ private static native int nativeCreate2(float x, float y, int color0, int color1);
- private static native long nativePostCreate1(long native_shader, float cx, float cy,
+ private static native int nativePostCreate1(int native_shader, float cx, float cy,
int[] colors, float[] positions);
- private static native long nativePostCreate2(long native_shader, float cx, float cy,
+ private static native int nativePostCreate2(int native_shader, float cx, float cy,
int color0, int color1);
}
native_instance = nativeNewTable(table);
}
- private TableMaskFilter(long ni) {
+ private TableMaskFilter(int ni) {
native_instance = ni;
}
return new TableMaskFilter(nativeNewGamma(gamma));
}
- private static native long nativeNewTable(byte[] table);
- private static native long nativeNewClip(int min, int max);
- private static native long nativeNewGamma(float gamma);
+ private static native int nativeNewTable(byte[] table);
+ private static native int nativeNewClip(int min, int max);
+ private static native int nativeNewGamma(float gamma);
}
import android.content.res.AssetManager;
import android.util.SparseArray;
-import android.util.LongSparseArray;
import java.io.File;
public static final Typeface MONOSPACE;
static Typeface[] sDefaults;
- private static final LongSparseArray<SparseArray<Typeface>> sTypefaceCache =
- new LongSparseArray<SparseArray<Typeface>>(3);
+ private static final SparseArray<SparseArray<Typeface>> sTypefaceCache =
+ new SparseArray<SparseArray<Typeface>>(3);
/**
* @hide
*/
- public long native_instance;
+ public int native_instance;
// Style
public static final int NORMAL = 0;
* @return The best matching typeface.
*/
public static Typeface create(Typeface family, int style) {
- long ni = 0;
+ int ni = 0;
if (family != null) {
// Return early if we're asked for the same face/style
if (family.mStyle == style) {
}
// don't allow clients to call this directly
- private Typeface(long ni) {
+ private Typeface(int ni) {
if (ni == 0) {
throw new RuntimeException("native typeface cannot be made");
}
@Override
public int hashCode() {
- /*
- * Modified method for hashCode with long native_instance derived from
- * http://developer.android.com/reference/java/lang/Object.html
- */
- int result = 17;
- result = 31 * result + (int) (native_instance ^ (native_instance >>> 32));
+ int result = native_instance;
result = 31 * result + mStyle;
return result;
}
- private static native long nativeCreate(String familyName, int style);
- private static native long nativeCreateFromTypeface(long native_instance, int style);
- private static native void nativeUnref(long native_instance);
- private static native int nativeGetStyle(long native_instance);
- private static native long nativeCreateFromAsset(AssetManager mgr, String path);
- private static native long nativeCreateFromFile(String path);
+ private static native int nativeCreate(String familyName, int style);
+ private static native int nativeCreateFromTypeface(int native_instance, int style);
+ private static native void nativeUnref(int native_instance);
+ private static native int nativeGetStyle(int native_instance);
+ private static native int nativeCreateFromAsset(AssetManager mgr, String path);
+ private static native int nativeCreateFromFile(String path);
}
}
}
- private static native void finalizer(long native_instance);
+ private static native void finalizer(int native_instance);
- long native_instance;
+ int native_instance;
}
config);
SkBitmap *bitmap =
- (SkBitmap *) env->GetLongField(jBitmap, fields.nativeBitmap);
+ (SkBitmap *) env->GetIntField(jBitmap, fields.nativeBitmap);
bitmap->lockPixels();
rotate((uint16_t*)bitmap->getPixels(),
if (fields.createScaledBitmapMethod == NULL) {
return;
}
- fields.nativeBitmap = env->GetFieldID(fields.bitmapClazz, "mNativeBitmap", "J");
+ fields.nativeBitmap = env->GetFieldID(fields.bitmapClazz, "mNativeBitmap", "I");
if (fields.nativeBitmap == NULL) {
return;
}
gContextId = _env->GetFieldID(_this, "mContext", "J");
jclass bitmapClass = _env->FindClass("android/graphics/Bitmap");
- gNativeBitmapID = _env->GetFieldID(bitmapClass, "mNativeBitmap", "J");
+ gNativeBitmapID = _env->GetFieldID(bitmapClass, "mNativeBitmap", "I");
}
// ---------------------------------------------------------------------------
nAllocationCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip, jobject jbitmap, jint usage)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)_env->GetLongField(jbitmap, gNativeBitmapID);
+ (SkBitmap const *)_env->GetIntField(jbitmap, gNativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
bitmap.lockPixels();
nAllocationCreateBitmapBackedAllocation(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip, jobject jbitmap, jint usage)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)_env->GetLongField(jbitmap, gNativeBitmapID);
+ (SkBitmap const *)_env->GetIntField(jbitmap, gNativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
bitmap.lockPixels();
nAllocationCubeCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip, jobject jbitmap, jint usage)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)_env->GetLongField(jbitmap, gNativeBitmapID);
+ (SkBitmap const *)_env->GetIntField(jbitmap, gNativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
bitmap.lockPixels();
nAllocationCopyFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject jbitmap)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)_env->GetLongField(jbitmap, gNativeBitmapID);
+ (SkBitmap const *)_env->GetIntField(jbitmap, gNativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
int w = bitmap.width();
int h = bitmap.height();
nAllocationCopyToBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject jbitmap)
{
SkBitmap const * nativeBitmap =
- (SkBitmap const *)_env->GetLongField(jbitmap, gNativeBitmapID);
+ (SkBitmap const *)_env->GetIntField(jbitmap, gNativeBitmapID);
const SkBitmap& bitmap(*nativeBitmap);
bitmap.lockPixels();
}
canvas.drawBitmap(bitmap, 0.0f, 0.0f, null);
canvas.restore();
- // TODO: Change mAtlasMap to long[] to support 64-bit systems
- atlasMap[mapIndex++] = (int) bitmap.mNativeBitmap;
+
+ atlasMap[mapIndex++] = bitmap.mNativeBitmap;
atlasMap[mapIndex++] = entry.x;
atlasMap[mapIndex++] = entry.y;
atlasMap[mapIndex++] = entry.rotated ? 1 : 0;
jfieldID mNativeCanvas;
} gCanvasFinalizerClassInfo;
-#define GET_LONG(object, field) \
- env->GetLongField(object, field)
+#define GET_INT(object, field) \
+ env->GetIntField(object, field)
-#define SET_LONG(object, field, value) \
- env->SetLongField(object, field, value)
+#define SET_INT(object, field, value) \
+ env->SetIntField(object, field, value)
// ----------------------------------------------------------------------------
// Canvas management
static inline void swapCanvasPtr(JNIEnv* env, jobject canvasObj, SkCanvas* newCanvas) {
jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer);
SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>(
- GET_LONG(canvasObj, gCanvasClassInfo.mNativeCanvas));
- SET_LONG(canvasObj, gCanvasClassInfo.mNativeCanvas, (long) newCanvas);
- SET_LONG(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (long) newCanvas);
+ GET_INT(canvasObj, gCanvasClassInfo.mNativeCanvas));
+ SET_INT(canvasObj, gCanvasClassInfo.mNativeCanvas, (int) newCanvas);
+ SET_INT(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int) newCanvas);
SkSafeUnref(previousCanvas);
}
FIND_CLASS(clazz, "android/graphics/Canvas");
GET_FIELD_ID(gCanvasClassInfo.mFinalizer, clazz, "mFinalizer",
"Landroid/graphics/Canvas$CanvasFinalizer;");
- GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J");
+ GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I");
FIND_CLASS(clazz, "android/graphics/Canvas$CanvasFinalizer");
- GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J");
+ GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I");
return jniRegisterNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
}
OSDN Git Service
