Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Revert "Add ninePatch support to Canvas.h""

Browse Source
This commit is contained in:
John Reck
2015-08-17 22:39:57 +00:00
committed by Android (Google) Code Review
parent 69ca9960ac 773bbe0357
commit 2fce18d99d
14 changed files with 145 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
core/java/android/view/DisplayListCanvas.java
View File

@@ -221,6 +221,29 @@ public class DisplayListCanvas extends Canvas {
// Drawing
///////////////////////////////////////////////////////////////////////////
// TODO: move to Canvas.java
@Override
public void drawPatch(NinePatch patch, Rect dst, Paint paint) {
Bitmap bitmap = patch.getBitmap();
throwIfCannotDraw(bitmap);
final long nativePaint = paint == null ? 0 : paint.getNativeInstance();
nDrawPatch(mNativeCanvasWrapper, bitmap, patch.mNativeChunk,
dst.left, dst.top, dst.right, dst.bottom, nativePaint);
}
// TODO: move to Canvas.java
@Override
public void drawPatch(NinePatch patch, RectF dst, Paint paint) {
Bitmap bitmap = patch.getBitmap();
throwIfCannotDraw(bitmap);
final long nativePaint = paint == null ? 0 : paint.getNativeInstance();
nDrawPatch(mNativeCanvasWrapper, bitmap, patch.mNativeChunk,
dst.left, dst.top, dst.right, dst.bottom, nativePaint);
}
private static native void nDrawPatch(long renderer, Bitmap bitmap, long chunk,
float left, float top, float right, float bottom, long paint);
public void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,
CanvasProperty<Float> radius, CanvasProperty<Paint> paint) {
nDrawCircle(mNativeCanvasWrapper, cx.getNativeContainer(), cy.getNativeContainer(),

1
core/jni/Android.mk
View File

@@ -114,6 +114,7 @@ LOCAL_SRC_FILES:= \
android/graphics/MinikinUtils.cpp \
android/graphics/Movie.cpp \
android/graphics/NinePatch.cpp \
android/graphics/NinePatchImpl.cpp \
android/graphics/NinePatchPeeker.cpp \
android/graphics/Paint.cpp \
android/graphics/PaintImpl.cpp \

77
core/jni/android/graphics/NinePatch.cpp
View File

@@ -29,11 +29,12 @@
#include "SkRegion.h"
#include "GraphicsJNI.h"
#include "utils/NinePatch.h"
#include "JNIHelp.h"
#include "core_jni_helpers.h"
extern void NinePatch_Draw(SkCanvas* canvas, const SkRect& bounds, const SkBitmap& bitmap,
const android::Res_png_9patch& chunk, const SkPaint* paint, SkRegion** outRegion);
using namespace android;
/**
@@ -87,6 +88,72 @@ public:
}
}
static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds, const SkBitmap& bitmap,
Res_png_9patch* chunk, const SkPaint* paint, jint destDensity, jint srcDensity) {
if (destDensity == srcDensity || destDensity == 0 || srcDensity == 0) {
ALOGV("Drawing unscaled 9-patch: (%g,%g)-(%g,%g)",
SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop),
SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom));
NinePatch_Draw(canvas, bounds, bitmap, *chunk, paint, NULL);
} else {
canvas->save();
SkScalar scale = destDensity / (float)srcDensity;
canvas->translate(bounds.fLeft, bounds.fTop);
canvas->scale(scale, scale);
bounds.fRight = (bounds.fRight-bounds.fLeft) / scale;
bounds.fBottom = (bounds.fBottom-bounds.fTop) / scale;
bounds.fLeft = bounds.fTop = 0;
ALOGV("Drawing scaled 9-patch: (%g,%g)-(%g,%g) srcDensity=%d destDensity=%d",
SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop),
SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom),
srcDensity, destDensity);
NinePatch_Draw(canvas, bounds, bitmap, *chunk, paint, NULL);
canvas->restore();
}
}
static void drawF(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRectF,
jobject jbitmap, jlong chunkHandle, jlong paintHandle,
jint destDensity, jint srcDensity) {
SkCanvas* canvas = reinterpret_cast<Canvas*>(canvasHandle)->asSkCanvas();
Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
SkASSERT(canvas);
SkASSERT(boundsRectF);
SkASSERT(chunk);
// paint is optional
SkBitmap bitmap;
GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
SkRect bounds;
GraphicsJNI::jrectf_to_rect(env, boundsRectF, &bounds);
draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity);
}
static void drawI(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRect,
jobject jbitmap, jlong chunkHandle, jlong paintHandle,
jint destDensity, jint srcDensity) {
SkCanvas* canvas = reinterpret_cast<Canvas*>(canvasHandle)->asSkCanvas();
Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
SkASSERT(canvas);
SkASSERT(boundsRect);
SkASSERT(chunk);
// paint is optional
SkBitmap bitmap;
GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
SkRect bounds;
GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);
draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity);
}
static jlong getTransparentRegion(JNIEnv* env, jobject, jobject jbitmap,
jlong chunkHandle, jobject boundsRect) {
Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
@@ -99,7 +166,7 @@ public:
GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);
SkRegion* region = NULL;
NinePatch::Draw(NULL, bounds, bitmap, *chunk, NULL, &region);
NinePatch_Draw(NULL, bounds, bitmap, *chunk, NULL, &region);
return reinterpret_cast<jlong>(region);
}
@@ -113,6 +180,10 @@ static JNINativeMethod gNinePatchMethods[] = {
{ "validateNinePatchChunk", "([B)J",
(void*) SkNinePatchGlue::validateNinePatchChunk },
{ "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize },
{ "nativeDraw", "(JLandroid/graphics/RectF;Landroid/graphics/Bitmap;JJII)V",
(void*) SkNinePatchGlue::drawF },
{ "nativeDraw", "(JLandroid/graphics/Rect;Landroid/graphics/Bitmap;JJII)V",
(void*) SkNinePatchGlue::drawI },
{ "nativeGetTransparentRegion", "(Landroid/graphics/Bitmap;JLandroid/graphics/Rect;)J",
(void*) SkNinePatchGlue::getTransparentRegion }
};

16
libs/hwui/utils/NinePatchImpl.cpp → core/jni/android/graphics/NinePatchImpl.cpp
View File

@@ -15,7 +15,11 @@
** limitations under the License.
*/
#include "utils/NinePatch.h"
#define LOG_TAG "NinePatch"
#define LOG_NDEBUG 1
#include <androidfw/ResourceTypes.h>
#include <utils/Log.h>
#include "SkBitmap.h"
#include "SkCanvas.h"
@@ -26,8 +30,6 @@
#include <utils/Log.h>
namespace android {
static const bool kUseTrace = true;
static bool gTrace = false;
@@ -95,9 +97,9 @@ SkScalar calculateStretch(SkScalar boundsLimit, SkScalar startingPoint,
return srcSpace * stretchySpaceRemaining / numStrechyPixelsRemaining;
}
void NinePatch::Draw(SkCanvas* canvas, const SkRect& bounds,
const SkBitmap& bitmap, const Res_png_9patch& chunk,
const SkPaint* paint, SkRegion** outRegion) {
void NinePatch_Draw(SkCanvas* canvas, const SkRect& bounds,
const SkBitmap& bitmap, const android::Res_png_9patch& chunk,
const SkPaint* paint, SkRegion** outRegion) {
if (canvas && canvas->quickReject(bounds)) {
return;
}
@@ -322,5 +324,3 @@ nextDiv:
dstRightsHaveBeenCached = true;
}
}
} // namespace android

38
core/jni/android_graphics_Canvas.cpp
View File

@@ -18,8 +18,6 @@
#include "GraphicsJNI.h"
#include "core_jni_helpers.h"
#include <androidfw/ResourceTypes.h>
#include <Canvas.h>
#include "SkDrawFilter.h"
#include "SkGraphics.h"
@@ -332,41 +330,6 @@ static void drawVertices(JNIEnv* env, jobject, jlong canvasHandle,
indices, indexCount, *paint);
}
static void drawNinePatch(JNIEnv* env, jlong canvasHandle, jobject jbitmap, jlong chunkHandle,
jfloat left, jfloat top, jfloat right, jfloat bottom,
jlong paintHandle, jint dstDensity, jint srcDensity) {
Canvas* canvas = get_canvas(canvasHandle);
SkBitmap bitmap;
GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
const android::Res_png_9patch* chunk = reinterpret_cast<android::Res_png_9patch*>(chunkHandle);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
if (CC_LIKELY(dstDensity == srcDensity || dstDensity == 0 || srcDensity == 0)) {
ALOGV("Drawing unscaled 9-patch: (%g,%g)-(%g,%g)", left, top, right, bottom);
canvas->drawNinePatch(bitmap, *chunk, left, top, right, bottom, paint);
} else {
canvas->save(SkCanvas::kMatrixClip_SaveFlag);
SkScalar scale = dstDensity / (float)srcDensity;
canvas->translate(left, top);
canvas->scale(scale, scale);
Paint filteredPaint;
if (paint) {
filteredPaint = *paint;
}
filteredPaint.setFilterQuality(kLow_SkFilterQuality);
ALOGV("Drawing scaled 9-patch: (0,0)-(%g,%g) srcDensity=%d destDensity=%d",
(right-left)/scale, (bottom-top)/scale, srcDensity, dstDensity);
canvas->drawNinePatch(bitmap, *chunk, 0, 0, (right-left)/scale, (bottom-top)/scale,
&filteredPaint);
canvas->restore();
}
}
static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jobject jbitmap,
jfloat left, jfloat top, jlong paintHandle, jint canvasDensity,
jint screenDensity, jint bitmapDensity) {
@@ -788,7 +751,6 @@ static JNINativeMethod gMethods[] = {
{"native_drawArc","(JFFFFFFZJ)V", (void*) CanvasJNI::drawArc},
{"native_drawPath","(JJJ)V", (void*) CanvasJNI::drawPath},
{"nativeDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)CanvasJNI::drawVertices},
{"native_drawNinePatch", "(JLandroid/graphics/Bitmap;JFFFFJII)V", (void*)CanvasJNI::drawNinePatch},
{"native_drawBitmap","(JLandroid/graphics/Bitmap;FFJIII)V", (void*) CanvasJNI::drawBitmap},
{"nativeDrawBitmapMatrix", "(JLandroid/graphics/Bitmap;JJ)V", (void*)CanvasJNI::drawBitmapMatrix},
{"native_drawBitmap","(JLandroid/graphics/Bitmap;FFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect},

15
core/jni/android_view_DisplayListCanvas.cpp
View File

@@ -22,6 +22,8 @@
#include <android_runtime/AndroidRuntime.h>
#include <androidfw/ResourceTypes.h>
#include <cutils/properties.h>
#include <SkBitmap.h>
@@ -81,6 +83,17 @@ static jint android_view_DisplayListCanvas_getMaxTextureHeight(JNIEnv* env, jobj
// Drawing
// ----------------------------------------------------------------------------
static void android_view_DisplayListCanvas_drawPatch(JNIEnv* env, jobject clazz,
jlong rendererPtr, jobject jbitmap, jlong patchPtr,
float left, float top, float right, float bottom, jlong paintPtr) {
SkBitmap bitmap;
GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
DisplayListCanvas* renderer = reinterpret_cast<DisplayListCanvas*>(rendererPtr);
Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(patchPtr);
Paint* paint = reinterpret_cast<Paint*>(paintPtr);
renderer->drawPatch(bitmap, patch, left, top, right, bottom, paint);
}
static void android_view_DisplayListCanvas_drawRoundRectProps(JNIEnv* env, jobject clazz,
jlong rendererPtr, jlong leftPropPtr, jlong topPropPtr, jlong rightPropPtr,
jlong bottomPropPtr, jlong rxPropPtr, jlong ryPropPtr, jlong paintPropPtr) {
@@ -183,6 +196,8 @@ static JNINativeMethod gMethods[] = {
{ "nCallDrawGLFunction", "(JJ)V", (void*) android_view_DisplayListCanvas_callDrawGLFunction },
{ "nDrawPatch", "(JLandroid/graphics/Bitmap;JFFFFJ)V", (void*) android_view_DisplayListCanvas_drawPatch },
{ "nDrawRoundRect", "(JJJJJJJJ)V", (void*) android_view_DisplayListCanvas_drawRoundRectProps },
{ "nDrawCircle", "(JJJJJ)V", (void*) android_view_DisplayListCanvas_drawCircleProps },

13
graphics/java/android/graphics/Canvas.java
View File

@@ -1281,10 +1281,7 @@ public class Canvas {
* @hide
*/
public void drawPatch(@NonNull NinePatch patch, @NonNull Rect dst, @Nullable Paint paint) {
final long nativePaint = paint == null ? 0 : paint.getNativeInstance();
native_drawNinePatch(mNativeCanvasWrapper, patch.getBitmap(), patch.mNativeChunk,
dst.left, dst.top, dst.right, dst.bottom, nativePaint,
mDensity, patch.getDensity());
patch.drawSoftware(this, dst, paint);
}
/**
@@ -1297,10 +1294,7 @@ public class Canvas {
* @hide
*/
public void drawPatch(@NonNull NinePatch patch, @NonNull RectF dst, @Nullable Paint paint) {
final long nativePaint = paint == null ? 0 : paint.getNativeInstance();
native_drawNinePatch(mNativeCanvasWrapper, patch.getBitmap(), patch.mNativeChunk,
dst.left, dst.top, dst.right, dst.bottom, nativePaint,
mDensity, patch.getDensity());
patch.drawSoftware(this, dst, paint);
}
/**
@@ -2068,9 +2062,6 @@ public class Canvas {
long nativePaint);
private static native void native_drawRegion(long nativeCanvas,
long nativeRegion, long nativePaint);
private native void native_drawNinePatch(long nativeCanvas, Bitmap bitmap,
long ninePatch, float dstLeft, float dstTop, float dstRight, float dstBottom,
long nativePaintOrZero, int screenDensity, int bitmapDensity);
private native void native_drawBitmap(long nativeCanvas, Bitmap bitmap,
float left, float top,
long nativePaintOrZero,

14
graphics/java/android/graphics/NinePatch.java
View File

@@ -198,6 +198,16 @@ public class NinePatch {
canvas.drawPatch(this, location, paint);
}
void drawSoftware(Canvas canvas, RectF location, Paint paint) {
nativeDraw(canvas.getNativeCanvasWrapper(), location, mBitmap, mNativeChunk,
paint != null ? paint.getNativeInstance() : 0, canvas.mDensity, mBitmap.mDensity);
}
void drawSoftware(Canvas canvas, Rect location, Paint paint) {
nativeDraw(canvas.getNativeCanvasWrapper(), location, mBitmap, mNativeChunk,
paint != null ? paint.getNativeInstance() : 0, canvas.mDensity, mBitmap.mDensity);
}
/**
* Return the underlying bitmap's density, as per
* {@link Bitmap#getDensity() Bitmap.getDensity()}.
@@ -263,5 +273,9 @@ public class NinePatch {
*/
private static native long validateNinePatchChunk(byte[] chunk);
private static native void nativeFinalize(long chunk);
private static native void nativeDraw(long canvas_instance, RectF loc, Bitmap bitmap_instance,
long c, long paint_instance_or_null, int destDensity, int srcDensity);
private static native void nativeDraw(long canvas_instance, Rect loc, Bitmap bitmap_instance,
long c, long paint_instance_or_null, int destDensity, int srcDensity);
private static native long nativeGetTransparentRegion(Bitmap bitmap, long chunk, Rect location);
}

1
libs/hwui/Android.mk
View File

@@ -23,7 +23,6 @@ hwui_src_files := \
utils/Blur.cpp \
utils/GLUtils.cpp \
utils/LinearAllocator.cpp \
utils/NinePatchImpl.cpp \
AmbientShadow.cpp \
AnimationContext.cpp \
Animator.cpp \

5
libs/hwui/Canvas.h
View File

@@ -19,8 +19,6 @@
#include <cutils/compiler.h>
#include "utils/NinePatch.h"
#include <SkBitmap.h>
#include <SkCanvas.h>
#include <SkMatrix.h>
@@ -146,9 +144,6 @@ public:
float dstRight, float dstBottom, const SkPaint* paint) = 0;
virtual void drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight,
const float* vertices, const int* colors, const SkPaint* paint) = 0;
virtual void drawNinePatch(const SkBitmap& bitmap, const android::Res_png_9patch& chunk,
float dstLeft, float dstTop, float dstRight, float dstBottom,
const SkPaint* paint) = 0;
// Text
/**

9
libs/hwui/DisplayListCanvas.cpp
View File

@@ -320,14 +320,13 @@ void DisplayListCanvas::drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, in
vertices, colors, paint));
}
void DisplayListCanvas::drawNinePatch(const SkBitmap& bitmap, const Res_png_9patch& patch,
float dstLeft, float dstTop, float dstRight, float dstBottom, const SkPaint* paint) {
void DisplayListCanvas::drawPatch(const SkBitmap& bitmap, const Res_png_9patch* patch,
float left, float top, float right, float bottom, const SkPaint* paint) {
const SkBitmap* bitmapPtr = refBitmap(bitmap);
const Res_png_9patch* patchPtr = refPatch(&patch);
patch = refPatch(patch);
paint = refPaint(paint);
addDrawOp(new (alloc()) DrawPatchOp(bitmapPtr, patchPtr,
dstLeft, dstTop, dstRight, dstBottom, paint));
addDrawOp(new (alloc()) DrawPatchOp(bitmapPtr, patch, left, top, right, bottom, paint));
}
void DisplayListCanvas::drawColor(int color, SkXfermode::Mode mode) {

7
libs/hwui/DisplayListCanvas.h
View File

@@ -79,6 +79,10 @@ public:
// HWUI Canvas draw operations
// ----------------------------------------------------------------------------
// TODO: move drawPatch() to Canvas.h
void drawPatch(const SkBitmap& bitmap, const Res_png_9patch* patch,
float left, float top, float right, float bottom, const SkPaint* paint);
// Shapes
void drawRoundRect(CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
@@ -205,9 +209,6 @@ public:
float dstRight, float dstBottom, const SkPaint* paint) override;
virtual void drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight,
const float* vertices, const int* colors, const SkPaint* paint) override;
virtual void drawNinePatch(const SkBitmap& bitmap, const android::Res_png_9patch& chunk,
float dstLeft, float dstTop, float dstRight, float dstBottom,
const SkPaint* paint) override;
// Text
virtual void drawText(const uint16_t* glyphs, const float* positions, int count,

9
libs/hwui/SkiaCanvas.cpp
View File

@@ -124,9 +124,6 @@ public:
float dstRight, float dstBottom, const SkPaint* paint) override;
virtual void drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight,
const float* vertices, const int* colors, const SkPaint* paint) override;
virtual void drawNinePatch(const SkBitmap& bitmap, const android::Res_png_9patch& chunk,
float dstLeft, float dstTop, float dstRight, float dstBottom,
const SkPaint* paint) override;
virtual void drawText(const uint16_t* text, const float* positions, int count,
const SkPaint& paint, float x, float y,
@@ -683,12 +680,6 @@ void SkiaCanvas::drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshH
indexCount, tmpPaint);
}
void SkiaCanvas::drawNinePatch(const SkBitmap& bitmap, const Res_png_9patch& chunk,
float dstLeft, float dstTop, float dstRight, float dstBottom, const SkPaint* paint) {
SkRect bounds = SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom);
NinePatch::Draw(mCanvas, bounds, bitmap, chunk, paint, nullptr);
}
// ----------------------------------------------------------------------------
// Canvas draw operations: Text
// ----------------------------------------------------------------------------

37
libs/hwui/utils/NinePatch.h
View File

@@ -1,37 +0,0 @@
/*
**
** Copyright 2015, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#ifndef ANDROID_GRAPHICS_NINEPATCH_H
#define ANDROID_GRAPHICS_NINEPATCH_H
#include <androidfw/ResourceTypes.h>
#include <cutils/compiler.h>
#include "SkCanvas.h"
#include "SkRegion.h"
namespace android {
class ANDROID_API NinePatch {
public:
static void Draw(SkCanvas* canvas, const SkRect& bounds, const SkBitmap& bitmap,
const Res_png_9patch& chunk, const SkPaint* paint, SkRegion** outRegion);
};
} // namespace android
#endif // ANDROID_GRAPHICS_NINEPATCH_H