[sgt/puzzles] / drawing.c

/*
 * drawing.c: Intermediary between the drawing interface as
 * presented to the back end, and that implemented by the front
 * end.
 * 
 * Mostly just looks up calls in a vtable and passes them through
 * unchanged. However, on the printing side it tracks print colours
 * so the front end API doesn't have to.
 * 
 * FIXME:
 * 
 *  - I'd _like_ to do automatic draw_updates, but it's a pain for
 *    draw_text in particular. I'd have to invent a front end API
 *    which retrieved the text bounds.
 *     + that might allow me to do the alignment centrally as well?
 * 	  * perhaps not, because PS can't return this information,
 * 	    so there would have to be a special case for it.
 *     + however, that at least doesn't stand in the way of using
 * 	 the text bounds for draw_update, because PS doesn't need
 * 	 draw_update since it's printing-only. Any _interactive_
 * 	 drawing API couldn't get away with refusing to tell you
 * 	 what parts of the screen a text draw had covered, because
 * 	 you would inevitably need to erase it later on.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>

#include "puzzles.h"

struct print_colour {
    int hatch;
    int hatch_when;		       /* 0=never 1=only-in-b&w 2=always */
    float r, g, b;
    float grey;
};

struct drawing {
    const drawing_api *api;
    void *handle;
    struct print_colour *colours;
    int ncolours, coloursize;
    float scale;
    /* `me' is only used in status_bar(), so print-oriented instances of
     * this may set it to NULL. */
    midend *me;
    char *laststatus;
};

drawing *drawing_new(const drawing_api *api, midend *me, void *handle)
{
    drawing *dr = snew(drawing);
    dr->api = api;
    dr->handle = handle;
    dr->colours = NULL;
    dr->ncolours = dr->coloursize = 0;
    dr->scale = 1.0F;
    dr->me = me;
    dr->laststatus = NULL;
    return dr;
}

void drawing_free(drawing *dr)
{
    sfree(dr->laststatus);
    sfree(dr->colours);
    sfree(dr);
}

void draw_text(drawing *dr, int x, int y, int fonttype, int fontsize,
               int align, int colour, char *text)
{
    dr->api->draw_text(dr->handle, x, y, fonttype, fontsize, align,
		       colour, text);
}

void draw_rect(drawing *dr, int x, int y, int w, int h, int colour)
{
    dr->api->draw_rect(dr->handle, x, y, w, h, colour);
}

void draw_line(drawing *dr, int x1, int y1, int x2, int y2, int colour)
{
    dr->api->draw_line(dr->handle, x1, y1, x2, y2, colour);
}

void draw_thick_line(drawing *dr, float thickness,
		     float x1, float y1, float x2, float y2, int colour)
{
    if (dr->api->draw_thick_line) {
	dr->api->draw_thick_line(dr->handle, thickness,
				 x1, y1, x2, y2, colour);
    } else {
	/* We'll fake it up with a filled polygon.  The tweak to the
	 * thickness empirically compensates for rounding errors, because
	 * polygon rendering uses integer coordinates.
	 */
	float len = sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
	float tvhatx = (x2 - x1)/len * (thickness/2 - 0.2);
	float tvhaty = (y2 - y1)/len * (thickness/2 - 0.2);
	int p[8];

	p[0] = x1 - tvhaty;
	p[1] = y1 + tvhatx;
	p[2] = x2 - tvhaty;
	p[3] = y2 + tvhatx;
	p[4] = x2 + tvhaty;
	p[5] = y2 - tvhatx;
	p[6] = x1 + tvhaty;
	p[7] = y1 - tvhatx;
	dr->api->draw_polygon(dr->handle, p, 4, colour, colour);
    }
}

void draw_polygon(drawing *dr, int *coords, int npoints,
                  int fillcolour, int outlinecolour)
{
    dr->api->draw_polygon(dr->handle, coords, npoints, fillcolour,
			  outlinecolour);
}

