Path.cpp revision 54b6cfa9a9e5b861a9930af873580d6dc20f773c 
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
29namespace android {
30
31class SkPathGlue {
32public:
33
34    static void finalizer(JNIEnv* env, jobject clazz, SkPath* obj) {
35        delete obj;
36    }
37
38    static SkPath* init1(JNIEnv* env, jobject clazz) {
39        return new SkPath();
40    }
41
42    static SkPath* init2(JNIEnv* env, jobject clazz, SkPath* val) {
43        return new SkPath(*val);
44    }
45
46    static void reset(JNIEnv* env, jobject clazz, SkPath* obj) {
47        obj->reset();
48    }
49
50    static void rewind(JNIEnv* env, jobject clazz, SkPath* obj) {
51        obj->rewind();
52    }
53
54    static void assign(JNIEnv* env, jobject clazz, SkPath* dst, const SkPath* src) {
55        *dst = *src;
56    }
57
58    static jint getFillType(JNIEnv* env, jobject clazz, SkPath* obj) {
59        return obj->getFillType();
60    }
61
62    static void setFillType(JNIEnv* env, jobject clazz, SkPath* path,
63                            SkPath::FillType ft) {
64        path->setFillType(ft);
65    }
66
67    static jboolean isEmpty(JNIEnv* env, jobject clazz, SkPath* obj) {
68        return obj->isEmpty();
69    }
70
71    static jboolean isRect(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect) {
72        SkRect rect_;
73        jboolean result = obj->isRect(&rect_);
74        GraphicsJNI::rect_to_jrectf(rect_, env, rect);
75        return result;
76    }
77
78    static void computeBounds(JNIEnv* env, jobject clazz, SkPath* obj, jobject bounds, SkPath::BoundsType btype) {
79        SkRect bounds_;
80        obj->computeBounds(&bounds_, btype);
81        GraphicsJNI::rect_to_jrectf(bounds_, env, bounds);
82    }
83
84    static void incReserve(JNIEnv* env, jobject clazz, SkPath* obj, jint extraPtCount) {
85        obj->incReserve(extraPtCount);
86    }
87
88    static void moveTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) {
89        SkScalar x_ = SkFloatToScalar(x);
90        SkScalar y_ = SkFloatToScalar(y);
91        obj->moveTo(x_, y_);
92    }
93
94    static void rMoveTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
95        SkScalar dx_ = SkFloatToScalar(dx);
96        SkScalar dy_ = SkFloatToScalar(dy);
97        obj->rMoveTo(dx_, dy_);
98    }
99
100    static void lineTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) {
101        SkScalar x_ = SkFloatToScalar(x);
102        SkScalar y_ = SkFloatToScalar(y);
103        obj->lineTo(x_, y_);
104    }
105
106    static void rLineTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
107        SkScalar dx_ = SkFloatToScalar(dx);
108        SkScalar dy_ = SkFloatToScalar(dy);
109        obj->rLineTo(dx_, dy_);
110    }
111
112    static void quadTo__FFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2) {
113        SkScalar x1_ = SkFloatToScalar(x1);
114        SkScalar y1_ = SkFloatToScalar(y1);
115        SkScalar x2_ = SkFloatToScalar(x2);
116        SkScalar y2_ = SkFloatToScalar(y2);
117        obj->quadTo(x1_, y1_, x2_, y2_);
118    }
119
120    static void rQuadTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) {
121        SkScalar dx1_ = SkFloatToScalar(dx1);
122        SkScalar dy1_ = SkFloatToScalar(dy1);
123        SkScalar dx2_ = SkFloatToScalar(dx2);
124        SkScalar dy2_ = SkFloatToScalar(dy2);
125        obj->rQuadTo(dx1_, dy1_, dx2_, dy2_);
126    }
127
128    static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
129        SkScalar x1_ = SkFloatToScalar(x1);
130        SkScalar y1_ = SkFloatToScalar(y1);
131        SkScalar x2_ = SkFloatToScalar(x2);
132        SkScalar y2_ = SkFloatToScalar(y2);
133        SkScalar x3_ = SkFloatToScalar(x3);
134        SkScalar y3_ = SkFloatToScalar(y3);
135        obj->cubicTo(x1_, y1_, x2_, y2_, x3_, y3_);
136    }
137
138    static void rCubicTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
139        SkScalar x1_ = SkFloatToScalar(x1);
140        SkScalar y1_ = SkFloatToScalar(y1);
141        SkScalar x2_ = SkFloatToScalar(x2);
142        SkScalar y2_ = SkFloatToScalar(y2);
143        SkScalar x3_ = SkFloatToScalar(x3);
144        SkScalar y3_ = SkFloatToScalar(y3);
145        obj->rCubicTo(x1_, y1_, x2_, y2_, x3_, y3_);
146    }
147
148    static void arcTo(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) {
149        SkRect oval_;
150        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
151        SkScalar startAngle_ = SkFloatToScalar(startAngle);
152        SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
153        obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo);
154    }
155
156    static void close(JNIEnv* env, jobject clazz, SkPath* obj) {
157        obj->close();
158    }
159
160    static void addRect__RectFI(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, SkPath::Direction dir) {
161        SkRect rect_;
162        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
163        obj->addRect(rect_, dir);
164    }
165
166    static void addRect__FFFFI(JNIEnv* env, jobject clazz, SkPath* obj, jfloat left, jfloat top, jfloat right, jfloat bottom, SkPath::Direction dir) {
167        SkScalar left_ = SkFloatToScalar(left);
168        SkScalar top_ = SkFloatToScalar(top);
169        SkScalar right_ = SkFloatToScalar(right);
170        SkScalar bottom_ = SkFloatToScalar(bottom);
171        obj->addRect(left_, top_, right_, bottom_, dir);
172    }
173
174    static void addOval(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, SkPath::Direction dir) {
175        SkRect oval_;
176        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
177        obj->addOval(oval_, dir);
178    }
179
180    static void addCircle(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y, jfloat radius, SkPath::Direction dir) {
181        SkScalar x_ = SkFloatToScalar(x);
182        SkScalar y_ = SkFloatToScalar(y);
183        SkScalar radius_ = SkFloatToScalar(radius);
184        obj->addCircle(x_, y_, radius_, dir);
185    }
186
187    static void addArc(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle) {
188        SkRect oval_;
189        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
190        SkScalar startAngle_ = SkFloatToScalar(startAngle);
191        SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
192        obj->addArc(oval_, startAngle_, sweepAngle_);
193    }
194
195    static void addRoundRectXY(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect,
196                               jfloat rx, jfloat ry, SkPath::Direction dir) {
197        SkRect rect_;
198        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
199        SkScalar rx_ = SkFloatToScalar(rx);
200        SkScalar ry_ = SkFloatToScalar(ry);
201        obj->addRoundRect(rect_, rx_, ry_, dir);
202    }
203
204    static void addRoundRect8(JNIEnv* env, jobject, SkPath* obj, jobject rect,
205                              jfloatArray array, SkPath::Direction dir) {
206        SkRect rect_;
207        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
208        AutoJavaFloatArray  afa(env, array, 8);
209        const float* src = afa.ptr();
210        SkScalar dst[8];
211
212        for (int i = 0; i < 8; i++) {
213            dst[i] = SkFloatToScalar(src[i]);
214        }
215        obj->addRoundRect(rect_, dst, dir);
216    }
217
218    static void addPath__PathFF(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, jfloat dx, jfloat dy) {
219        SkScalar dx_ = SkFloatToScalar(dx);
220        SkScalar dy_ = SkFloatToScalar(dy);
221        obj->addPath(*src, dx_, dy_);
222    }
223
224    static void addPath__Path(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src) {
225        obj->addPath(*src);
226    }
227
228    static void addPath__PathMatrix(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, SkMatrix* matrix) {
229        obj->addPath(*src, *matrix);
230    }
231
232    static void offset__FFPath(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy, SkPath* dst) {
233        SkScalar dx_ = SkFloatToScalar(dx);
234        SkScalar dy_ = SkFloatToScalar(dy);
235        obj->offset(dx_, dy_, dst);
236    }
237
238    static void offset__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
239        SkScalar dx_ = SkFloatToScalar(dx);
240        SkScalar dy_ = SkFloatToScalar(dy);
241        obj->offset(dx_, dy_);
242    }
243
244    static void setLastPoint(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
245        SkScalar dx_ = SkFloatToScalar(dx);
246        SkScalar dy_ = SkFloatToScalar(dy);
247        obj->setLastPt(dx_, dy_);
248    }
249
250    static void transform__MatrixPath(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix, SkPath* dst) {
251        obj->transform(*matrix, dst);
252    }
253
254    static void transform__Matrix(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix) {
255        obj->transform(*matrix);
256    }
257
258};
259
260static JNINativeMethod methods[] = {
261    {"finalizer", "(I)V", (void*) SkPathGlue::finalizer},
262    {"init1","()I", (void*) SkPathGlue::init1},
263    {"init2","(I)I", (void*) SkPathGlue::init2},
264    {"native_reset","(I)V", (void*) SkPathGlue::reset},
265    {"native_rewind","(I)V", (void*) SkPathGlue::rewind},
266    {"native_set","(II)V", (void*) SkPathGlue::assign},
267    {"native_getFillType","(I)I", (void*) SkPathGlue::getFillType},
268    {"native_setFillType","(II)V", (void*) SkPathGlue::setFillType},
269    {"native_isEmpty","(I)Z", (void*) SkPathGlue::isEmpty},
270    {"native_isRect","(ILandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect},
271    {"native_computeBounds","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::computeBounds},
272    {"native_incReserve","(II)V", (void*) SkPathGlue::incReserve},
273    {"native_moveTo","(IFF)V", (void*) SkPathGlue::moveTo__FF},
274    {"native_rMoveTo","(IFF)V", (void*) SkPathGlue::rMoveTo},
275    {"native_lineTo","(IFF)V", (void*) SkPathGlue::lineTo__FF},
276    {"native_rLineTo","(IFF)V", (void*) SkPathGlue::rLineTo},
277    {"native_quadTo","(IFFFF)V", (void*) SkPathGlue::quadTo__FFFF},
278    {"native_rQuadTo","(IFFFF)V", (void*) SkPathGlue::rQuadTo},
279    {"native_cubicTo","(IFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF},
280    {"native_rCubicTo","(IFFFFFF)V", (void*) SkPathGlue::rCubicTo},
281    {"native_arcTo","(ILandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo},
282    {"native_close","(I)V", (void*) SkPathGlue::close},
283    {"native_addRect","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI},
284    {"native_addRect","(IFFFFI)V", (void*) SkPathGlue::addRect__FFFFI},
285    {"native_addOval","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval},
286    {"native_addCircle","(IFFFI)V", (void*) SkPathGlue::addCircle},
287    {"native_addArc","(ILandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc},
288    {"native_addRoundRect","(ILandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY},
289    {"native_addRoundRect","(ILandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8},
290    {"native_addPath","(IIFF)V", (void*) SkPathGlue::addPath__PathFF},
291    {"native_addPath","(II)V", (void*) SkPathGlue::addPath__Path},
292    {"native_addPath","(III)V", (void*) SkPathGlue::addPath__PathMatrix},
293    {"native_offset","(IFFI)V", (void*) SkPathGlue::offset__FFPath},
294    {"native_offset","(IFF)V", (void*) SkPathGlue::offset__FF},
295    {"native_setLastPoint","(IFF)V", (void*) SkPathGlue::setLastPoint},
296    {"native_transform","(III)V", (void*) SkPathGlue::transform__MatrixPath},
297    {"native_transform","(II)V", (void*) SkPathGlue::transform__Matrix}
298};
299
300int register_android_graphics_Path(JNIEnv* env) {
301    int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Path", methods,
302        sizeof(methods) / sizeof(methods[0]));
303    return result;
304}
305
306}
307