[sgt/puzzles] / ps.c

/*
 * ps.c: PostScript printing functions.
 */

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>

#include "puzzles.h"

#define ROOT2 1.414213562

struct psdata {
    FILE *fp;
    int colour;
    int ytop;
    int clipped;
    float hatchthick, hatchspace;
    int gamewidth, gameheight;
    drawing *drawing;
};

static void ps_printf(psdata *ps, char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    vfprintf(ps->fp, fmt, ap);
    va_end(ap);
}

static void ps_fill(psdata *ps, int colour)
{
    int hatch;
    float r, g, b;

    print_get_colour(ps->drawing, colour, ps->colour, &hatch, &r, &g, &b);

    if (hatch < 0) {
	if (ps->colour)
	    ps_printf(ps, "%g %g %g setrgbcolor fill\n", r, g, b);
	else
	    ps_printf(ps, "%g setgray fill\n", r);
    } else {
	/* Clip to the region. */
	ps_printf(ps, "gsave clip\n");
	/* Hatch the entire game printing area. */
	ps_printf(ps, "newpath\n");
	if (hatch == HATCH_VERT || hatch == HATCH_PLUS)
	    ps_printf(ps, "0 %g %d {\n"
		      "  0 moveto 0 %d rlineto\n"
		      "} for\n", ps->hatchspace, ps->gamewidth,
		      ps->gameheight);
	if (hatch == HATCH_HORIZ || hatch == HATCH_PLUS)
	    ps_printf(ps, "0 %g %d {\n"
		      "  0 exch moveto %d 0 rlineto\n"
		      "} for\n", ps->hatchspace, ps->gameheight,
		      ps->gamewidth);
	if (hatch == HATCH_SLASH || hatch == HATCH_X)
	    ps_printf(ps, "%d %g %d {\n"
		      "  0 moveto %d dup rlineto\n"
		      "} for\n", -ps->gameheight, ps->hatchspace * ROOT2,
		      ps->gamewidth, max(ps->gamewidth, ps->gameheight));
	if (hatch == HATCH_BACKSLASH || hatch == HATCH_X)
	    ps_printf(ps, "0 %g %d {\n"
		      "  0 moveto %d neg dup neg rlineto\n"
		      "} for\n", ps->hatchspace * ROOT2,
		      ps->gamewidth+ps->gameheight,
		      max(ps->gamewidth, ps->gameheight));
	ps_printf(ps, "0 setgray %g setlinewidth stroke grestore\n",
		  ps->hatchthick);
    }
}

static void ps_setcolour_internal(psdata *ps, int colour, char *suffix)
{
    int hatch;
    float r, g, b;

    print_get_colour(ps->drawing, colour, ps->colour, &hatch, &r, &g, &b);

    /*
     * Stroking in hatched colours is not permitted.
     */
    assert(hatch < 0);
    
    if (ps->colour)
	ps_printf(ps, "%g %g %g setrgbcolor%s\n", r, g, b, suffix);
    else
	ps_printf(ps, "%g setgray%s\n", r, suffix);
}

static void ps_setcolour(psdata *ps, int colour)
{
    ps_setcolour_internal(ps, colour, "");
}

static void ps_stroke(psdata *ps, int colour)
{
    ps_setcolour_internal(ps, colour, " stroke");
}

static void ps_draw_text(void *handle, int x, int y, int fonttype,
			 int fontsize, int align, int colour, char *text)
{
    psdata *ps = (psdata *)handle;

    y = ps->ytop - y;
    ps_setcolour(ps, colour);
    ps_printf(ps, "/%s findfont %d scalefont setfont\n",
	      fonttype == FONT_FIXED ? "Courier" : "Helvetica",
	      fontsize);
    if (align & ALIGN_VCENTRE) {
	ps_printf(ps, "newpath 0 0 moveto (X) true charpath flattenpath"
		  " pathbbox\n"
		  "3 -1 roll add 2 div %d exch sub %d exch moveto pop pop\n",
		  y, x);
    } else {
	ps_printf(ps, "%d %d moveto\n", x, y);
    }
    ps_printf(ps, "(");
    while (*text) {
	if (*text == '\\' || *text == '(' || *text == ')')
	    ps_printf(ps, "\\");
	ps_printf(ps, "%c", *text);
	text++;
    }
    ps_printf(ps, ") ");
    if (align & (ALIGN_HCENTRE | ALIGN_HRIGHT))
	ps_printf(ps, "dup stringwidth pop %sneg 0 rmoveto show\n",
		  (align & ALIGN_HCENTRE) ? "2 div " : "");
    else
	ps_printf(ps, "show\n");
}