void draw_circle(drawing *dr, int cx, int cy, int radius,
                 int fillcolour, int outlinecolour)
{
    dr->api->draw_circle(dr->handle, cx, cy, radius, fillcolour,
			 outlinecolour);
}

void draw_update(drawing *dr, int x, int y, int w, int h)
{
    if (dr->api->draw_update)
	dr->api->draw_update(dr->handle, x, y, w, h);
}

void clip(drawing *dr, int x, int y, int w, int h)
{
    dr->api->clip(dr->handle, x, y, w, h);
}

void unclip(drawing *dr)
{
    dr->api->unclip(dr->handle);
}

void start_draw(drawing *dr)
{
    dr->api->start_draw(dr->handle);
}

void end_draw(drawing *dr)
{
    dr->api->end_draw(dr->handle);
}

char *text_fallback(drawing *dr, const char *const *strings, int nstrings)
{
    int i;

    /*
     * If the drawing implementation provides one of these, use it.
     */
    if (dr && dr->api->text_fallback)
	return dr->api->text_fallback(dr->handle, strings, nstrings);

    /*
     * Otherwise, do the simple thing and just pick the first string
     * that fits in plain ASCII. It will then need no translation
     * out of UTF-8.
     */
    for (i = 0; i < nstrings; i++) {
	const char *p;

	for (p = strings[i]; *p; p++)
	    if (*p & 0x80)
		break;
	if (!*p)
	    return dupstr(strings[i]);
    }

    /*
     * The caller was responsible for making sure _some_ string in
     * the list was in plain ASCII.
     */
    assert(!"Should never get here");
    return NULL;		       /* placate optimiser */
}

void status_bar(drawing *dr, char *text)
{
    char *rewritten;

    if (!dr->api->status_bar)
	return;

    assert(dr->me);

    rewritten = midend_rewrite_statusbar(dr->me, text);
    if (!dr->laststatus || strcmp(rewritten, dr->laststatus)) {
	dr->api->status_bar(dr->handle, rewritten);
	sfree(dr->laststatus);
	dr->laststatus = rewritten;
    } else {
	sfree(rewritten);
    }
}

blitter *blitter_new(drawing *dr, int w, int h)
{
    return dr->api->blitter_new(dr->handle, w, h);
}

void blitter_free(drawing *dr, blitter *bl)
{
    dr->api->blitter_free(dr->handle, bl);
}

void blitter_save(drawing *dr, blitter *bl, int x, int y)
{
    dr->api->blitter_save(dr->handle, bl, x, y);
}

void blitter_load(drawing *dr, blitter *bl, int x, int y)
{
    dr->api->blitter_load(dr->handle, bl, x, y);
}

void print_begin_doc(drawing *dr, int pages)
{
    dr->api->begin_doc(dr->handle, pages);
}

void print_begin_page(drawing *dr, int number)
{
    dr->api->begin_page(dr->handle, number);
}

void print_begin_puzzle(drawing *dr, float xm, float xc,
			float ym, float yc, int pw, int ph, float wmm,
			float scale)
{
    dr->scale = scale;
    dr->ncolours = 0;
    dr->api->begin_puzzle(dr->handle, xm, xc, ym, yc, pw, ph, wmm);
}

void print_end_puzzle(drawing *dr)
{
    dr->api->end_puzzle(dr->handle);
    dr->scale = 1.0F;
}

void print_end_page(drawing *dr, int number)
{
    dr->api->end_page(dr->handle, number);
}

void print_end_doc(drawing *dr)
{
    dr->api->end_doc(dr->handle);
}

void print_get_colour(drawing *dr, int colour, int printing_in_colour,
		      int *hatch, float *r, float *g, float *b)
{
    assert(colour >= 0 && colour < dr->ncolours);
    if (dr->colours[colour].hatch_when == 2 ||
	(dr->colours[colour].hatch_when == 1 && !printing_in_colour)) {
	*hatch = dr->colours[colour].hatch;
    } else {
	*hatch = -1;
	if (printing_in_colour) {
	    *r = dr->colours[colour].r;
	    *g = dr->colours[colour].g;
	    *b = dr->colours[colour].b;
	} else {
	    *r = *g = *b = dr->colours[colour].grey;
	}
    }
}

