Merge "Added primitive parameters to various functions requiring rectangles." (96401d99) · Commits · e / os / android_frameworks_base

api/current.txt

+6 −0

Original line number	Diff line number	Diff line
		@@ -10215,6 +10215,7 @@ package android.graphics {
		method public void concat(android.graphics.Matrix);
		method public void drawARGB(int, int, int, int);
		method public void drawArc(android.graphics.RectF, float, float, boolean, android.graphics.Paint);
		method public void drawArc(float, float, float, float, float, float, boolean, android.graphics.Paint);
		method public void drawBitmap(android.graphics.Bitmap, float, float, android.graphics.Paint);
		method public void drawBitmap(android.graphics.Bitmap, android.graphics.Rect, android.graphics.RectF, android.graphics.Paint);
		method public void drawBitmap(android.graphics.Bitmap, android.graphics.Rect, android.graphics.Rect, android.graphics.Paint);
		@@ -10229,6 +10230,7 @@ package android.graphics {
		method public void drawLines(float[], int, int, android.graphics.Paint);
		method public void drawLines(float[], android.graphics.Paint);
		method public void drawOval(android.graphics.RectF, android.graphics.Paint);
		method public void drawOval(float, float, float, float, android.graphics.Paint);
		method public void drawPaint(android.graphics.Paint);
		method public void drawPath(android.graphics.Path, android.graphics.Paint);
		method public void drawPicture(android.graphics.Picture);
		@@ -10738,6 +10740,7 @@ package android.graphics {
		ctor public Path();
		ctor public Path(android.graphics.Path);
		method public void addArc(android.graphics.RectF, float, float);
		method public void addArc(float, float, float, float, float, float);
		method public void addCircle(float, float, float, android.graphics.Path.Direction);
		method public void addOval(android.graphics.RectF, android.graphics.Path.Direction);
		method public void addOval(float, float, float, float, android.graphics.Path.Direction);
		@@ -10747,9 +10750,12 @@ package android.graphics {
		method public void addRect(android.graphics.RectF, android.graphics.Path.Direction);
		method public void addRect(float, float, float, float, android.graphics.Path.Direction);
		method public void addRoundRect(android.graphics.RectF, float, float, android.graphics.Path.Direction);
		method public void addRoundRect(float, float, float, float, float, float, android.graphics.Path.Direction);
		method public void addRoundRect(android.graphics.RectF, float[], android.graphics.Path.Direction);
		method public void addRoundRect(float, float, float, float, float[], android.graphics.Path.Direction);
		method public void arcTo(android.graphics.RectF, float, float, boolean);
		method public void arcTo(android.graphics.RectF, float, float);
		method public void arcTo(float, float, float, float, float, float, boolean);
		method public void close();
		method public void computeBounds(android.graphics.RectF, boolean);
		method public void cubicTo(float, float, float, float, float, float);

core/java/android/view/GLES20Canvas.java

+5 −5

Original line number	Diff line number	Diff line
		@@ -547,9 +547,9 @@ class GLES20Canvas extends HardwareCanvas {
		///////////////////////////////////////////////////////////////////////////

		@Override
		public void drawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter,
		Paint paint) {
		nDrawArc(mRenderer, oval.left, oval.top, oval.right, oval.bottom,
		public void drawArc(float left, float top, float right, float bottom,
		float startAngle, float sweepAngle, boolean useCenter, Paint paint) {
		nDrawArc(mRenderer, left, top, right, bottom,
		startAngle, sweepAngle, useCenter, paint.mNativePaint);
		}

		@@ -774,8 +774,8 @@ class GLES20Canvas extends HardwareCanvas {
		}

		@Override
		public void drawOval(RectF oval, Paint paint) {
		nDrawOval(mRenderer, oval.left, oval.top, oval.right, oval.bottom, paint.mNativePaint);
		public void drawOval(float left, float top, float right, float bottom, Paint paint) {
		nDrawOval(mRenderer, left, top, right, bottom, paint.mNativePaint);
		}

		private static native void nDrawOval(long renderer, float left, float top,

core/jni/android/graphics/Canvas.cpp

+9 −13

Original line number	Diff line number	Diff line
		@@ -569,12 +569,11 @@ public:
		canvas->drawRectCoords(left, top, right, bottom, *paint);
		}

		static void drawOval(JNIEnv* env, jobject, jlong canvasHandle, jobject joval,
		jlong paintHandle) {
		static void drawOval(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top,
		jfloat right, jfloat bottom, jlong paintHandle) {
		SkCanvas* canvas = getNativeCanvas(canvasHandle);
		SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
		SkRect oval;
		GraphicsJNI::jrectf_to_rect(env, joval, &oval);
		SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
		canvas->drawOval(oval, *paint);
		}

		@@ -585,13 +584,12 @@ public:
		canvas->drawCircle(cx, cy, radius, *paint);
		}

		static void drawArc(JNIEnv* env, jobject, jlong canvasHandle, jobject joval,
		jfloat startAngle, jfloat sweepAngle,
		jboolean useCenter, jlong paintHandle) {
		static void drawArc(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top,
		jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle, jboolean useCenter,
		jlong paintHandle) {
		SkCanvas* canvas = getNativeCanvas(canvasHandle);
		SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
		SkRect oval;
		GraphicsJNI::jrectf_to_rect(env, joval, &oval);
		SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
		canvas->drawArc(oval, startAngle, sweepAngle, useCenter, *paint);
		}

		@@ -1241,11 +1239,9 @@ static JNINativeMethod gCanvasMethods[] = {
		{"native_drawLines", "(J[FIIJ)V", (void*) SkCanvasGlue::drawLines},
		{"native_drawLine","(JFFFFJ)V", (void*) SkCanvasGlue::drawLine__FFFFPaint},
		{"native_drawRect","(JFFFFJ)V", (void*) SkCanvasGlue::drawRect__FFFFPaint},
		{"native_drawOval","(JLandroid/graphics/RectF;J)V",
		(void*) SkCanvasGlue::drawOval},
		{"native_drawOval","(JFFFFJ)V", (void*) SkCanvasGlue::drawOval},
		{"native_drawCircle","(JFFFJ)V", (void*) SkCanvasGlue::drawCircle},
		{"native_drawArc","(JLandroid/graphics/RectF;FFZJ)V",
		(void*) SkCanvasGlue::drawArc},
		{"native_drawArc","(JFFFFFFZJ)V", (void*) SkCanvasGlue::drawArc},
		{"native_drawRoundRect","(JFFFFFFJ)V",
		(void*) SkCanvasGlue::drawRoundRect},
		{"native_drawPath","(JJJ)V", (void*) SkCanvasGlue::drawPath},

core/jni/android/graphics/Path.cpp

+49 −50

Original line number	Diff line number	Diff line
		@@ -152,11 +152,12 @@ public:
		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) {
		static void arcTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top,
		jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle,
		jboolean forceMoveTo) {
		SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
		SkRect oval_;
		GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
		obj->arcTo(oval_, startAngle, sweepAngle, forceMoveTo);
		SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
		obj->arcTo(oval, startAngle, sweepAngle, forceMoveTo);
		}

		static void close(JNIEnv* env, jobject clazz, jlong objHandle) {
		@@ -185,28 +186,26 @@ public:
		obj->addCircle(x, y, radius, dir);
		}

		static void addArc(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle) {
		SkRect oval_;
		static void addArc(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top,
		jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle) {
		SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
		SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
		GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
		obj->addArc(oval_, startAngle, sweepAngle);
		obj->addArc(oval, startAngle, sweepAngle);
		}

		static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jobject jrect,
		jfloat rx, jfloat ry, jint dirHandle) {
		SkRect rect;
		static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top,
		jfloat right, jfloat bottom, jfloat rx, jfloat ry, jint dirHandle) {
		SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
		SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
		SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
		GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
		obj->addRoundRect(rect, rx, ry, dir);
		}

		static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jobject jrect,
		jfloatArray array, jint dirHandle) {
		SkRect rect;
		static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jfloat left, jfloat top,
		jfloat right, jfloat bottom, jfloatArray array, jint dirHandle) {
		SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
		SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
		SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
		GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
		AutoJavaFloatArray afa(env, array, 8);
		#ifdef SK_SCALAR_IS_FLOAT
		const float* src = afa.ptr();
		@@ -487,14 +486,14 @@ static JNINativeMethod methods[] = {
		{"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_arcTo","(JFFFFFFZ)V", (void*) SkPathGlue::arcTo},
		{"native_close","(J)V", (void*) SkPathGlue::close},
		{"native_addRect","(JFFFFI)V", (void*) SkPathGlue::addRect},
		{"native_addOval","(JFFFFI)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_addArc","(JFFFFFF)V", (void*) SkPathGlue::addArc},
		{"native_addRoundRect","(JFFFFFFI)V", (void*) SkPathGlue::addRoundRectXY},
		{"native_addRoundRect","(JFFFF[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},

graphics/java/android/graphics/Canvas.java

+42 −10

Original line number	Diff line number	Diff line
		@@ -1091,7 +1091,15 @@ public class Canvas {
		if (oval == null) {
		throw new NullPointerException();
		}
		native_drawOval(mNativeCanvasWrapper, oval, paint.mNativePaint);
		drawOval(oval.left, oval.top, oval.right, oval.bottom, paint);
		}

		/**
		* Draw the specified oval using the specified paint. The oval will be
		* filled or framed based on the Style in the paint.
		*/
		public void drawOval(float left, float top, float right, float bottom, @NonNull Paint paint) {
		native_drawOval(mNativeCanvasWrapper, left, top, right, bottom, paint.mNativePaint);
		}

		/**
		@@ -1133,10 +1141,34 @@ public class Canvas {
		*/
		public void drawArc(@NonNull RectF oval, float startAngle, float sweepAngle, boolean useCenter,
		@NonNull Paint paint) {
		if (oval == null) {
		throw new NullPointerException();
		drawArc(oval.left, oval.top, oval.right, oval.bottom, startAngle, sweepAngle, useCenter,
		paint);
		}
		native_drawArc(mNativeCanvasWrapper, oval, startAngle, sweepAngle,

		/**
		* <p>Draw the specified arc, which will be scaled to fit inside the
		* specified oval.</p>
		*
		* <p>If the start angle is negative or >= 360, the start angle is treated
		* as start angle modulo 360.</p>
		*
		* <p>If the sweep angle is >= 360, then the oval is drawn
		* completely. Note that this differs slightly from SkPath::arcTo, which
		* treats the sweep angle modulo 360. If the sweep angle is negative,
		* the sweep angle is treated as sweep angle modulo 360</p>
		*
		* <p>The arc is drawn clockwise. An angle of 0 degrees correspond to the
		* geometric angle of 0 degrees (3 o'clock on a watch.)</p>
		*
		* @param startAngle Starting angle (in degrees) where the arc begins
		* @param sweepAngle Sweep angle (in degrees) measured clockwise
		* @param useCenter If true, include the center of the oval in the arc, and
		close it if it is being stroked. This will draw a wedge
		* @param paint The paint used to draw the arc
		*/
		public void drawArc(float left, float top, float right, float bottom, float startAngle,
		float sweepAngle, boolean useCenter, @NonNull Paint paint) {
		native_drawArc(mNativeCanvasWrapper, left, top, right, bottom, startAngle, sweepAngle,
		useCenter, paint.mNativePaint);
		}

		@@ -1908,14 +1940,14 @@ public class Canvas {
		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_drawOval(long nativeCanvas, float left, float top,
		float right, float bottom, long nativePaint);
		private static native void native_drawCircle(long nativeCanvas, float cx,
		float cy, float radius,
		long nativePaint);
		private static native void native_drawArc(long nativeCanvas, RectF oval,
		float startAngle, float sweep,
		boolean useCenter,
		private static native void native_drawArc(long nativeCanvas, float left, float top,
		float right, float bottom,
		float startAngle, float sweep, boolean useCenter,
		long nativePaint);
		private static native void native_drawRoundRect(long nativeCanvas,
		float left, float top, float right, float bottom,