static void ps_draw_rect(void *handle, int x, int y, int w, int h, int colour)
{
    psdata *ps = (psdata *)handle;

    y = ps->ytop - y;
    /*
     * Offset by half a pixel for the exactness requirement.
     */
    ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
	      " %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
    ps_fill(ps, colour);
}

static void ps_draw_line(void *handle, int x1, int y1, int x2, int y2,
			 int colour)
{
    psdata *ps = (psdata *)handle;

    y1 = ps->ytop - y1;
    y2 = ps->ytop - y2;
    ps_printf(ps, "newpath %d %d moveto %d %d lineto\n", x1, y1, x2, y2);
    ps_stroke(ps, colour);
}

static void ps_draw_polygon(void *handle, int *coords, int npoints,
			    int fillcolour, int outlinecolour)
{
    psdata *ps = (psdata *)handle;

    int i;

    ps_printf(ps, "newpath %d %d moveto\n", coords[0], ps->ytop - coords[1]);

    for (i = 1; i < npoints; i++)
	ps_printf(ps, "%d %d lineto\n", coords[i*2], ps->ytop - coords[i*2+1]);

    ps_printf(ps, "closepath\n");

    if (fillcolour >= 0) {
	ps_printf(ps, "gsave\n");
	ps_fill(ps, fillcolour);
	ps_printf(ps, "grestore\n");
    }
    ps_stroke(ps, outlinecolour);
}

static void ps_draw_circle(void *handle, int cx, int cy, int radius,
			   int fillcolour, int outlinecolour)
{
    psdata *ps = (psdata *)handle;

    cy = ps->ytop - cy;

    ps_printf(ps, "newpath %d %d %d 0 360 arc closepath\n", cx, cy, radius);

    if (fillcolour >= 0) {
	ps_printf(ps, "gsave\n");
	ps_fill(ps, fillcolour);
	ps_printf(ps, "grestore\n");
    }
    ps_stroke(ps, outlinecolour);
}

static void ps_unclip(void *handle)
{
    psdata *ps = (psdata *)handle;

    assert(ps->clipped);
    ps_printf(ps, "grestore\n");
    ps->clipped = FALSE;
}
 
static void ps_clip(void *handle, int x, int y, int w, int h)
{
    psdata *ps = (psdata *)handle;

    if (ps->clipped)
	ps_unclip(ps);

    y = ps->ytop - y;
    /*
     * Offset by half a pixel for the exactness requirement.
     */
    ps_printf(ps, "gsave\n");
    ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
	      " %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
    ps_printf(ps, "clip\n");
    ps->clipped = TRUE;
}

static void ps_line_width(void *handle, float width)
{
    psdata *ps = (psdata *)handle;

    ps_printf(ps, "%g setlinewidth\n", width);
}

static void ps_begin_doc(void *handle, int pages)
{
    psdata *ps = (psdata *)handle;

    fputs("%!PS-Adobe-3.0\n", ps->fp);
    fputs("%%Creator: Simon Tatham's Portable Puzzle Collection\n", ps->fp);
    fputs("%%DocumentData: Clean7Bit\n", ps->fp);
    fputs("%%LanguageLevel: 1\n", ps->fp);
    fprintf(ps->fp, "%%%%Pages: %d\n", pages);
    fputs("%%DocumentNeededResources:\n", ps->fp);
    fputs("%%+ font Helvetica\n", ps->fp);
    fputs("%%+ font Courier\n", ps->fp);
    fputs("%%EndComments\n", ps->fp);
    fputs("%%BeginSetup\n", ps->fp);
    fputs("%%IncludeResource: font Helvetica\n", ps->fp);
    fputs("%%IncludeResource: font Courier\n", ps->fp);
    fputs("%%EndSetup\n", ps->fp);
}

