Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/platform/java/jni/path.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 // Copyright (C) 2004-2021 Artifex Software, Inc.
2 //
3 // This file is part of MuPDF.
4 //
5 // MuPDF is free software: you can redistribute it and/or modify it under the
6 // terms of the GNU Affero General Public License as published by the Free
7 // Software Foundation, either version 3 of the License, or (at your option)
8 // any later version.
9 //
10 // MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 // FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
13 // details.
14 //
15 // You should have received a copy of the GNU Affero General Public License
16 // along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
17 //
18 // Alternative licensing terms are available from the licensor.
19 // For commercial licensing, see <https://www.artifex.com/> or contact
20 // Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
21 // CA 94129, USA, for further information.
22
23 /* Path interface */
24
25 JNIEXPORT void JNICALL
26 FUN(Path_finalize)(JNIEnv *env, jobject self)
27 {
28 fz_context *ctx = get_context(env);
29 fz_path *path = from_Path_safe(env, self);
30 if (!ctx || !path) return;
31 (*env)->SetLongField(env, self, fid_Path_pointer, 0);
32 fz_drop_path(ctx, path);
33 }
34
35 JNIEXPORT jlong JNICALL
36 FUN(Path_newNative)(JNIEnv *env, jobject self)
37 {
38 fz_context *ctx = get_context(env);
39 fz_path *path = NULL;
40
41 if (!ctx) return 0;
42
43 fz_try(ctx)
44 path = fz_new_path(ctx);
45 fz_catch(ctx)
46 jni_rethrow(env, ctx);
47
48 return jlong_cast(path);
49 }
50
51 JNIEXPORT jobject JNICALL
52 FUN(Path_currentPoint)(JNIEnv *env, jobject self)
53 {
54 fz_context *ctx = get_context(env);
55 fz_path *path = from_Path(env, self);
56 fz_point point;
57
58 if (!ctx || !path) return NULL;
59
60 fz_try(ctx)
61 point = fz_currentpoint(ctx, path);
62 fz_catch(ctx)
63 jni_rethrow(env, ctx);
64
65 return to_Point_safe(ctx, env, point);
66 }
67
68 JNIEXPORT void JNICALL
69 FUN(Path_moveTo)(JNIEnv *env, jobject self, jfloat x, jfloat y)
70 {
71 fz_context *ctx = get_context(env);
72 fz_path *path = from_Path(env, self);
73
74 if (!ctx || !path) return;
75
76 fz_try(ctx)
77 fz_moveto(ctx, path, x, y);
78 fz_catch(ctx)
79 jni_rethrow_void(env, ctx);
80 }
81
82 JNIEXPORT void JNICALL
83 FUN(Path_lineTo)(JNIEnv *env, jobject self, jfloat x, jfloat y)
84 {
85 fz_context *ctx = get_context(env);
86 fz_path *path = from_Path(env, self);
87
88 if (!ctx || !path) return;
89
90 fz_try(ctx)
91 fz_lineto(ctx, path, x, y);
92 fz_catch(ctx)
93 jni_rethrow_void(env, ctx);
94 }
95
96 JNIEXPORT void JNICALL
97 FUN(Path_curveTo)(JNIEnv *env, jobject self, jfloat cx1, jfloat cy1, jfloat cx2, jfloat cy2, jfloat ex, jfloat ey)
98 {
99 fz_context *ctx = get_context(env);
100 fz_path *path = from_Path(env, self);
101
102 if (!ctx || !path) return;
103
104 fz_try(ctx)
105 fz_curveto(ctx, path, cx1, cy1, cx2, cy2, ex, ey);
106 fz_catch(ctx)
107 jni_rethrow_void(env, ctx);
108 }
109
110 JNIEXPORT void JNICALL
111 FUN(Path_curveToV)(JNIEnv *env, jobject self, jfloat cx, jfloat cy, jfloat ex, jfloat ey)
112 {
113 fz_context *ctx = get_context(env);
114 fz_path *path = from_Path(env, self);
115
116 if (!ctx || !path) return;
117
118 fz_try(ctx)
119 fz_curvetov(ctx, path, cx, cy, ex, ey);
120 fz_catch(ctx)
121 jni_rethrow_void(env, ctx);
122 }
123
124 JNIEXPORT void JNICALL
125 FUN(Path_curveToY)(JNIEnv *env, jobject self, jfloat cx, jfloat cy, jfloat ex, jfloat ey)
126 {
127 fz_context *ctx = get_context(env);
128 fz_path *path = from_Path(env, self);
129
130 if (!ctx || !path) return;
131
132 fz_try(ctx)
133 fz_curvetoy(ctx, path, cx, cy, ex, ey);
134 fz_catch(ctx)
135 jni_rethrow_void(env, ctx);
136 }
137
138 JNIEXPORT void JNICALL
139 FUN(Path_rect)(JNIEnv *env, jobject self, jint x1, jint y1, jint x2, jint y2)
140 {
141 fz_context *ctx = get_context(env);
142 fz_path *path = from_Path(env, self);
143
144 if (!ctx || !path) return;
145
146 fz_try(ctx)
147 fz_rectto(ctx, path, x1, y1, x2, y2);
148 fz_catch(ctx)
149 jni_rethrow_void(env, ctx);
150 }
151
152 JNIEXPORT void JNICALL
153 FUN(Path_closePath)(JNIEnv *env, jobject self)
154 {
155 fz_context *ctx = get_context(env);
156 fz_path *path = from_Path(env, self);
157
158 if (!ctx || !path) return;
159
160 fz_try(ctx)
161 fz_closepath(ctx, path);
162 fz_catch(ctx)
163 jni_rethrow_void(env, ctx);
164 }
165
166 JNIEXPORT void JNICALL
167 FUN(Path_transform)(JNIEnv *env, jobject self, jobject jctm)
168 {
169 fz_context *ctx = get_context(env);
170 fz_path *path = from_Path(env, self);
171 fz_matrix ctm = from_Matrix(env, jctm);
172
173 if (!ctx || !path) return;
174
175 fz_try(ctx)
176 fz_transform_path(ctx, path, ctm);
177 fz_catch(ctx)
178 jni_rethrow_void(env, ctx);
179 }
180
181 JNIEXPORT jlong JNICALL
182 FUN(Path_cloneNative)(JNIEnv *env, jobject self)
183 {
184 fz_context *ctx = get_context(env);
185 fz_path *old_path = from_Path(env, self);
186 fz_path *new_path = NULL;
187
188 if (!ctx || !old_path) return 0;
189
190 fz_try(ctx)
191 new_path = fz_clone_path(ctx, old_path);
192 fz_catch(ctx)
193 jni_rethrow(env, ctx);
194
195 return jlong_cast(new_path);
196 }
197
198 JNIEXPORT jobject JNICALL
199 FUN(Path_getBounds)(JNIEnv *env, jobject self, jobject jstroke, jobject jctm)
200 {
201 fz_context *ctx = get_context(env);
202 fz_path *path = from_Path(env, self);
203 fz_stroke_state *stroke = from_StrokeState(env, jstroke);
204 fz_matrix ctm = from_Matrix(env, jctm);
205 fz_rect rect;
206
207 if (!ctx || !path) return NULL;
208 if (!stroke) jni_throw_arg(env, "stroke must not be null");
209
210 fz_try(ctx)
211 rect = fz_bound_path(ctx, path, stroke, ctm);
212 fz_catch(ctx)
213 jni_rethrow(env, ctx);
214
215 return to_Rect_safe(ctx, env, rect);
216 }
217
218 typedef struct
219 {
220 JNIEnv *env;
221 jobject obj;
222 } path_walker_state;
223
224 static void
225 pathWalkMoveTo(fz_context *ctx, void *arg, float x, float y)
226 {
227 path_walker_state *state = (path_walker_state *)arg;
228 JNIEnv *env = state->env;
229 (*env)->CallVoidMethod(env, state->obj, mid_PathWalker_moveTo, x, y);
230 if ((*env)->ExceptionCheck(env))
231 fz_throw_java(ctx, env);
232 }
233
234 static void
235 pathWalkLineTo(fz_context *ctx, void *arg, float x, float y)
236 {
237 path_walker_state *state = (path_walker_state *)arg;
238 JNIEnv *env = state->env;
239 (*env)->CallVoidMethod(env, state->obj, mid_PathWalker_lineTo, x, y);
240 if ((*env)->ExceptionCheck(env))
241 fz_throw_java(ctx, env);
242 }
243
244 static void
245 pathWalkCurveTo(fz_context *ctx, void *arg, float x1, float y1, float x2, float y2, float x3, float y3)
246 {
247 path_walker_state *state = (path_walker_state *)arg;
248 JNIEnv *env = state->env;
249 (*env)->CallVoidMethod(env, state->obj, mid_PathWalker_curveTo, x1, y1, x2, y2, x3, y3);
250 if ((*env)->ExceptionCheck(env))
251 fz_throw_java(ctx, env);
252 }
253
254 static void
255 pathWalkClosePath(fz_context *ctx, void *arg)
256 {
257 path_walker_state *state = (path_walker_state *) arg;
258 JNIEnv *env = state->env;
259 (*env)->CallVoidMethod(env, state->obj, mid_PathWalker_closePath);
260 if ((*env)->ExceptionCheck(env))
261 fz_throw_java(ctx, env);
262 }
263
264 static const fz_path_walker java_path_walker =
265 {
266 pathWalkMoveTo,
267 pathWalkLineTo,
268 pathWalkCurveTo,
269 pathWalkClosePath,
270 NULL,
271 NULL,
272 NULL,
273 NULL
274 };
275
276 JNIEXPORT void JNICALL
277 FUN(Path_walk)(JNIEnv *env, jobject self, jobject obj)
278 {
279 fz_context *ctx = get_context(env);
280 fz_path *path = from_Path(env, self);
281 path_walker_state state;
282
283 if (!ctx || !path) return;
284 if (!obj) jni_throw_arg_void(env, "object must not be null");
285
286 state.env = env;
287 state.obj = obj;
288
289 fz_try(ctx)
290 fz_walk_path(ctx, path, &java_path_walker, &state);
291 fz_catch(ctx)
292 jni_rethrow_void(env, ctx);
293 }