static int print_generic_colour(drawing *dr, float r, float g, float b,
				float grey, int hatch, int hatch_when)
{
    if (dr->ncolours >= dr->coloursize) {
	dr->coloursize = dr->ncolours + 16;
	dr->colours = sresize(dr->colours, dr->coloursize,
			      struct print_colour);
    }
    dr->colours[dr->ncolours].hatch = hatch;
    dr->colours[dr->ncolours].hatch_when = hatch_when;
    dr->colours[dr->ncolours].r = r;
    dr->colours[dr->ncolours].g = g;
    dr->colours[dr->ncolours].b = b;
    dr->colours[dr->ncolours].grey = grey;
    return dr->ncolours++;
}

int print_mono_colour(drawing *dr, int grey)
{
    return print_generic_colour(dr, grey, grey, grey, grey, -1, 0);
}

int print_grey_colour(drawing *dr, float grey)
{
    return print_generic_colour(dr, grey, grey, grey, grey, -1, 0);
}

int print_hatched_colour(drawing *dr, int hatch)
{
    return print_generic_colour(dr, 0, 0, 0, 0, hatch, 2);
}

int print_rgb_mono_colour(drawing *dr, float r, float g, float b, int grey)
{
    return print_generic_colour(dr, r, g, b, grey, -1, 0);
}

int print_rgb_grey_colour(drawing *dr, float r, float g, float b, float grey)
{
    return print_generic_colour(dr, r, g, b, grey, -1, 0);
}

int print_rgb_hatched_colour(drawing *dr, float r, float g, float b, int hatch)
{
    return print_generic_colour(dr, r, g, b, 0, hatch, 1);
}

void print_line_width(drawing *dr, int width)
{
    /*
     * I don't think it's entirely sensible to have line widths be
     * entirely relative to the puzzle size; there is a point
     * beyond which lines are just _stupidly_ thick. On the other
     * hand, absolute line widths aren't particularly nice either
     * because they start to feel a bit feeble at really large
     * scales.
     * 
     * My experimental answer is to scale line widths as the
     * _square root_ of the main puzzle scale. Double the puzzle
     * size, and the line width multiplies by 1.4.
     */
    dr->api->line_width(dr->handle, (float)sqrt(dr->scale) * width);
}

void print_line_dotted(drawing *dr, int dotted)
{
    dr->api->line_dotted(dr->handle, dotted);
}
Commit	Line	Data
dafd6cf6	1	/*
	2	* drawing.c: Intermediary between the drawing interface as
	3	* presented to the back end, and that implemented by the front
	4	* end.
	5	*
	6	* Mostly just looks up calls in a vtable and passes them through
	7	* unchanged. However, on the printing side it tracks print colours
	8	* so the front end API doesn't have to.
	9	*
83c0438f	10	* FIXME:
	11	*
	12	* - I'd _like_ to do automatic draw_updates, but it's a pain for
	13	* draw_text in particular. I'd have to invent a front end API
	14	* which retrieved the text bounds.
	15	* + that might allow me to do the alignment centrally as well?
	16	* * perhaps not, because PS can't return this information,
	17	* so there would have to be a special case for it.
	18	* + however, that at least doesn't stand in the way of using
	19	* the text bounds for draw_update, because PS doesn't need
	20	* draw_update since it's printing-only. Any _interactive_
	21	* drawing API couldn't get away with refusing to tell you
	22	* what parts of the screen a text draw had covered, because
	23	* you would inevitably need to erase it later on.
dafd6cf6	24	*/
	25
	26	#include <stdio.h>
	27	#include <stdlib.h>