static void ps_begin_page(void *handle, int number)
{
    psdata *ps = (psdata *)handle;

    fprintf(ps->fp, "%%%%Page: %d %d\ngsave save\n%g dup scale\n",
	    number, number, 72.0 / 25.4);
}

static void ps_begin_puzzle(void *handle, float xm, float xc,
			    float ym, float yc, int pw, int ph, float wmm)
{
    psdata *ps = (psdata *)handle;

    fprintf(ps->fp, "gsave\n"
	    "clippath flattenpath pathbbox pop pop translate\n"
	    "clippath flattenpath pathbbox 4 2 roll pop pop\n"
	    "exch %g mul %g add exch dup %g mul %g add sub translate\n"
	    "%g dup scale\n"
	    "0 -%d translate\n", xm, xc, ym, yc, wmm/pw, ph);
    ps->ytop = ph;
    ps->clipped = FALSE;
    ps->gamewidth = pw;
    ps->gameheight = ph;
    ps->hatchthick = 0.2 * pw / wmm;
    ps->hatchspace = 1.0 * pw / wmm;
}

static void ps_end_puzzle(void *handle)
{
    psdata *ps = (psdata *)handle;

    fputs("grestore\n", ps->fp);
}

static void ps_end_page(void *handle, int number)
{
    psdata *ps = (psdata *)handle;

    fputs("restore grestore showpage\n", ps->fp);
}

static void ps_end_doc(void *handle)
{
    psdata *ps = (psdata *)handle;

    fputs("%%EOF\n", ps->fp);
}

static const struct drawing_api ps_drawing = {
    ps_draw_text,
    ps_draw_rect,
    ps_draw_line,
    ps_draw_polygon,
    ps_draw_circle,
    NULL /* draw_update */,
    ps_clip,
    ps_unclip,
    NULL /* start_draw */,
    NULL /* end_draw */,
    NULL /* status_bar */,
    NULL /* blitter_new */,
    NULL /* blitter_free */,
    NULL /* blitter_save */,
    NULL /* blitter_load */,
    ps_begin_doc,
    ps_begin_page,
    ps_begin_puzzle,
    ps_end_puzzle,
    ps_end_page,
    ps_end_doc,
    ps_line_width,
};

psdata *ps_init(FILE *outfile, int colour)
{
    psdata *ps = snew(psdata);

    ps->fp = outfile;
    ps->colour = colour;
    ps->ytop = 0;
    ps->clipped = FALSE;
    ps->hatchthick = ps->hatchspace = ps->gamewidth = ps->gameheight = 0;
    ps->drawing = drawing_new(&ps_drawing, NULL, ps);

    return ps;
}

void ps_free(psdata *ps)
{
    drawing_free(ps->drawing);
    sfree(ps);
}

