diff options
Diffstat (limited to 'apps/plugins/puzzles/drawing.c')
-rw-r--r-- | apps/plugins/puzzles/drawing.c | 351 |
1 files changed, 351 insertions, 0 deletions
diff --git a/apps/plugins/puzzles/drawing.c b/apps/plugins/puzzles/drawing.c new file mode 100644 index 0000000000..8bf58d5530 --- /dev/null +++ b/apps/plugins/puzzles/drawing.c | |||
@@ -0,0 +1,351 @@ | |||
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 | * | ||
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. | ||
24 | */ | ||
25 | |||
26 | #include <stdio.h> | ||
27 | #include <stdlib.h> | ||
28 | #include <string.h> | ||
29 | #include "rbassert.h" | ||
30 | #include <math.h> | ||
31 | |||
32 | #include "puzzles.h" | ||
33 | |||
34 | struct print_colour { | ||
35 | int hatch; | ||
36 | int hatch_when; /* 0=never 1=only-in-b&w 2=always */ | ||
37 | float r, g, b; | ||
38 | float grey; | ||
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; | ||
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; | ||
51 | }; | ||
52 | |||
53 | drawing *drawing_new(const drawing_api *api, midend *me, void *handle) | ||
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; | ||
61 | dr->me = me; | ||
62 | dr->laststatus = NULL; | ||
63 | return dr; | ||
64 | } | ||
65 | |||
66 | void drawing_free(drawing *dr) | ||
67 | { | ||
68 | sfree(dr->laststatus); | ||
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 | |||
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 | |||
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 | |||
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 | |||
191 | void status_bar(drawing *dr, char *text) | ||
192 | { | ||
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 | } | ||
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 | |||
265 | void print_get_colour(drawing *dr, int colour, int printing_in_colour, | ||
266 | int *hatch, float *r, float *g, float *b) | ||
267 | { | ||
268 | assert(colour >= 0 && colour < dr->ncolours); | ||
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 | } | ||
282 | } | ||
283 | |||
284 | static int print_generic_colour(drawing *dr, float r, float g, float b, | ||
285 | float grey, int hatch, int hatch_when) | ||
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; | ||
293 | dr->colours[dr->ncolours].hatch_when = hatch_when; | ||
294 | dr->colours[dr->ncolours].r = r; | ||
295 | dr->colours[dr->ncolours].g = g; | ||
296 | dr->colours[dr->ncolours].b = b; | ||
297 | dr->colours[dr->ncolours].grey = grey; | ||
298 | return dr->ncolours++; | ||
299 | } | ||
300 | |||
301 | int print_mono_colour(drawing *dr, int grey) | ||
302 | { | ||
303 | return print_generic_colour(dr, grey, grey, grey, grey, -1, 0); | ||
304 | } | ||
305 | |||
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) | ||
327 | { | ||
328 | return print_generic_colour(dr, r, g, b, 0, hatch, 1); | ||
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 | */ | ||
345 | dr->api->line_width(dr->handle, (float)sqrt(dr->scale) * width); | ||
346 | } | ||
347 | |||
348 | void print_line_dotted(drawing *dr, int dotted) | ||
349 | { | ||
350 | dr->api->line_dotted(dr->handle, dotted); | ||
351 | } | ||