83c0438f	28	#include <string.h>
dafd6cf6	29	#include <assert.h>
	30	#include <math.h>
	31
	32	#include "puzzles.h"
	33
	34	struct print_colour {
	35	int hatch;
60aa1c74	36	int hatch_when; /* 0=never 1=only-in-b&w 2=always */
dafd6cf6	37	float r, g, b;
60aa1c74	38	float grey;
dafd6cf6	39	};
	40
	41	struct drawing {
	42	const drawing_api *api;
	43	void *handle;
	44	struct print_colour *colours;
	45	int ncolours, coloursize;
	46	float scale;
83c0438f	47	/* `me' is only used in status_bar(), so print-oriented instances of
	48	* this may set it to NULL. */
	49	midend *me;
	50	char *laststatus;
dafd6cf6	51	};
dafd6cf6	52
83c0438f	53	drawing drawing_new(const drawing_api api, midend me, void handle)
dafd6cf6	54	{
	55	drawing *dr = snew(drawing);
	56	dr->api = api;
	57	dr->handle = handle;
	58	dr->colours = NULL;
	59	dr->ncolours = dr->coloursize = 0;
	60	dr->scale = 1.0F;
83c0438f	61	dr->me = me;
83c0438f	62	dr->laststatus = NULL;
dafd6cf6	63	return dr;
	64	}
	65
	66	void drawing_free(drawing *dr)
	67	{
83c0438f	68	sfree(dr->laststatus);
dafd6cf6	69	sfree(dr->colours);
	70	sfree(dr);
	71	}
	72
	73	void draw_text(drawing *dr, int x, int y, int fonttype, int fontsize,
	74	int align, int colour, char *text)
	75	{
	76	dr->api->draw_text(dr->handle, x, y, fonttype, fontsize, align,
	77	colour, text);
	78	}
	79
	80	void draw_rect(drawing *dr, int x, int y, int w, int h, int colour)
	81	{
	82	dr->api->draw_rect(dr->handle, x, y, w, h, colour);
	83	}
	84
	85	void draw_line(drawing *dr, int x1, int y1, int x2, int y2, int colour)
	86	{
	87	dr->api->draw_line(dr->handle, x1, y1, x2, y2, colour);
	88	}
	89
a39c3aa0	90	void draw_thick_line(drawing *dr, float thickness,
	91	float x1, float y1, float x2, float y2, int colour)
	92	{
	93	if (dr->api->draw_thick_line) {
	94	dr->api->draw_thick_line(dr->handle, thickness,
	95	x1, y1, x2, y2, colour);
	96	} else {
	97	/* We'll fake it up with a filled polygon. The tweak to the
	98	* thickness empirically compensates for rounding errors, because
	99	* polygon rendering uses integer coordinates.
	100	*/
	101	float len = sqrt((x2 - x1)(x2 - x1) + (y2 - y1)(y2 - y1));
	102	float tvhatx = (x2 - x1)/len * (thickness/2 - 0.2);
	103	float tvhaty = (y2 - y1)/len * (thickness/2 - 0.2);
	104	int p[8];
	105
	106	p[0] = x1 - tvhaty;
	107	p[1] = y1 + tvhatx;
	108	p[2] = x2 - tvhaty;
	109	p[3] = y2 + tvhatx;
	110	p[4] = x2 + tvhaty;
	111	p[5] = y2 - tvhatx;
	112	p[6] = x1 + tvhaty;
	113	p[7] = y1 - tvhatx;
	114	dr->api->draw_polygon(dr->handle, p, 4, colour, colour);
	115	}
	116	}
	117
dafd6cf6	118	void draw_polygon(drawing dr, int coords, int npoints,
	119	int fillcolour, int outlinecolour)
	120	{
	121	dr->api->draw_polygon(dr->handle, coords, npoints, fillcolour,
	122	outlinecolour);
	123	}
	124
	125	void draw_circle(drawing *dr, int cx, int cy, int radius,
	126	int fillcolour, int outlinecolour)
	127	{
	128	dr->api->draw_circle(dr->handle, cx, cy, radius, fillcolour,
	129	outlinecolour);
	130	}
	131
	132	void draw_update(drawing *dr, int x, int y, int w, int h)
	133	{
	134	if (dr->api->draw_update)
	135	dr->api->draw_update(dr->handle, x, y, w, h);
	136	}
	137
	138	void clip(drawing *dr, int x, int y, int w, int h)
	139	{
	140	dr->api->clip(dr->handle, x, y, w, h);
	141	}
	142
	143	void unclip(drawing *dr)
	144	{
	145	dr->api->unclip(dr->handle);
	146	}
	147
	148	void start_draw(drawing *dr)
	149	{
	150	dr->api->start_draw(dr->handle);
	151	}
	152
	153	void end_draw(drawing *dr)
	154	{
	155	dr->api->end_draw(dr->handle);
	156	}
	157
