Path.cpp revision a0398430fcf365fba6e42ad0bdca2fbf45ed6fe0 
1/* libs/android_runtime/android/graphics/Path.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18// This file was generated from the C++ include file: SkPath.h
19// Any changes made to this file will be discarded by the build.
20// To change this file, either edit the include, or device/tools/gluemaker/main.cpp,
21// or one of the auxilary file specifications in device/tools/gluemaker.
22
23#include "jni.h"
24#include "GraphicsJNI.h"
25#include <android_runtime/AndroidRuntime.h>
26
27#include "SkPath.h"
28#include "pathops/SkPathOps.h"
29
30#include <Caches.h>
31
32namespace android {
33
34class SkPathGlue {
35public:
36
37    static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) {
38        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
39#ifdef USE_OPENGL_RENDERER
40        if (android::uirenderer::Caches::hasInstance()) {
41            android::uirenderer::Caches::getInstance().resourceCache.destructor(obj);
42            return;
43        }
44#endif
45        delete obj;
46    }
47
48    static jlong init1(JNIEnv* env, jobject clazz) {
49        return reinterpret_cast<jlong>(new SkPath());
50    }
51
52    static jlong init2(JNIEnv* env, jobject clazz, jlong valHandle) {
53        SkPath* val = reinterpret_cast<SkPath*>(valHandle);
54        return reinterpret_cast<jlong>(new SkPath(*val));
55    }
56
57    static void reset(JNIEnv* env, jobject clazz, jlong objHandle) {
58        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
59        obj->reset();
60    }
61
62    static void rewind(JNIEnv* env, jobject clazz, jlong objHandle) {
63        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
64        obj->rewind();
65    }
66
67    static void assign(JNIEnv* env, jobject clazz, jlong dstHandle, jlong srcHandle) {
68        SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
69        const SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
70        *dst = *src;
71    }
72
73    static jint getFillType(JNIEnv* env, jobject clazz, jlong objHandle) {
74        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
75        return obj->getFillType();
76    }
77
78    static void setFillType(JNIEnv* env, jobject clazz, jlong pathHandle, jint ftHandle) {
79        SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
80        SkPath::FillType ft = static_cast<SkPath::FillType>(ftHandle);
81        path->setFillType(ft);
82    }
83
84    static jboolean isEmpty(JNIEnv* env, jobject clazz, jlong objHandle) {
85        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
86        return obj->isEmpty();
87    }
88
89    static jboolean isRect(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect) {
90        SkRect rect_;
91        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
92        jboolean result = obj->isRect(&rect_);
93        GraphicsJNI::rect_to_jrectf(rect_, env, rect);
94        return result;
95    }
96
97    static void computeBounds(JNIEnv* env, jobject clazz, jlong objHandle, jobject bounds) {
98        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
99        const SkRect& bounds_ = obj->getBounds();
100        GraphicsJNI::rect_to_jrectf(bounds_, env, bounds);
101    }
102
103    static void incReserve(JNIEnv* env, jobject clazz, jlong objHandle, jint extraPtCount) {
104        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
105        obj->incReserve(extraPtCount);
106    }
107
108    static void moveTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) {
109        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
110        SkScalar x_ = SkFloatToScalar(x);
111        SkScalar y_ = SkFloatToScalar(y);
112        obj->moveTo(x_, y_);
113    }
114
115    static void rMoveTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
116        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
117        SkScalar dx_ = SkFloatToScalar(dx);
118        SkScalar dy_ = SkFloatToScalar(dy);
119        obj->rMoveTo(dx_, dy_);
120    }
121
122    static void lineTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) {
123        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
124        SkScalar x_ = SkFloatToScalar(x);
125        SkScalar y_ = SkFloatToScalar(y);
126        obj->lineTo(x_, y_);
127    }
128
129    static void rLineTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
130        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
131        SkScalar dx_ = SkFloatToScalar(dx);
132        SkScalar dy_ = SkFloatToScalar(dy);
133        obj->rLineTo(dx_, dy_);
134    }
135
136    static void quadTo__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2) {
137        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
138        SkScalar x1_ = SkFloatToScalar(x1);
139        SkScalar y1_ = SkFloatToScalar(y1);
140        SkScalar x2_ = SkFloatToScalar(x2);
141        SkScalar y2_ = SkFloatToScalar(y2);
142        obj->quadTo(x1_, y1_, x2_, y2_);
143    }
144
145    static void rQuadTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) {
146        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
147        SkScalar dx1_ = SkFloatToScalar(dx1);
148        SkScalar dy1_ = SkFloatToScalar(dy1);
149        SkScalar dx2_ = SkFloatToScalar(dx2);
150        SkScalar dy2_ = SkFloatToScalar(dy2);
151        obj->rQuadTo(dx1_, dy1_, dx2_, dy2_);
152    }
153
154    static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
155        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
156        SkScalar x1_ = SkFloatToScalar(x1);
157        SkScalar y1_ = SkFloatToScalar(y1);
158        SkScalar x2_ = SkFloatToScalar(x2);
159        SkScalar y2_ = SkFloatToScalar(y2);
160        SkScalar x3_ = SkFloatToScalar(x3);
161        SkScalar y3_ = SkFloatToScalar(y3);
162        obj->cubicTo(x1_, y1_, x2_, y2_, x3_, y3_);
163    }
164
165    static void rCubicTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
166        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
167        SkScalar x1_ = SkFloatToScalar(x1);
168        SkScalar y1_ = SkFloatToScalar(y1);
169        SkScalar x2_ = SkFloatToScalar(x2);
170        SkScalar y2_ = SkFloatToScalar(y2);
171        SkScalar x3_ = SkFloatToScalar(x3);
172        SkScalar y3_ = SkFloatToScalar(y3);
173        obj->rCubicTo(x1_, y1_, x2_, y2_, x3_, y3_);
174    }
175
176    static void arcTo(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) {
177        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
178        SkRect oval_;
179        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
180        SkScalar startAngle_ = SkFloatToScalar(startAngle);
181        SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
182        obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo);
183    }
184
185    static void close(JNIEnv* env, jobject clazz, jlong objHandle) {
186        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
187        obj->close();
188    }
189
190    static void addRect__RectFI(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect, jint dirHandle) {
191        SkRect rect_;
192        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
193        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
194        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
195        obj->addRect(rect_, dir);
196    }
197
198    static void addRect__FFFFI(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) {
199        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
200        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
201        SkScalar left_ = SkFloatToScalar(left);
202        SkScalar top_ = SkFloatToScalar(top);
203        SkScalar right_ = SkFloatToScalar(right);
204        SkScalar bottom_ = SkFloatToScalar(bottom);
205        obj->addRect(left_, top_, right_, bottom_, dir);
206    }
207
208    static void addOval(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jint dirHandle) {
209        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
210        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
211        SkRect oval_;
212        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
213        obj->addOval(oval_, dir);
214    }
215
216    static void addCircle(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y, jfloat radius, jint dirHandle) {
217        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
218        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
219        SkScalar x_ = SkFloatToScalar(x);
220        SkScalar y_ = SkFloatToScalar(y);
221        SkScalar radius_ = SkFloatToScalar(radius);
222        obj->addCircle(x_, y_, radius_, dir);
223    }
224
225    static void addArc(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle) {
226        SkRect oval_;
227        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
228        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
229        SkScalar startAngle_ = SkFloatToScalar(startAngle);
230        SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
231        obj->addArc(oval_, startAngle_, sweepAngle_);
232    }
233
234    static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect,
235            jfloat rx, jfloat ry, jint dirHandle) {
236        SkRect rect_;
237        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
238        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
239        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
240        SkScalar rx_ = SkFloatToScalar(rx);
241        SkScalar ry_ = SkFloatToScalar(ry);
242        obj->addRoundRect(rect_, rx_, ry_, dir);
243    }
244
245    static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jobject rect,
246            jfloatArray array, jint dirHandle) {
247        SkRect rect_;
248        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
249        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
250        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
251        AutoJavaFloatArray  afa(env, array, 8);
252        const float* src = afa.ptr();
253        SkScalar dst[8];
254
255        for (int i = 0; i < 8; i++) {
256            dst[i] = SkFloatToScalar(src[i]);
257        }
258        obj->addRoundRect(rect_, dst, dir);
259    }
260
261    static void addPath__PathFF(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jfloat dx, jfloat dy) {
262        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
263        SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
264        SkScalar dx_ = SkFloatToScalar(dx);
265        SkScalar dy_ = SkFloatToScalar(dy);
266        obj->addPath(*src, dx_, dy_);
267    }
268
269    static void addPath__Path(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle) {
270        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
271        SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
272        obj->addPath(*src);
273    }
274
275    static void addPath__PathMatrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong matrixHandle) {
276        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
277        SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
278        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
279        obj->addPath(*src, *matrix);
280    }
281
282    static void offset__FFPath(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy, jlong dstHandle) {
283        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
284        SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
285        SkScalar dx_ = SkFloatToScalar(dx);
286        SkScalar dy_ = SkFloatToScalar(dy);
287        obj->offset(dx_, dy_, dst);
288    }
289
290    static void offset__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
291        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
292        SkScalar dx_ = SkFloatToScalar(dx);
293        SkScalar dy_ = SkFloatToScalar(dy);
294        obj->offset(dx_, dy_);
295    }
296
297    static void setLastPoint(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
298        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
299        SkScalar dx_ = SkFloatToScalar(dx);
300        SkScalar dy_ = SkFloatToScalar(dy);
301        obj->setLastPt(dx_, dy_);
302    }
303
304    static void transform__MatrixPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle, jlong dstHandle) {
305        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
306        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
307        SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
308        obj->transform(*matrix, dst);
309    }
310
311    static void transform__Matrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle) {
312        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
313        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
314        obj->transform(*matrix);
315    }
316
317    static jboolean op(JNIEnv* env, jobject clazz, jlong p1Handle, jlong p2Handle, jint opHandle, jlong rHandle) {
318        SkPath* p1  = reinterpret_cast<SkPath*>(p1Handle);
319        SkPath* p2  = reinterpret_cast<SkPath*>(p2Handle);
320        SkPathOp op = static_cast<SkPathOp>(opHandle);
321        SkPath* r   = reinterpret_cast<SkPath*>(rHandle);
322        return Op(*p1, *p2, op, r);
323     }
324};
325
326static JNINativeMethod methods[] = {
327    {"finalizer", "(J)V", (void*) SkPathGlue::finalizer},
328    {"init1","()J", (void*) SkPathGlue::init1},
329    {"init2","(J)J", (void*) SkPathGlue::init2},
330    {"native_reset","(J)V", (void*) SkPathGlue::reset},
331    {"native_rewind","(J)V", (void*) SkPathGlue::rewind},
332    {"native_set","(JJ)V", (void*) SkPathGlue::assign},
333    {"native_getFillType","(J)I", (void*) SkPathGlue::getFillType},
334    {"native_setFillType","(JI)V", (void*) SkPathGlue::setFillType},
335    {"native_isEmpty","(J)Z", (void*) SkPathGlue::isEmpty},
336    {"native_isRect","(JLandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect},
337    {"native_computeBounds","(JLandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds},
338    {"native_incReserve","(JI)V", (void*) SkPathGlue::incReserve},
339    {"native_moveTo","(JFF)V", (void*) SkPathGlue::moveTo__FF},
340    {"native_rMoveTo","(JFF)V", (void*) SkPathGlue::rMoveTo},
341    {"native_lineTo","(JFF)V", (void*) SkPathGlue::lineTo__FF},
342    {"native_rLineTo","(JFF)V", (void*) SkPathGlue::rLineTo},
343    {"native_quadTo","(JFFFF)V", (void*) SkPathGlue::quadTo__FFFF},
344    {"native_rQuadTo","(JFFFF)V", (void*) SkPathGlue::rQuadTo},
345    {"native_cubicTo","(JFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF},
346    {"native_rCubicTo","(JFFFFFF)V", (void*) SkPathGlue::rCubicTo},
347    {"native_arcTo","(JLandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo},
348    {"native_close","(J)V", (void*) SkPathGlue::close},
349    {"native_addRect","(JLandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI},
350    {"native_addRect","(JFFFFI)V", (void*) SkPathGlue::addRect__FFFFI},
351    {"native_addOval","(JLandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval},
352    {"native_addCircle","(JFFFI)V", (void*) SkPathGlue::addCircle},
353    {"native_addArc","(JLandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc},
354    {"native_addRoundRect","(JLandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY},
355    {"native_addRoundRect","(JLandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8},
356    {"native_addPath","(JJFF)V", (void*) SkPathGlue::addPath__PathFF},
357    {"native_addPath","(JJ)V", (void*) SkPathGlue::addPath__Path},
358    {"native_addPath","(JJJ)V", (void*) SkPathGlue::addPath__PathMatrix},
359    {"native_offset","(JFFJ)V", (void*) SkPathGlue::offset__FFPath},
360    {"native_offset","(JFF)V", (void*) SkPathGlue::offset__FF},
361    {"native_setLastPoint","(JFF)V", (void*) SkPathGlue::setLastPoint},
362    {"native_transform","(JJJ)V", (void*) SkPathGlue::transform__MatrixPath},
363    {"native_transform","(JJ)V", (void*) SkPathGlue::transform__Matrix},
364    {"native_op","(JJIJ)Z", (void*) SkPathGlue::op}
365};
366
367int register_android_graphics_Path(JNIEnv* env) {
368    int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Path", methods,
369        sizeof(methods) / sizeof(methods[0]));
370    return result;
371}
372
373}
374