| /* Copyright (C) 1989, 1990 Aladdin Enterprises. All rights reserved. | |
| Distributed by Free Software Foundation, Inc. | |
| This file is part of Ghostscript. | |
| Ghostscript is distributed in the hope that it will be useful, but | |
| WITHOUT ANY WARRANTY. No author or distributor accepts responsibility | |
| to anyone for the consequences of using it or for whether it serves any | |
| particular purpose or works at all, unless he says so in writing. Refer | |
| to the Ghostscript General Public License for full details. | |
| Everyone is granted permission to copy, modify and redistribute | |
| Ghostscript, but only under the conditions described in the Ghostscript | |
| General Public License. A copy of this license is supposed to have been | |
| given to you along with Ghostscript so you can know your rights and | |
| responsibilities. It should be in a file named COPYING. Among other | |
| things, the copyright notice and this notice must be preserved on all | |
| copies. */ | |
| /* zpath.c */ | |
| /* Path operators for GhostScript */ | |
| #include "math_.h" | |
| #include "ghost.h" | |
| #include "errors.h" | |
| #include "oper.h" | |
| #include "gsmatrix.h" | |
| #include "gspath.h" | |
| #include "state.h" | |
| #include "store.h" | |
| /* Forward references */ | |
| private int common_to(P2(ref *, | |
| int (*)(P3(gs_state *, floatp, floatp)))); | |
| private int common_arc(P2(ref *, | |
| int (*)(P6(gs_state *, floatp, floatp, floatp, floatp, floatp)))); | |
| private int common_arct(P2(ref *, float *)); | |
| private int common_curve(P2(ref *, | |
| int (*)(P7(gs_state *, floatp, floatp, floatp, floatp, floatp, floatp)))); | |
| /* Imported from util.c */ | |
| extern int num_params(P3(ref *, int, float *)); | |
| /* Imported from zmath.c */ | |
| extern double degrees_to_radians, radians_to_degrees; | |
| /* newpath */ | |
| int | |
| znewpath(register ref *op) | |
| { return gs_newpath(igs); | |
| } | |
| /* currentpoint */ | |
| int | |
| zcurrentpoint(register ref *op) | |
| { gs_point pt; | |
| int code = gs_currentpoint(igs, &pt); | |
| if ( code < 0 ) return code; | |
| push(2); | |
| make_real(op - 1, pt.x); | |
| make_real(op, pt.y); | |
| return 0; | |
| } | |
| /* moveto */ | |
| int | |
| zmoveto(register ref *op) | |
| { return common_to(op, gs_moveto); | |
| } | |
| /* rmoveto */ | |
| int | |
| zrmoveto(register ref *op) | |
| { return common_to(op, gs_rmoveto); | |
| } | |
| /* lineto */ | |
| int | |
| zlineto(register ref *op) | |
| { return common_to(op, gs_lineto); | |
| } | |
| /* rlineto */ | |
| int | |
| zrlineto(register ref *op) | |
| { return common_to(op, gs_rlineto); | |
| } | |
| /* Common code for [r](move/line)to */ | |
| private int | |
| common_to(ref *op, int (*add_proc)(P3(gs_state *, floatp, floatp))) | |
| { float opxy[2]; | |
| int code; | |
| if ( (code = num_params(op, 2, opxy)) < 0 || | |
| (code = (*add_proc)(igs, opxy[0], opxy[1])) < 0 | |
| ) return code; | |
| pop(2); | |
| return 0; | |
| } | |
| /* arc */ | |
| int | |
| zarc(register ref *op) | |
| { return common_arc(op, gs_arc); | |
| } | |
| /* arcn */ | |
| int | |
| zarcn(register ref *op) | |
| { return common_arc(op, gs_arcn); | |
| } | |
| /* Common code for arc[n] */ | |
| private int | |
| common_arc(ref *op, | |
| int (*aproc)(P6(gs_state *, floatp, floatp, floatp, floatp, floatp))) | |
| { float xyra[5]; /* x, y, r, ang1, ang2 */ | |
| int code; | |
| if ( (code = num_params(op, 5, xyra)) < 0 ) return code; | |
| code = (*aproc)(igs, xyra[0], xyra[1], xyra[2], xyra[3], xyra[4]); | |
| if ( code >= 0 ) pop(5); | |
| return code; | |
| } | |
| /* arct */ | |
| int | |
| zarct(register ref *op) | |
| { int code = common_arct(op, (float *)0); | |
| if ( code < 0 ) return code; | |
| pop(5); | |
| return 0; | |
| } | |
| /* arcto */ | |
| int | |
| zarcto(register ref *op) | |
| { float tanxy[4]; /* xt1, yt1, xt2, yt2 */ | |
| int code = common_arct(op, tanxy); | |
| if ( code < 0 ) return code; | |
| make_real(op - 4, tanxy[0]); | |
| make_real(op - 3, tanxy[1]); | |
| make_real(op - 2, tanxy[2]); | |
| make_real(op - 1, tanxy[3]); | |
| pop(1); | |
| return 0; | |
| } | |
| /* Common code for arct[o] */ | |
| private int | |
| common_arct(ref *op, float *tanxy) | |
| { float args[5]; /* x1, y1, x2, y2, r */ | |
| int code; | |
| if ( (code = num_params(op, 5, args)) < 0 ) return code; | |
| return gs_arcto(igs, args[0], args[1], args[2], args[3], args[4], tanxy); | |
| } | |
| /* curveto */ | |
| int | |
| zcurveto(register ref *op) | |
| { return common_curve(op, gs_curveto); | |
| } | |
| /* rcurveto */ | |
| int | |
| zrcurveto(register ref *op) | |
| { return common_curve(op, gs_rcurveto); | |
| } | |
| /* Common code for [r]curveto */ | |
| private int | |
| common_curve(ref *op, | |
| int (*add_proc)(P7(gs_state *, floatp, floatp, floatp, floatp, floatp, floatp))) | |
| { float opxy[6]; | |
| int code; | |
| if ( (code = num_params(op, 6, opxy)) < 0 ) return code; | |
| code = (*add_proc)(igs, opxy[0], opxy[1], opxy[2], opxy[3], opxy[4], opxy[5]); | |
| if ( code >= 0 ) pop(6); | |
| return code; | |
| } | |
| /* closepath */ | |
| int | |
| zclosepath(register ref *op) | |
| { return gs_closepath(igs); | |
| } | |
| /* ------ Initialization procedure ------ */ | |
| void | |
| zpath_op_init() | |
| { static op_def my_defs[] = { | |
| {"5arc", zarc}, | |
| {"5arcn", zarcn}, | |
| {"5arct", zarct}, | |
| {"5arcto", zarcto}, | |
| {"0closepath", zclosepath}, | |
| {"0currentpoint", zcurrentpoint}, | |
| {"6curveto", zcurveto}, | |
| {"2lineto", zlineto}, | |
| {"2moveto", zmoveto}, | |
| {"0newpath", znewpath}, | |
| {"6rcurveto", zrcurveto}, | |
| {"2rlineto", zrlineto}, | |
| {"2rmoveto", zrmoveto}, | |
| op_def_end | |
| }; | |
| z_op_init(my_defs); | |
| } |