4011952c	158	char text_fallback(drawing dr, const char const strings, int nstrings)
	159	{
	160	int i;
	161
	162	/*
	163	* If the drawing implementation provides one of these, use it.
	164	*/
	165	if (dr && dr->api->text_fallback)
	166	return dr->api->text_fallback(dr->handle, strings, nstrings);
	167
	168	/*
	169	* Otherwise, do the simple thing and just pick the first string
	170	* that fits in plain ASCII. It will then need no translation
	171	* out of UTF-8.
	172	*/
	173	for (i = 0; i < nstrings; i++) {
	174	const char *p;
	175
	176	for (p = strings[i]; *p; p++)
	177	if (*p & 0x80)
	178	break;
	179	if (!*p)
	180	return dupstr(strings[i]);
	181	}
	182
	183	/*
	184	* The caller was responsible for making sure _some_ string in
	185	* the list was in plain ASCII.
	186	*/
	187	assert(!"Should never get here");
	188	return NULL; /* placate optimiser */
	189	}
	190
dafd6cf6	191	void status_bar(drawing dr, char text)
dafd6cf6	192	{
83c0438f	193	char *rewritten;
	194
	195	if (!dr->api->status_bar)
	196	return;
	197
	198	assert(dr->me);
	199
	200	rewritten = midend_rewrite_statusbar(dr->me, text);
	201	if (!dr->laststatus \|\| strcmp(rewritten, dr->laststatus)) {
	202	dr->api->status_bar(dr->handle, rewritten);
	203	sfree(dr->laststatus);
	204	dr->laststatus = rewritten;
	205	} else {
	206	sfree(rewritten);
	207	}
dafd6cf6	208	}
	209
	210	blitter blitter_new(drawing dr, int w, int h)
	211	{
	212	return dr->api->blitter_new(dr->handle, w, h);
	213	}
	214
	215	void blitter_free(drawing dr, blitter bl)
	216	{
	217	dr->api->blitter_free(dr->handle, bl);
	218	}
	219
	220	void blitter_save(drawing dr, blitter bl, int x, int y)
	221	{
	222	dr->api->blitter_save(dr->handle, bl, x, y);
	223	}
	224
	225	void blitter_load(drawing dr, blitter bl, int x, int y)
	226	{
	227	dr->api->blitter_load(dr->handle, bl, x, y);
	228	}
	229
	230	void print_begin_doc(drawing *dr, int pages)
	231	{
	232	dr->api->begin_doc(dr->handle, pages);
	233	}
	234
	235	void print_begin_page(drawing *dr, int number)
	236	{
	237	dr->api->begin_page(dr->handle, number);
	238	}
	239
	240	void print_begin_puzzle(drawing *dr, float xm, float xc,
	241	float ym, float yc, int pw, int ph, float wmm,
	242	float scale)
	243	{
	244	dr->scale = scale;
	245	dr->ncolours = 0;
	246	dr->api->begin_puzzle(dr->handle, xm, xc, ym, yc, pw, ph, wmm);
	247	}
	248
	249	void print_end_puzzle(drawing *dr)
	250	{
	251	dr->api->end_puzzle(dr->handle);
	252	dr->scale = 1.0F;
	253	}
	254
	255	void print_end_page(drawing *dr, int number)
	256	{
	257	dr->api->end_page(dr->handle, number);
	258	}
	259
	260	void print_end_doc(drawing *dr)
	261	{
	262	dr->api->end_doc(dr->handle);
	263	}
	264