drawing *ps_drawing_api(psdata *ps)
{
    return ps->drawing;
}
Commit	Line	Data
dafd6cf6	1	/*
	2	* ps.c: PostScript printing functions.
	3	*/
	4
	5	#include <stdio.h>
	6	#include <stdarg.h>
	7	#include <string.h>
	8	#include <assert.h>
	9
	10	#include "puzzles.h"
	11
	12	#define ROOT2 1.414213562
	13
	14	struct psdata {
	15	FILE *fp;
	16	int colour;
	17	int ytop;
	18	int clipped;
	19	float hatchthick, hatchspace;
	20	int gamewidth, gameheight;
	21	drawing *drawing;
	22	};
	23
	24	static void ps_printf(psdata ps, char fmt, ...)
	25	{
	26	va_list ap;
	27
	28	va_start(ap, fmt);
	29	vfprintf(ps->fp, fmt, ap);
	30	va_end(ap);
	31	}
	32
	33	static void ps_fill(psdata *ps, int colour)
	34	{
	35	int hatch;
	36	float r, g, b;
	37
60aa1c74	38	print_get_colour(ps->drawing, colour, ps->colour, &hatch, &r, &g, &b);
dafd6cf6	39
60aa1c74	40	if (hatch < 0) {
	41	if (ps->colour)
	42	ps_printf(ps, "%g %g %g setrgbcolor fill\n", r, g, b);
	43	else
	44	ps_printf(ps, "%g setgray fill\n", r);
dafd6cf6	45	} else {
	46	/* Clip to the region. */
	47	ps_printf(ps, "gsave clip\n");
	48	/* Hatch the entire game printing area. */
	49	ps_printf(ps, "newpath\n");
	50	if (hatch == HATCH_VERT \|\| hatch == HATCH_PLUS)
	51	ps_printf(ps, "0 %g %d {\n"
	52	" 0 moveto 0 %d rlineto\n"
	53	"} for\n", ps->hatchspace, ps->gamewidth,
	54	ps->gameheight);
	55	if (hatch == HATCH_HORIZ \|\| hatch == HATCH_PLUS)
	56	ps_printf(ps, "0 %g %d {\n"
	57	" 0 exch moveto %d 0 rlineto\n"
	58	"} for\n", ps->hatchspace, ps->gameheight,
	59	ps->gamewidth);
	60	if (hatch == HATCH_SLASH \|\| hatch == HATCH_X)
	61	ps_printf(ps, "%d %g %d {\n"
	62	" 0 moveto %d dup rlineto\n"
	63	"} for\n", -ps->gameheight, ps->hatchspace * ROOT2,
	64	ps->gamewidth, max(ps->gamewidth, ps->gameheight));
	65	if (hatch == HATCH_BACKSLASH \|\| hatch == HATCH_X)
	66	ps_printf(ps, "0 %g %d {\n"
	67	" 0 moveto %d neg dup neg rlineto\n"
	68	"} for\n", ps->hatchspace * ROOT2,
	69	ps->gamewidth+ps->gameheight,
	70	max(ps->gamewidth, ps->gameheight));
	71	ps_printf(ps, "0 setgray %g setlinewidth stroke grestore\n",
	72	ps->hatchthick);
	73	}
	74	}
	75
	76	static void ps_setcolour_internal(psdata ps, int colour, char suffix)
	77	{
	78	int hatch;
	79	float r, g, b;
	80
60aa1c74	81	print_get_colour(ps->drawing, colour, ps->colour, &hatch, &r, &g, &b);
dafd6cf6	82
60aa1c74	83	/*
	84	* Stroking in hatched colours is not permitted.
	85	*/
	86	assert(hatch < 0);
	87
	88	if (ps->colour)
	89	ps_printf(ps, "%g %g %g setrgbcolor%s\n", r, g, b, suffix);
	90	else
	91	ps_printf(ps, "%g setgray%s\n", r, suffix);
dafd6cf6	92	}
	93
	94	static void ps_setcolour(psdata *ps, int colour)
	95	{
	96	ps_setcolour_internal(ps, colour, "");
	97	}
	98
	99	static void ps_stroke(psdata *ps, int colour)
	100	{
	101	ps_setcolour_internal(ps, colour, " stroke");
	102	}
	103
	104	static void ps_draw_text(void *handle, int x, int y, int fonttype,
	105	int fontsize, int align, int colour, char *text)
	106	{
	107	psdata ps = (psdata )handle;
	108
	109	y = ps->ytop - y;
	110	ps_setcolour(ps, colour);
	111	ps_printf(ps, "/%s findfont %d scalefont setfont\n",
	112	fonttype == FONT_FIXED ? "Courier" : "Helvetica",
0d336b11	113	fontsize);
dafd6cf6	114	if (align & ALIGN_VCENTRE) {
	115	ps_printf(ps, "newpath 0 0 moveto (X) true charpath flattenpath"
	116	" pathbbox\n"
	117	"3 -1 roll add 2 div %d exch sub %d exch moveto pop pop\n",
	118	y, x);
	119	} else {
	120	ps_printf(ps, "%d %d moveto\n", x, y);
	121	}
	122	ps_printf(ps, "(");
	123	while (*text) {
	124	if (text == '\\' \|\| text == '(' \|\| *text == ')')
	125	ps_printf(ps, "\\");
	126	ps_printf(ps, "%c", *text);
	127	text++;
	128	}
	129	ps_printf(ps, ") ");
	130	if (align & (ALIGN_HCENTRE \| ALIGN_HRIGHT))
	131	ps_printf(ps, "dup stringwidth pop %sneg 0 rmoveto show\n",
	132	(align & ALIGN_HCENTRE) ? "2 div " : "");
	133	else
	134	ps_printf(ps, "show\n");
	135	}
	136
	137	static void ps_draw_rect(void *handle, int x, int y, int w, int h, int colour)
	138	{
	139	psdata ps = (psdata )handle;
	140
	141	y = ps->ytop - y;
	142	/*
	143	* Offset by half a pixel for the exactness requirement.
	144	*/
	145	ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
	146	" %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
	147	ps_fill(ps, colour);
	148	}
	149
	150	static void ps_draw_line(void *handle, int x1, int y1, int x2, int y2,
	151	int colour)
	152	{
	153	psdata ps = (psdata )handle;
	154
	155	y1 = ps->ytop - y1;
	156	y2 = ps->ytop - y2;
	157	ps_printf(ps, "newpath %d %d moveto %d %d lineto\n", x1, y1, x2, y2);
	158	ps_stroke(ps, colour);
	159	}
	160
	161	static void ps_draw_polygon(void handle, int coords, int npoints,
	162	int fillcolour, int outlinecolour)
	163	{
	164	psdata ps = (psdata )handle;
	165
	166	int i;
	167
	168	ps_printf(ps, "newpath %d %d moveto\n", coords[0], ps->ytop - coords[1]);
	169
	170	for (i = 1; i < npoints; i++)
	171	ps_printf(ps, "%d %d lineto\n", coords[i2], ps->ytop - coords[i2+1]);
	172
	173	ps_printf(ps, "closepath\n");
	174
	175	if (fillcolour >= 0) {
	176	ps_printf(ps, "gsave\n");
	177	ps_fill(ps, fillcolour);
178	ps_printf(ps, "grestore\n");
179	}
180	ps_stroke(ps, outlinecolour);
181	}
182
183	static void ps_draw_circle(void *handle, int cx, int cy, int radius,
184	int fillcolour, int outlinecolour)
185	{
186	psdata ps = (psdata )handle;
187
188	cy = ps->ytop - cy;
189
190	ps_printf(ps, "newpath %d %d %d 0 360 arc closepath\n", cx, cy, radius);
191
192	if (fillcolour >= 0) {
193	ps_printf(ps, "gsave\n");
194	ps_fill(ps, fillcolour);
195	ps_printf(ps, "grestore\n");
196	}
197	ps_stroke(ps, outlinecolour);
198	}
199
200	static void ps_unclip(void *handle)
201	{
202	psdata ps = (psdata )handle;
203
204	assert(ps->clipped);
205	ps_printf(ps, "grestore\n");
206	ps->clipped = FALSE;
207	}
208
209	static void ps_clip(void *handle, int x, int y, int w, int h)
210	{
211	psdata ps = (psdata )handle;
212
213	if (ps->clipped)
214	ps_unclip(ps);
215
216	y = ps->ytop - y;
217	/*
218	* Offset by half a pixel for the exactness requirement.
219	*/
220	ps_printf(ps, "gsave\n");
221	ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
222	" %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
223	ps_printf(ps, "clip\n");
224	ps->clipped = TRUE;
225	}
226
227	static void ps_line_width(void *handle, float width)
228	{
229	psdata ps = (psdata )handle;
230
231	ps_printf(ps, "%g setlinewidth\n", width);
232	}
233
234	static void ps_begin_doc(void *handle, int pages)
235	{
236	psdata ps = (psdata )handle;
237
238	fputs("%!PS-Adobe-3.0\n", ps->fp);
239	fputs("%%Creator: Simon Tatham's Portable Puzzle Collection\n", ps->fp);
240	fputs("%%DocumentData: Clean7Bit\n", ps->fp);
241	fputs("%%LanguageLevel: 1\n", ps->fp);
242	fprintf(ps->fp, "%%%%Pages: %d\n", pages);
243	fputs("%%DocumentNeededResources:\n", ps->fp);
244	fputs("%%+ font Helvetica\n", ps->fp);
245	fputs("%%+ font Courier\n", ps->fp);
246	fputs("%%EndComments\n", ps->fp);
247	fputs("%%BeginSetup\n", ps->fp);
248	fputs("%%IncludeResource: font Helvetica\n", ps->fp);
249	fputs("%%IncludeResource: font Courier\n", ps->fp);
250	fputs("%%EndSetup\n", ps->fp);
251	}
252
253	static void ps_begin_page(void *handle, int number)
254	{
255	psdata ps = (psdata )handle;
256
257	fprintf(ps->fp, "%%%%Page: %d %d\ngsave save\n%g dup scale\n",
258	number, number, 72.0 / 25.4);
259	}
260
261	static void ps_begin_puzzle(void *handle, float xm, float xc,
262	float ym, float yc, int pw, int ph, float wmm)
263	{
264	psdata ps = (psdata )handle;
265
266	fprintf(ps->fp, "gsave\n"
267	"clippath flattenpath pathbbox pop pop translate\n"
268	"clippath flattenpath pathbbox 4 2 roll pop pop\n"
269	"exch %g mul %g add exch dup %g mul %g add sub translate\n"
270	"%g dup scale\n"
271	"0 -%d translate\n", xm, xc, ym, yc, wmm/pw, ph);
272	ps->ytop = ph;
273	ps->clipped = FALSE;
274	ps->gamewidth = pw;
275	ps->gameheight = ph;
276	ps->hatchthick = 0.2 * pw / wmm;
277	ps->hatchspace = 1.0 * pw / wmm;
278	}
279
280	static void ps_end_puzzle(void *handle)
281	{
282	psdata ps = (psdata )handle;
283
284	fputs("grestore\n", ps->fp);
285	}
286
287	static void ps_end_page(void *handle, int number)
288	{
289	psdata ps = (psdata )handle;
290
291	fputs("restore grestore showpage\n", ps->fp);
292	}
293
294	static void ps_end_doc(void *handle)
295	{
296	psdata ps = (psdata )handle;
297
298	fputs("%%EOF\n", ps->fp);
299	}
300
301	static const struct drawing_api ps_drawing = {
302	ps_draw_text,
303	ps_draw_rect,
304	ps_draw_line,
305	ps_draw_polygon,
306	ps_draw_circle,
307	NULL /* draw_update */,
308	ps_clip,
309	ps_unclip,
310	NULL /* start_draw */,
311	NULL /* end_draw */,
312	NULL /* status_bar */,
313	NULL /* blitter_new */,
314	NULL /* blitter_free */,
315	NULL /* blitter_save */,
316	NULL /* blitter_load */,
317	ps_begin_doc,
318	ps_begin_page,
319	ps_begin_puzzle,
320	ps_end_puzzle,
321	ps_end_page,
322	ps_end_doc,
323	ps_line_width,
324	};
325
326	psdata ps_init(FILE outfile, int colour)
327	{
328	psdata *ps = snew(psdata);
329
330	ps->fp = outfile;
331	ps->colour = colour;
332	ps->ytop = 0;
333	ps->clipped = FALSE;
334	ps->hatchthick = ps->hatchspace = ps->gamewidth = ps->gameheight = 0;
83c0438f	335	ps->drawing = drawing_new(&ps_drawing, NULL, ps);
dafd6cf6	336
	337	return ps;
	338	}
	339
	340	void ps_free(psdata *ps)
	341	{
	342	drawing_free(ps->drawing);
	343	sfree(ps);
	344	}
	345
	346	drawing ps_drawing_api(psdata ps)
	347	{
	348	return ps->drawing;
	349	}