60aa1c74	265	void print_get_colour(drawing *dr, int colour, int printing_in_colour,
60aa1c74	266	int hatch, float r, float g, float b)
dafd6cf6	267	{
dafd6cf6	268	assert(colour >= 0 && colour < dr->ncolours);
60aa1c74	269	if (dr->colours[colour].hatch_when == 2 \|\|
	270	(dr->colours[colour].hatch_when == 1 && !printing_in_colour)) {
	271	*hatch = dr->colours[colour].hatch;
	272	} else {
	273	*hatch = -1;
	274	if (printing_in_colour) {
	275	*r = dr->colours[colour].r;
	276	*g = dr->colours[colour].g;
	277	*b = dr->colours[colour].b;
	278	} else {
	279	r = g = *b = dr->colours[colour].grey;
	280	}
	281	}
dafd6cf6	282	}
dafd6cf6	283
60aa1c74	284	static int print_generic_colour(drawing *dr, float r, float g, float b,
60aa1c74	285	float grey, int hatch, int hatch_when)
dafd6cf6	286	{
	287	if (dr->ncolours >= dr->coloursize) {
	288	dr->coloursize = dr->ncolours + 16;
	289	dr->colours = sresize(dr->colours, dr->coloursize,
	290	struct print_colour);
	291	}
	292	dr->colours[dr->ncolours].hatch = hatch;
60aa1c74	293	dr->colours[dr->ncolours].hatch_when = hatch_when;
dafd6cf6	294	dr->colours[dr->ncolours].r = r;
	295	dr->colours[dr->ncolours].g = g;
	296	dr->colours[dr->ncolours].b = b;
60aa1c74	297	dr->colours[dr->ncolours].grey = grey;
dafd6cf6	298	return dr->ncolours++;
	299	}
	300
60aa1c74	301	int print_mono_colour(drawing *dr, int grey)
dafd6cf6	302	{
60aa1c74	303	return print_generic_colour(dr, grey, grey, grey, grey, -1, 0);
dafd6cf6	304	}
dafd6cf6	305
60aa1c74	306	int print_grey_colour(drawing *dr, float grey)
	307	{
	308	return print_generic_colour(dr, grey, grey, grey, grey, -1, 0);
	309	}
	310
	311	int print_hatched_colour(drawing *dr, int hatch)
	312	{
	313	return print_generic_colour(dr, 0, 0, 0, 0, hatch, 2);
	314	}
	315
	316	int print_rgb_mono_colour(drawing *dr, float r, float g, float b, int grey)
	317	{
	318	return print_generic_colour(dr, r, g, b, grey, -1, 0);
	319	}
	320
	321	int print_rgb_grey_colour(drawing *dr, float r, float g, float b, float grey)
	322	{
	323	return print_generic_colour(dr, r, g, b, grey, -1, 0);
	324	}
	325
	326	int print_rgb_hatched_colour(drawing *dr, float r, float g, float b, int hatch)
dafd6cf6	327	{
60aa1c74	328	return print_generic_colour(dr, r, g, b, 0, hatch, 1);
dafd6cf6	329	}
	330
	331	void print_line_width(drawing *dr, int width)
	332	{
	333	/*
	334	* I don't think it's entirely sensible to have line widths be
	335	* entirely relative to the puzzle size; there is a point
	336	* beyond which lines are just _stupidly_ thick. On the other
	337	* hand, absolute line widths aren't particularly nice either
	338	* because they start to feel a bit feeble at really large
	339	* scales.
	340	*
	341	* My experimental answer is to scale line widths as the
	342	* _square root_ of the main puzzle scale. Double the puzzle
	343	* size, and the line width multiplies by 1.4.
	344	*/
5b502ae8	345	dr->api->line_width(dr->handle, (float)sqrt(dr->scale) * width);
dafd6cf6	346	}
e91f8f26	347
	348	void print_line_dotted(drawing *dr, int dotted)
	349	{
	350	dr->api->line_dotted(dr->handle, dotted);
	351	}