diff options
author | Franklin Wei <frankhwei536@gmail.com> | 2016-11-20 15:16:41 -0500 |
---|---|---|
committer | Franklin Wei <me@fwei.tk> | 2016-12-18 18:13:22 +0100 |
commit | 1a6a8b52f7aa4e2da6f4c34a0c743c760b8cfd99 (patch) | |
tree | 8e7f2d6b0cbdb5d15c13457b2c3e1de69f598440 /apps/plugins/puzzles/gtk.c | |
parent | 3ee79724f6fb033d50e26ef37b33d3f8cedf0c5b (diff) | |
download | rockbox-1a6a8b52f7aa4e2da6f4c34a0c743c760b8cfd99.tar.gz rockbox-1a6a8b52f7aa4e2da6f4c34a0c743c760b8cfd99.zip |
Port of Simon Tatham's Puzzle Collection
Original revision: 5123b1bf68777ffa86e651f178046b26a87cf2d9
MIT Licensed. Some games still crash and others are unplayable due to
issues with controls. Still need a "real" polygon filling algorithm.
Currently builds one plugin per puzzle (about 40 in total, around 100K
each on ARM), but can easily be made to build a single monolithic
overlay (800K or so on ARM).
The following games are at least partially broken for various reasons,
and have been disabled on this commit:
Cube: failed assertion with "Icosahedron" setting
Keen: input issues
Mines: weird stuff happens on target
Palisade: input issues
Solo: input issues, occasional crash on target
Towers: input issues
Undead: input issues
Unequal: input and drawing issues (concave polys)
Untangle: input issues
Features left to do:
- In-game help system
- Figure out the weird bugs
Change-Id: I7c69b6860ab115f973c8d76799502e9bb3d52368
Diffstat (limited to 'apps/plugins/puzzles/gtk.c')
-rw-r--r-- | apps/plugins/puzzles/gtk.c | 3215 |
1 files changed, 3215 insertions, 0 deletions
diff --git a/apps/plugins/puzzles/gtk.c b/apps/plugins/puzzles/gtk.c new file mode 100644 index 0000000000..aa3ba06eed --- /dev/null +++ b/apps/plugins/puzzles/gtk.c | |||
@@ -0,0 +1,3215 @@ | |||
1 | /* | ||
2 | * gtk.c: GTK front end for my puzzle collection. | ||
3 | */ | ||
4 | |||
5 | #include <stdio.h> | ||
6 | #include "rbassert.h" | ||
7 | #include <stdlib.h> | ||
8 | #include <time.h> | ||
9 | #include <stdarg.h> | ||
10 | #include <string.h> | ||
11 | #include <errno.h> | ||
12 | #include <math.h> | ||
13 | |||
14 | #include <sys/time.h> | ||
15 | #include <sys/resource.h> | ||
16 | |||
17 | #include <gtk/gtk.h> | ||
18 | #include <gdk/gdkkeysyms.h> | ||
19 | |||
20 | #include <gdk-pixbuf/gdk-pixbuf.h> | ||
21 | |||
22 | #include <gdk/gdkx.h> | ||
23 | #include <X11/Xlib.h> | ||
24 | #include <X11/Xutil.h> | ||
25 | #include <X11/Xatom.h> | ||
26 | |||
27 | #include "puzzles.h" | ||
28 | |||
29 | #if GTK_CHECK_VERSION(2,0,0) | ||
30 | # define USE_PANGO | ||
31 | # ifdef PANGO_VERSION_CHECK | ||
32 | # if PANGO_VERSION_CHECK(1,8,0) | ||
33 | # define HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION | ||
34 | # endif | ||
35 | # endif | ||
36 | #endif | ||
37 | #if !GTK_CHECK_VERSION(2,4,0) | ||
38 | # define OLD_FILESEL | ||
39 | #endif | ||
40 | #if GTK_CHECK_VERSION(2,8,0) | ||
41 | # define USE_CAIRO | ||
42 | # if GTK_CHECK_VERSION(3,0,0) || defined(GDK_DISABLE_DEPRECATED) | ||
43 | # define USE_CAIRO_WITHOUT_PIXMAP | ||
44 | # endif | ||
45 | #endif | ||
46 | |||
47 | #if GTK_CHECK_VERSION(3,0,0) | ||
48 | /* The old names are still more concise! */ | ||
49 | #define gtk_hbox_new(x,y) gtk_box_new(GTK_ORIENTATION_HORIZONTAL,y) | ||
50 | #define gtk_vbox_new(x,y) gtk_box_new(GTK_ORIENTATION_VERTICAL,y) | ||
51 | /* GTK 3 has retired stock button labels */ | ||
52 | #define LABEL_OK "_OK" | ||
53 | #define LABEL_CANCEL "_Cancel" | ||
54 | #define LABEL_NO "_No" | ||
55 | #define LABEL_YES "_Yes" | ||
56 | #define LABEL_SAVE "_Save" | ||
57 | #define LABEL_OPEN "_Open" | ||
58 | #define gtk_button_new_with_our_label gtk_button_new_with_mnemonic | ||
59 | #else | ||
60 | #define LABEL_OK GTK_STOCK_OK | ||
61 | #define LABEL_CANCEL GTK_STOCK_CANCEL | ||
62 | #define LABEL_NO GTK_STOCK_NO | ||
63 | #define LABEL_YES GTK_STOCK_YES | ||
64 | #define LABEL_SAVE GTK_STOCK_SAVE | ||
65 | #define LABEL_OPEN GTK_STOCK_OPEN | ||
66 | #define gtk_button_new_with_our_label gtk_button_new_from_stock | ||
67 | #endif | ||
68 | |||
69 | /* #undef USE_CAIRO */ | ||
70 | /* #define NO_THICK_LINE */ | ||
71 | #ifdef DEBUGGING | ||
72 | static FILE *debug_fp = NULL; | ||
73 | |||
74 | void dputs(char *buf) | ||
75 | { | ||
76 | if (!debug_fp) { | ||
77 | debug_fp = fopen("debug.log", "w"); | ||
78 | } | ||
79 | |||
80 | fputs(buf, stderr); | ||
81 | |||
82 | if (debug_fp) { | ||
83 | fputs(buf, debug_fp); | ||
84 | fflush(debug_fp); | ||
85 | } | ||
86 | } | ||
87 | |||
88 | void debug_printf(char *fmt, ...) | ||
89 | { | ||
90 | char buf[4096]; | ||
91 | va_list ap; | ||
92 | |||
93 | va_start(ap, fmt); | ||
94 | vsprintf(buf, fmt, ap); | ||
95 | dputs(buf); | ||
96 | va_end(ap); | ||
97 | } | ||
98 | #endif | ||
99 | |||
100 | /* ---------------------------------------------------------------------- | ||
101 | * Error reporting functions used elsewhere. | ||
102 | */ | ||
103 | |||
104 | void fatal(char *fmt, ...) | ||
105 | { | ||
106 | va_list ap; | ||
107 | |||
108 | fprintf(stderr, "fatal error: "); | ||
109 | |||
110 | va_start(ap, fmt); | ||
111 | vfprintf(stderr, fmt, ap); | ||
112 | va_end(ap); | ||
113 | |||
114 | fprintf(stderr, "\n"); | ||
115 | exit(1); | ||
116 | } | ||
117 | |||
118 | /* ---------------------------------------------------------------------- | ||
119 | * GTK front end to puzzles. | ||
120 | */ | ||
121 | |||
122 | static void changed_preset(frontend *fe); | ||
123 | |||
124 | struct font { | ||
125 | #ifdef USE_PANGO | ||
126 | PangoFontDescription *desc; | ||
127 | #else | ||
128 | GdkFont *font; | ||
129 | #endif | ||
130 | int type; | ||
131 | int size; | ||
132 | }; | ||
133 | |||
134 | /* | ||
135 | * This structure holds all the data relevant to a single window. | ||
136 | * In principle this would allow us to open multiple independent | ||
137 | * puzzle windows, although I can't currently see any real point in | ||
138 | * doing so. I'm just coding cleanly because there's no | ||
139 | * particularly good reason not to. | ||
140 | */ | ||
141 | struct frontend { | ||
142 | GtkWidget *window; | ||
143 | GtkAccelGroup *accelgroup; | ||
144 | GtkWidget *area; | ||
145 | GtkWidget *statusbar; | ||
146 | GtkWidget *menubar; | ||
147 | guint statusctx; | ||
148 | int w, h; | ||
149 | midend *me; | ||
150 | #ifdef USE_CAIRO | ||
151 | const float *colours; | ||
152 | cairo_t *cr; | ||
153 | cairo_surface_t *image; | ||
154 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
155 | GdkPixmap *pixmap; | ||
156 | #endif | ||
157 | GdkColor background; /* for painting outside puzzle area */ | ||
158 | #else | ||
159 | GdkPixmap *pixmap; | ||
160 | GdkGC *gc; | ||
161 | GdkColor *colours; | ||
162 | GdkColormap *colmap; | ||
163 | int backgroundindex; /* which of colours[] is background */ | ||
164 | #endif | ||
165 | int ncolours; | ||
166 | int bbox_l, bbox_r, bbox_u, bbox_d; | ||
167 | int timer_active, timer_id; | ||
168 | struct timeval last_time; | ||
169 | struct font *fonts; | ||
170 | int nfonts, fontsize; | ||
171 | config_item *cfg; | ||
172 | int cfg_which, cfgret; | ||
173 | GtkWidget *cfgbox; | ||
174 | void *paste_data; | ||
175 | int paste_data_len; | ||
176 | int pw, ph; /* pixmap size (w, h are area size) */ | ||
177 | int ox, oy; /* offset of pixmap in drawing area */ | ||
178 | #ifdef OLD_FILESEL | ||
179 | char *filesel_name; | ||
180 | #endif | ||
181 | GSList *preset_radio; | ||
182 | int n_preset_menu_items; | ||
183 | int preset_threaded; | ||
184 | GtkWidget *preset_custom; | ||
185 | GtkWidget *copy_menu_item; | ||
186 | #if !GTK_CHECK_VERSION(3,0,0) | ||
187 | int drawing_area_shrink_pending; | ||
188 | int menubar_is_local; | ||
189 | #endif | ||
190 | }; | ||
191 | |||
192 | struct blitter { | ||
193 | #ifdef USE_CAIRO | ||
194 | cairo_surface_t *image; | ||
195 | #else | ||
196 | GdkPixmap *pixmap; | ||
197 | #endif | ||
198 | int w, h, x, y; | ||
199 | }; | ||
200 | |||
201 | void get_random_seed(void **randseed, int *randseedsize) | ||
202 | { | ||
203 | struct timeval *tvp = snew(struct timeval); | ||
204 | gettimeofday(tvp, NULL); | ||
205 | *randseed = (void *)tvp; | ||
206 | *randseedsize = sizeof(struct timeval); | ||
207 | } | ||
208 | |||
209 | void frontend_default_colour(frontend *fe, float *output) | ||
210 | { | ||
211 | #if !GTK_CHECK_VERSION(3,0,0) | ||
212 | /* | ||
213 | * Use the widget style's default background colour as the | ||
214 | * background for the puzzle drawing area. | ||
215 | */ | ||
216 | GdkColor col = gtk_widget_get_style(fe->window)->bg[GTK_STATE_NORMAL]; | ||
217 | output[0] = col.red / 65535.0; | ||
218 | output[1] = col.green / 65535.0; | ||
219 | output[2] = col.blue / 65535.0; | ||
220 | #else | ||
221 | /* | ||
222 | * GTK 3 has decided that there's no such thing as a 'default | ||
223 | * background colour' any more, because widget styles might set | ||
224 | * the background to something more complicated like a background | ||
225 | * image. We don't want to get into overlaying our entire puzzle | ||
226 | * on an arbitrary background image, so we'll just make up a | ||
227 | * reasonable shade of grey. | ||
228 | */ | ||
229 | output[0] = output[1] = output[2] = 0.9F; | ||
230 | #endif | ||
231 | } | ||
232 | |||
233 | void gtk_status_bar(void *handle, char *text) | ||
234 | { | ||
235 | frontend *fe = (frontend *)handle; | ||
236 | |||
237 | assert(fe->statusbar); | ||
238 | |||
239 | gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx); | ||
240 | gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, text); | ||
241 | } | ||
242 | |||
243 | /* ---------------------------------------------------------------------- | ||
244 | * Cairo drawing functions. | ||
245 | */ | ||
246 | |||
247 | #ifdef USE_CAIRO | ||
248 | |||
249 | static void setup_drawing(frontend *fe) | ||
250 | { | ||
251 | fe->cr = cairo_create(fe->image); | ||
252 | cairo_set_antialias(fe->cr, CAIRO_ANTIALIAS_GRAY); | ||
253 | cairo_set_line_width(fe->cr, 1.0); | ||
254 | cairo_set_line_cap(fe->cr, CAIRO_LINE_CAP_SQUARE); | ||
255 | cairo_set_line_join(fe->cr, CAIRO_LINE_JOIN_ROUND); | ||
256 | } | ||
257 | |||
258 | static void teardown_drawing(frontend *fe) | ||
259 | { | ||
260 | cairo_destroy(fe->cr); | ||
261 | fe->cr = NULL; | ||
262 | |||
263 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
264 | { | ||
265 | cairo_t *cr = gdk_cairo_create(fe->pixmap); | ||
266 | cairo_set_source_surface(cr, fe->image, 0, 0); | ||
267 | cairo_rectangle(cr, | ||
268 | fe->bbox_l - 1, | ||
269 | fe->bbox_u - 1, | ||
270 | fe->bbox_r - fe->bbox_l + 2, | ||
271 | fe->bbox_d - fe->bbox_u + 2); | ||
272 | cairo_fill(cr); | ||
273 | cairo_destroy(cr); | ||
274 | } | ||
275 | #endif | ||
276 | } | ||
277 | |||
278 | static void snaffle_colours(frontend *fe) | ||
279 | { | ||
280 | fe->colours = midend_colours(fe->me, &fe->ncolours); | ||
281 | } | ||
282 | |||
283 | static void set_colour(frontend *fe, int colour) | ||
284 | { | ||
285 | cairo_set_source_rgb(fe->cr, | ||
286 | fe->colours[3*colour + 0], | ||
287 | fe->colours[3*colour + 1], | ||
288 | fe->colours[3*colour + 2]); | ||
289 | } | ||
290 | |||
291 | static void set_window_background(frontend *fe, int colour) | ||
292 | { | ||
293 | #if GTK_CHECK_VERSION(3,0,0) | ||
294 | GdkRGBA rgba; | ||
295 | rgba.red = fe->colours[3*colour + 0]; | ||
296 | rgba.green = fe->colours[3*colour + 1]; | ||
297 | rgba.blue = fe->colours[3*colour + 2]; | ||
298 | rgba.alpha = 1.0; | ||
299 | gdk_window_set_background_rgba(gtk_widget_get_window(fe->area), &rgba); | ||
300 | gdk_window_set_background_rgba(gtk_widget_get_window(fe->window), &rgba); | ||
301 | #else | ||
302 | GdkColormap *colmap; | ||
303 | |||
304 | colmap = gdk_colormap_get_system(); | ||
305 | fe->background.red = fe->colours[3*colour + 0] * 65535; | ||
306 | fe->background.green = fe->colours[3*colour + 1] * 65535; | ||
307 | fe->background.blue = fe->colours[3*colour + 2] * 65535; | ||
308 | if (!gdk_colormap_alloc_color(colmap, &fe->background, FALSE, FALSE)) { | ||
309 | g_error("couldn't allocate background (#%02x%02x%02x)\n", | ||
310 | fe->background.red >> 8, fe->background.green >> 8, | ||
311 | fe->background.blue >> 8); | ||
312 | } | ||
313 | gdk_window_set_background(gtk_widget_get_window(fe->area), | ||
314 | &fe->background); | ||
315 | gdk_window_set_background(gtk_widget_get_window(fe->window), | ||
316 | &fe->background); | ||
317 | #endif | ||
318 | } | ||
319 | |||
320 | static PangoLayout *make_pango_layout(frontend *fe) | ||
321 | { | ||
322 | return (pango_cairo_create_layout(fe->cr)); | ||
323 | } | ||
324 | |||
325 | static void draw_pango_layout(frontend *fe, PangoLayout *layout, | ||
326 | int x, int y) | ||
327 | { | ||
328 | cairo_move_to(fe->cr, x, y); | ||
329 | pango_cairo_show_layout(fe->cr, layout); | ||
330 | } | ||
331 | |||
332 | static void save_screenshot_png(frontend *fe, const char *screenshot_file) | ||
333 | { | ||
334 | cairo_surface_write_to_png(fe->image, screenshot_file); | ||
335 | } | ||
336 | |||
337 | static void do_clip(frontend *fe, int x, int y, int w, int h) | ||
338 | { | ||
339 | cairo_new_path(fe->cr); | ||
340 | cairo_rectangle(fe->cr, x, y, w, h); | ||
341 | cairo_clip(fe->cr); | ||
342 | } | ||
343 | |||
344 | static void do_unclip(frontend *fe) | ||
345 | { | ||
346 | cairo_reset_clip(fe->cr); | ||
347 | } | ||
348 | |||
349 | static void do_draw_rect(frontend *fe, int x, int y, int w, int h) | ||
350 | { | ||
351 | cairo_save(fe->cr); | ||
352 | cairo_new_path(fe->cr); | ||
353 | cairo_set_antialias(fe->cr, CAIRO_ANTIALIAS_NONE); | ||
354 | cairo_rectangle(fe->cr, x, y, w, h); | ||
355 | cairo_fill(fe->cr); | ||
356 | cairo_restore(fe->cr); | ||
357 | } | ||
358 | |||
359 | static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2) | ||
360 | { | ||
361 | cairo_new_path(fe->cr); | ||
362 | cairo_move_to(fe->cr, x1 + 0.5, y1 + 0.5); | ||
363 | cairo_line_to(fe->cr, x2 + 0.5, y2 + 0.5); | ||
364 | cairo_stroke(fe->cr); | ||
365 | } | ||
366 | |||
367 | static void do_draw_thick_line(frontend *fe, float thickness, | ||
368 | float x1, float y1, float x2, float y2) | ||
369 | { | ||
370 | cairo_save(fe->cr); | ||
371 | cairo_set_line_width(fe->cr, thickness); | ||
372 | cairo_new_path(fe->cr); | ||
373 | cairo_move_to(fe->cr, x1, y1); | ||
374 | cairo_line_to(fe->cr, x2, y2); | ||
375 | cairo_stroke(fe->cr); | ||
376 | cairo_restore(fe->cr); | ||
377 | } | ||
378 | |||
379 | static void do_draw_poly(frontend *fe, int *coords, int npoints, | ||
380 | int fillcolour, int outlinecolour) | ||
381 | { | ||
382 | int i; | ||
383 | |||
384 | cairo_new_path(fe->cr); | ||
385 | for (i = 0; i < npoints; i++) | ||
386 | cairo_line_to(fe->cr, coords[i*2] + 0.5, coords[i*2 + 1] + 0.5); | ||
387 | cairo_close_path(fe->cr); | ||
388 | if (fillcolour >= 0) { | ||
389 | set_colour(fe, fillcolour); | ||
390 | cairo_fill_preserve(fe->cr); | ||
391 | } | ||
392 | assert(outlinecolour >= 0); | ||
393 | set_colour(fe, outlinecolour); | ||
394 | cairo_stroke(fe->cr); | ||
395 | } | ||
396 | |||
397 | static void do_draw_circle(frontend *fe, int cx, int cy, int radius, | ||
398 | int fillcolour, int outlinecolour) | ||
399 | { | ||
400 | cairo_new_path(fe->cr); | ||
401 | cairo_arc(fe->cr, cx + 0.5, cy + 0.5, radius, 0, 2*PI); | ||
402 | cairo_close_path(fe->cr); /* Just in case... */ | ||
403 | if (fillcolour >= 0) { | ||
404 | set_colour(fe, fillcolour); | ||
405 | cairo_fill_preserve(fe->cr); | ||
406 | } | ||
407 | assert(outlinecolour >= 0); | ||
408 | set_colour(fe, outlinecolour); | ||
409 | cairo_stroke(fe->cr); | ||
410 | } | ||
411 | |||
412 | static void setup_blitter(blitter *bl, int w, int h) | ||
413 | { | ||
414 | bl->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, w, h); | ||
415 | } | ||
416 | |||
417 | static void teardown_blitter(blitter *bl) | ||
418 | { | ||
419 | cairo_surface_destroy(bl->image); | ||
420 | } | ||
421 | |||
422 | static void do_blitter_save(frontend *fe, blitter *bl, int x, int y) | ||
423 | { | ||
424 | cairo_t *cr = cairo_create(bl->image); | ||
425 | |||
426 | cairo_set_source_surface(cr, fe->image, -x, -y); | ||
427 | cairo_paint(cr); | ||
428 | cairo_destroy(cr); | ||
429 | } | ||
430 | |||
431 | static void do_blitter_load(frontend *fe, blitter *bl, int x, int y) | ||
432 | { | ||
433 | cairo_set_source_surface(fe->cr, bl->image, x, y); | ||
434 | cairo_paint(fe->cr); | ||
435 | } | ||
436 | |||
437 | static void clear_backing_store(frontend *fe) | ||
438 | { | ||
439 | fe->image = NULL; | ||
440 | } | ||
441 | |||
442 | static void wipe_and_destroy_cairo(frontend *fe, cairo_t *cr) | ||
443 | { | ||
444 | cairo_set_source_rgb(cr, fe->colours[0], fe->colours[1], fe->colours[2]); | ||
445 | cairo_paint(cr); | ||
446 | cairo_destroy(cr); | ||
447 | } | ||
448 | |||
449 | static void setup_backing_store(frontend *fe) | ||
450 | { | ||
451 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
452 | fe->pixmap = gdk_pixmap_new(gtk_widget_get_window(fe->area), | ||
453 | fe->pw, fe->ph, -1); | ||
454 | #endif | ||
455 | fe->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, | ||
456 | fe->pw, fe->ph); | ||
457 | |||
458 | wipe_and_destroy_cairo(fe, cairo_create(fe->image)); | ||
459 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
460 | wipe_and_destroy_cairo(fe, gdk_cairo_create(fe->pixmap)); | ||
461 | #endif | ||
462 | wipe_and_destroy_cairo(fe, gdk_cairo_create | ||
463 | (gtk_widget_get_window(fe->area))); | ||
464 | } | ||
465 | |||
466 | static int backing_store_ok(frontend *fe) | ||
467 | { | ||
468 | return (!!fe->image); | ||
469 | } | ||
470 | |||
471 | static void teardown_backing_store(frontend *fe) | ||
472 | { | ||
473 | cairo_surface_destroy(fe->image); | ||
474 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
475 | gdk_pixmap_unref(fe->pixmap); | ||
476 | #endif | ||
477 | fe->image = NULL; | ||
478 | } | ||
479 | |||
480 | #endif | ||
481 | |||
482 | /* ---------------------------------------------------------------------- | ||
483 | * GDK drawing functions. | ||
484 | */ | ||
485 | |||
486 | #ifndef USE_CAIRO | ||
487 | |||
488 | static void setup_drawing(frontend *fe) | ||
489 | { | ||
490 | fe->gc = gdk_gc_new(fe->area->window); | ||
491 | } | ||
492 | |||
493 | static void teardown_drawing(frontend *fe) | ||
494 | { | ||
495 | gdk_gc_unref(fe->gc); | ||
496 | fe->gc = NULL; | ||
497 | } | ||
498 | |||
499 | static void snaffle_colours(frontend *fe) | ||
500 | { | ||
501 | int i, ncolours; | ||
502 | float *colours; | ||
503 | gboolean *success; | ||
504 | |||
505 | fe->colmap = gdk_colormap_get_system(); | ||
506 | colours = midend_colours(fe->me, &ncolours); | ||
507 | fe->ncolours = ncolours; | ||
508 | fe->colours = snewn(ncolours, GdkColor); | ||
509 | for (i = 0; i < ncolours; i++) { | ||
510 | fe->colours[i].red = colours[i*3] * 0xFFFF; | ||
511 | fe->colours[i].green = colours[i*3+1] * 0xFFFF; | ||
512 | fe->colours[i].blue = colours[i*3+2] * 0xFFFF; | ||
513 | } | ||
514 | success = snewn(ncolours, gboolean); | ||
515 | gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours, | ||
516 | FALSE, FALSE, success); | ||
517 | for (i = 0; i < ncolours; i++) { | ||
518 | if (!success[i]) { | ||
519 | g_error("couldn't allocate colour %d (#%02x%02x%02x)\n", | ||
520 | i, fe->colours[i].red >> 8, | ||
521 | fe->colours[i].green >> 8, | ||
522 | fe->colours[i].blue >> 8); | ||
523 | } | ||
524 | } | ||
525 | } | ||
526 | |||
527 | static void set_window_background(frontend *fe, int colour) | ||
528 | { | ||
529 | fe->backgroundindex = colour; | ||
530 | gdk_window_set_background(fe->area->window, &fe->colours[colour]); | ||
531 | gdk_window_set_background(fe->window->window, &fe->colours[colour]); | ||
532 | } | ||
533 | |||
534 | static void set_colour(frontend *fe, int colour) | ||
535 | { | ||
536 | gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); | ||
537 | } | ||
538 | |||
539 | #ifdef USE_PANGO | ||
540 | static PangoLayout *make_pango_layout(frontend *fe) | ||
541 | { | ||
542 | return (pango_layout_new(gtk_widget_get_pango_context(fe->area))); | ||
543 | } | ||
544 | |||
545 | static void draw_pango_layout(frontend *fe, PangoLayout *layout, | ||
546 | int x, int y) | ||
547 | { | ||
548 | gdk_draw_layout(fe->pixmap, fe->gc, x, y, layout); | ||
549 | } | ||
550 | #endif | ||
551 | |||
552 | static void save_screenshot_png(frontend *fe, const char *screenshot_file) | ||
553 | { | ||
554 | GdkPixbuf *pb; | ||
555 | GError *gerror = NULL; | ||
556 | |||
557 | midend_redraw(fe->me); | ||
558 | |||
559 | pb = gdk_pixbuf_get_from_drawable(NULL, fe->pixmap, | ||
560 | NULL, 0, 0, 0, 0, -1, -1); | ||
561 | gdk_pixbuf_save(pb, screenshot_file, "png", &gerror, NULL); | ||
562 | } | ||
563 | |||
564 | static void do_clip(frontend *fe, int x, int y, int w, int h) | ||
565 | { | ||
566 | GdkRectangle rect; | ||
567 | |||
568 | rect.x = x; | ||
569 | rect.y = y; | ||
570 | rect.width = w; | ||
571 | rect.height = h; | ||
572 | gdk_gc_set_clip_rectangle(fe->gc, &rect); | ||
573 | } | ||
574 | |||
575 | static void do_unclip(frontend *fe) | ||
576 | { | ||
577 | GdkRectangle rect; | ||
578 | |||
579 | rect.x = 0; | ||
580 | rect.y = 0; | ||
581 | rect.width = fe->w; | ||
582 | rect.height = fe->h; | ||
583 | gdk_gc_set_clip_rectangle(fe->gc, &rect); | ||
584 | } | ||
585 | |||
586 | static void do_draw_rect(frontend *fe, int x, int y, int w, int h) | ||
587 | { | ||
588 | gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h); | ||
589 | } | ||
590 | |||
591 | static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2) | ||
592 | { | ||
593 | gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2); | ||
594 | } | ||
595 | |||
596 | static void do_draw_thick_line(frontend *fe, float thickness, | ||
597 | float x1, float y1, float x2, float y2) | ||
598 | { | ||
599 | GdkGCValues save; | ||
600 | |||
601 | gdk_gc_get_values(fe->gc, &save); | ||
602 | gdk_gc_set_line_attributes(fe->gc, | ||
603 | thickness, | ||
604 | GDK_LINE_SOLID, | ||
605 | GDK_CAP_BUTT, | ||
606 | GDK_JOIN_BEVEL); | ||
607 | gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2); | ||
608 | gdk_gc_set_line_attributes(fe->gc, | ||
609 | save.line_width, | ||
610 | save.line_style, | ||
611 | save.cap_style, | ||
612 | save.join_style); | ||
613 | } | ||
614 | |||
615 | static void do_draw_poly(frontend *fe, int *coords, int npoints, | ||
616 | int fillcolour, int outlinecolour) | ||
617 | { | ||
618 | GdkPoint *points = snewn(npoints, GdkPoint); | ||
619 | int i; | ||
620 | |||
621 | for (i = 0; i < npoints; i++) { | ||
622 | points[i].x = coords[i*2]; | ||
623 | points[i].y = coords[i*2+1]; | ||
624 | } | ||
625 | |||
626 | if (fillcolour >= 0) { | ||
627 | set_colour(fe, fillcolour); | ||
628 | gdk_draw_polygon(fe->pixmap, fe->gc, TRUE, points, npoints); | ||
629 | } | ||
630 | assert(outlinecolour >= 0); | ||
631 | set_colour(fe, outlinecolour); | ||
632 | |||
633 | /* | ||
634 | * In principle we ought to be able to use gdk_draw_polygon for | ||
635 | * the outline as well. In fact, it turns out to interact badly | ||
636 | * with a clipping region, for no terribly obvious reason, so I | ||
637 | * draw the outline as a sequence of lines instead. | ||
638 | */ | ||
639 | for (i = 0; i < npoints; i++) | ||
640 | gdk_draw_line(fe->pixmap, fe->gc, | ||
641 | points[i].x, points[i].y, | ||
642 | points[(i+1)%npoints].x, points[(i+1)%npoints].y); | ||
643 | |||
644 | sfree(points); | ||
645 | } | ||
646 | |||
647 | static void do_draw_circle(frontend *fe, int cx, int cy, int radius, | ||
648 | int fillcolour, int outlinecolour) | ||
649 | { | ||
650 | if (fillcolour >= 0) { | ||
651 | set_colour(fe, fillcolour); | ||
652 | gdk_draw_arc(fe->pixmap, fe->gc, TRUE, | ||
653 | cx - radius, cy - radius, | ||
654 | 2 * radius, 2 * radius, 0, 360 * 64); | ||
655 | } | ||
656 | |||
657 | assert(outlinecolour >= 0); | ||
658 | set_colour(fe, outlinecolour); | ||
659 | gdk_draw_arc(fe->pixmap, fe->gc, FALSE, | ||
660 | cx - radius, cy - radius, | ||
661 | 2 * radius, 2 * radius, 0, 360 * 64); | ||
662 | } | ||
663 | |||
664 | static void setup_blitter(blitter *bl, int w, int h) | ||
665 | { | ||
666 | /* | ||
667 | * We can't create the pixmap right now, because fe->window | ||
668 | * might not yet exist. So we just cache w and h and create it | ||
669 | * during the firs call to blitter_save. | ||
670 | */ | ||
671 | bl->pixmap = NULL; | ||
672 | } | ||
673 | |||
674 | static void teardown_blitter(blitter *bl) | ||
675 | { | ||
676 | if (bl->pixmap) | ||
677 | gdk_pixmap_unref(bl->pixmap); | ||
678 | } | ||
679 | |||
680 | static void do_blitter_save(frontend *fe, blitter *bl, int x, int y) | ||
681 | { | ||
682 | if (!bl->pixmap) | ||
683 | bl->pixmap = gdk_pixmap_new(fe->area->window, bl->w, bl->h, -1); | ||
684 | gdk_draw_pixmap(bl->pixmap, | ||
685 | fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], | ||
686 | fe->pixmap, | ||
687 | x, y, 0, 0, bl->w, bl->h); | ||
688 | } | ||
689 | |||
690 | static void do_blitter_load(frontend *fe, blitter *bl, int x, int y) | ||
691 | { | ||
692 | assert(bl->pixmap); | ||
693 | gdk_draw_pixmap(fe->pixmap, | ||
694 | fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], | ||
695 | bl->pixmap, | ||
696 | 0, 0, x, y, bl->w, bl->h); | ||
697 | } | ||
698 | |||
699 | static void clear_backing_store(frontend *fe) | ||
700 | { | ||
701 | fe->pixmap = NULL; | ||
702 | } | ||
703 | |||
704 | static void setup_backing_store(frontend *fe) | ||
705 | { | ||
706 | GdkGC *gc; | ||
707 | |||
708 | fe->pixmap = gdk_pixmap_new(fe->area->window, fe->pw, fe->ph, -1); | ||
709 | |||
710 | gc = gdk_gc_new(fe->area->window); | ||
711 | gdk_gc_set_foreground(gc, &fe->colours[0]); | ||
712 | gdk_draw_rectangle(fe->pixmap, gc, 1, 0, 0, fe->pw, fe->ph); | ||
713 | gdk_draw_rectangle(fe->area->window, gc, 1, 0, 0, fe->w, fe->h); | ||
714 | gdk_gc_unref(gc); | ||
715 | } | ||
716 | |||
717 | static int backing_store_ok(frontend *fe) | ||
718 | { | ||
719 | return (!!fe->pixmap); | ||
720 | } | ||
721 | |||
722 | static void teardown_backing_store(frontend *fe) | ||
723 | { | ||
724 | gdk_pixmap_unref(fe->pixmap); | ||
725 | fe->pixmap = NULL; | ||
726 | } | ||
727 | |||
728 | #endif | ||
729 | |||
730 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
731 | static void repaint_rectangle(frontend *fe, GtkWidget *widget, | ||
732 | int x, int y, int w, int h) | ||
733 | { | ||
734 | GdkGC *gc = gdk_gc_new(gtk_widget_get_window(widget)); | ||
735 | #ifdef USE_CAIRO | ||
736 | gdk_gc_set_foreground(gc, &fe->background); | ||
737 | #else | ||
738 | gdk_gc_set_foreground(gc, &fe->colours[fe->backgroundindex]); | ||
739 | #endif | ||
740 | if (x < fe->ox) { | ||
741 | gdk_draw_rectangle(gtk_widget_get_window(widget), gc, | ||
742 | TRUE, x, y, fe->ox - x, h); | ||
743 | w -= (fe->ox - x); | ||
744 | x = fe->ox; | ||
745 | } | ||
746 | if (y < fe->oy) { | ||
747 | gdk_draw_rectangle(gtk_widget_get_window(widget), gc, | ||
748 | TRUE, x, y, w, fe->oy - y); | ||
749 | h -= (fe->oy - y); | ||
750 | y = fe->oy; | ||
751 | } | ||
752 | if (w > fe->pw) { | ||
753 | gdk_draw_rectangle(gtk_widget_get_window(widget), gc, | ||
754 | TRUE, x + fe->pw, y, w - fe->pw, h); | ||
755 | w = fe->pw; | ||
756 | } | ||
757 | if (h > fe->ph) { | ||
758 | gdk_draw_rectangle(gtk_widget_get_window(widget), gc, | ||
759 | TRUE, x, y + fe->ph, w, h - fe->ph); | ||
760 | h = fe->ph; | ||
761 | } | ||
762 | gdk_draw_pixmap(gtk_widget_get_window(widget), gc, fe->pixmap, | ||
763 | x - fe->ox, y - fe->oy, x, y, w, h); | ||
764 | gdk_gc_unref(gc); | ||
765 | } | ||
766 | #endif | ||
767 | |||
768 | /* ---------------------------------------------------------------------- | ||
769 | * Pango font functions. | ||
770 | */ | ||
771 | |||
772 | #ifdef USE_PANGO | ||
773 | |||
774 | static void add_font(frontend *fe, int index, int fonttype, int fontsize) | ||
775 | { | ||
776 | /* | ||
777 | * Use Pango to find the closest match to the requested | ||
778 | * font. | ||
779 | */ | ||
780 | PangoFontDescription *fd; | ||
781 | |||
782 | fd = pango_font_description_new(); | ||
783 | /* `Monospace' and `Sans' are meta-families guaranteed to exist */ | ||
784 | pango_font_description_set_family(fd, fonttype == FONT_FIXED ? | ||
785 | "Monospace" : "Sans"); | ||
786 | pango_font_description_set_weight(fd, PANGO_WEIGHT_BOLD); | ||
787 | /* | ||
788 | * I found some online Pango documentation which | ||
789 | * described a function called | ||
790 | * pango_font_description_set_absolute_size(), which is | ||
791 | * _exactly_ what I want here. Unfortunately, none of | ||
792 | * my local Pango installations have it (presumably | ||
793 | * they're too old), so I'm going to have to hack round | ||
794 | * it by figuring out the point size myself. This | ||
795 | * limits me to X and probably also breaks in later | ||
796 | * Pango installations, so ideally I should add another | ||
797 | * CHECK_VERSION type ifdef and use set_absolute_size | ||
798 | * where available. All very annoying. | ||
799 | */ | ||
800 | #ifdef HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION | ||
801 | pango_font_description_set_absolute_size(fd, PANGO_SCALE*fontsize); | ||
802 | #else | ||
803 | { | ||
804 | Display *d = GDK_DISPLAY(); | ||
805 | int s = DefaultScreen(d); | ||
806 | double resolution = | ||
807 | (PANGO_SCALE * 72.27 / 25.4) * | ||
808 | ((double) DisplayWidthMM(d, s) / DisplayWidth (d, s)); | ||
809 | pango_font_description_set_size(fd, resolution * fontsize); | ||
810 | } | ||
811 | #endif | ||
812 | fe->fonts[index].desc = fd; | ||
813 | } | ||
814 | |||
815 | static void align_and_draw_text(frontend *fe, | ||
816 | int index, int align, int x, int y, | ||
817 | const char *text) | ||
818 | { | ||
819 | PangoLayout *layout; | ||
820 | PangoRectangle rect; | ||
821 | |||
822 | layout = make_pango_layout(fe); | ||
823 | |||
824 | /* | ||
825 | * Create a layout. | ||
826 | */ | ||
827 | pango_layout_set_font_description(layout, fe->fonts[index].desc); | ||
828 | pango_layout_set_text(layout, text, strlen(text)); | ||
829 | pango_layout_get_pixel_extents(layout, NULL, &rect); | ||
830 | |||
831 | if (align & ALIGN_VCENTRE) | ||
832 | rect.y -= rect.height / 2; | ||
833 | else | ||
834 | rect.y -= rect.height; | ||
835 | |||
836 | if (align & ALIGN_HCENTRE) | ||
837 | rect.x -= rect.width / 2; | ||
838 | else if (align & ALIGN_HRIGHT) | ||
839 | rect.x -= rect.width; | ||
840 | |||
841 | draw_pango_layout(fe, layout, rect.x + x, rect.y + y); | ||
842 | |||
843 | g_object_unref(layout); | ||
844 | } | ||
845 | |||
846 | #endif | ||
847 | |||
848 | /* ---------------------------------------------------------------------- | ||
849 | * Old-fashioned font functions. | ||
850 | */ | ||
851 | |||
852 | #ifndef USE_PANGO | ||
853 | |||
854 | static void add_font(int index, int fonttype, int fontsize) | ||
855 | { | ||
856 | /* | ||
857 | * In GTK 1.2, I don't know of any plausible way to | ||
858 | * pick a suitable font, so I'm just going to be | ||
859 | * tedious. | ||
860 | */ | ||
861 | fe->fonts[i].font = gdk_font_load(fonttype == FONT_FIXED ? | ||
862 | "fixed" : "variable"); | ||
863 | } | ||
864 | |||
865 | static void align_and_draw_text(int index, int align, int x, int y, | ||
866 | const char *text) | ||
867 | { | ||
868 | int lb, rb, wid, asc, desc; | ||
869 | |||
870 | /* | ||
871 | * Measure vertical string extents with respect to the same | ||
872 | * string always... | ||
873 | */ | ||
874 | gdk_string_extents(fe->fonts[i].font, | ||
875 | "ABCDEFGHIJKLMNOPQRSTUVWXYZ", | ||
876 | &lb, &rb, &wid, &asc, &desc); | ||
877 | if (align & ALIGN_VCENTRE) | ||
878 | y += asc - (asc+desc)/2; | ||
879 | else | ||
880 | y += asc; | ||
881 | |||
882 | /* | ||
883 | * ... but horizontal extents with respect to the provided | ||
884 | * string. This means that multiple pieces of text centred | ||
885 | * on the same y-coordinate don't have different baselines. | ||
886 | */ | ||
887 | gdk_string_extents(fe->fonts[i].font, text, | ||
888 | &lb, &rb, &wid, &asc, &desc); | ||
889 | |||
890 | if (align & ALIGN_HCENTRE) | ||
891 | x -= wid / 2; | ||
892 | else if (align & ALIGN_HRIGHT) | ||
893 | x -= wid; | ||
894 | |||
895 | /* | ||
896 | * Actually draw the text. | ||
897 | */ | ||
898 | gdk_draw_string(fe->pixmap, fe->fonts[i].font, fe->gc, x, y, text); | ||
899 | } | ||
900 | |||
901 | #endif | ||
902 | |||
903 | /* ---------------------------------------------------------------------- | ||
904 | * The exported drawing functions. | ||
905 | */ | ||
906 | |||
907 | void gtk_start_draw(void *handle) | ||
908 | { | ||
909 | frontend *fe = (frontend *)handle; | ||
910 | fe->bbox_l = fe->w; | ||
911 | fe->bbox_r = 0; | ||
912 | fe->bbox_u = fe->h; | ||
913 | fe->bbox_d = 0; | ||
914 | setup_drawing(fe); | ||
915 | } | ||
916 | |||
917 | void gtk_clip(void *handle, int x, int y, int w, int h) | ||
918 | { | ||
919 | frontend *fe = (frontend *)handle; | ||
920 | do_clip(fe, x, y, w, h); | ||
921 | } | ||
922 | |||
923 | void gtk_unclip(void *handle) | ||
924 | { | ||
925 | frontend *fe = (frontend *)handle; | ||
926 | do_unclip(fe); | ||
927 | } | ||
928 | |||
929 | void gtk_draw_text(void *handle, int x, int y, int fonttype, int fontsize, | ||
930 | int align, int colour, char *text) | ||
931 | { | ||
932 | frontend *fe = (frontend *)handle; | ||
933 | int i; | ||
934 | |||
935 | /* | ||
936 | * Find or create the font. | ||
937 | */ | ||
938 | for (i = 0; i < fe->nfonts; i++) | ||
939 | if (fe->fonts[i].type == fonttype && fe->fonts[i].size == fontsize) | ||
940 | break; | ||
941 | |||
942 | if (i == fe->nfonts) { | ||
943 | if (fe->fontsize <= fe->nfonts) { | ||
944 | fe->fontsize = fe->nfonts + 10; | ||
945 | fe->fonts = sresize(fe->fonts, fe->fontsize, struct font); | ||
946 | } | ||
947 | |||
948 | fe->nfonts++; | ||
949 | |||
950 | fe->fonts[i].type = fonttype; | ||
951 | fe->fonts[i].size = fontsize; | ||
952 | add_font(fe, i, fonttype, fontsize); | ||
953 | } | ||
954 | |||
955 | /* | ||
956 | * Do the job. | ||
957 | */ | ||
958 | set_colour(fe, colour); | ||
959 | align_and_draw_text(fe, i, align, x, y, text); | ||
960 | } | ||
961 | |||
962 | void gtk_draw_rect(void *handle, int x, int y, int w, int h, int colour) | ||
963 | { | ||
964 | frontend *fe = (frontend *)handle; | ||
965 | set_colour(fe, colour); | ||
966 | do_draw_rect(fe, x, y, w, h); | ||
967 | } | ||
968 | |||
969 | void gtk_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour) | ||
970 | { | ||
971 | frontend *fe = (frontend *)handle; | ||
972 | set_colour(fe, colour); | ||
973 | do_draw_line(fe, x1, y1, x2, y2); | ||
974 | } | ||
975 | |||
976 | void gtk_draw_thick_line(void *handle, float thickness, | ||
977 | float x1, float y1, float x2, float y2, int colour) | ||
978 | { | ||
979 | frontend *fe = (frontend *)handle; | ||
980 | set_colour(fe, colour); | ||
981 | do_draw_thick_line(fe, thickness, x1, y1, x2, y2); | ||
982 | } | ||
983 | |||
984 | void gtk_draw_poly(void *handle, int *coords, int npoints, | ||
985 | int fillcolour, int outlinecolour) | ||
986 | { | ||
987 | frontend *fe = (frontend *)handle; | ||
988 | do_draw_poly(fe, coords, npoints, fillcolour, outlinecolour); | ||
989 | } | ||
990 | |||
991 | void gtk_draw_circle(void *handle, int cx, int cy, int radius, | ||
992 | int fillcolour, int outlinecolour) | ||
993 | { | ||
994 | frontend *fe = (frontend *)handle; | ||
995 | do_draw_circle(fe, cx, cy, radius, fillcolour, outlinecolour); | ||
996 | } | ||
997 | |||
998 | blitter *gtk_blitter_new(void *handle, int w, int h) | ||
999 | { | ||
1000 | blitter *bl = snew(blitter); | ||
1001 | setup_blitter(bl, w, h); | ||
1002 | bl->w = w; | ||
1003 | bl->h = h; | ||
1004 | return bl; | ||
1005 | } | ||
1006 | |||
1007 | void gtk_blitter_free(void *handle, blitter *bl) | ||
1008 | { | ||
1009 | teardown_blitter(bl); | ||
1010 | sfree(bl); | ||
1011 | } | ||
1012 | |||
1013 | void gtk_blitter_save(void *handle, blitter *bl, int x, int y) | ||
1014 | { | ||
1015 | frontend *fe = (frontend *)handle; | ||
1016 | do_blitter_save(fe, bl, x, y); | ||
1017 | bl->x = x; | ||
1018 | bl->y = y; | ||
1019 | } | ||
1020 | |||
1021 | void gtk_blitter_load(void *handle, blitter *bl, int x, int y) | ||
1022 | { | ||
1023 | frontend *fe = (frontend *)handle; | ||
1024 | if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) { | ||
1025 | x = bl->x; | ||
1026 | y = bl->y; | ||
1027 | } | ||
1028 | do_blitter_load(fe, bl, x, y); | ||
1029 | } | ||
1030 | |||
1031 | void gtk_draw_update(void *handle, int x, int y, int w, int h) | ||
1032 | { | ||
1033 | frontend *fe = (frontend *)handle; | ||
1034 | if (fe->bbox_l > x ) fe->bbox_l = x ; | ||
1035 | if (fe->bbox_r < x+w) fe->bbox_r = x+w; | ||
1036 | if (fe->bbox_u > y ) fe->bbox_u = y ; | ||
1037 | if (fe->bbox_d < y+h) fe->bbox_d = y+h; | ||
1038 | } | ||
1039 | |||
1040 | void gtk_end_draw(void *handle) | ||
1041 | { | ||
1042 | frontend *fe = (frontend *)handle; | ||
1043 | |||
1044 | teardown_drawing(fe); | ||
1045 | |||
1046 | if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d) { | ||
1047 | #ifdef USE_CAIRO_WITHOUT_PIXMAP | ||
1048 | gtk_widget_queue_draw_area(fe->area, | ||
1049 | fe->bbox_l - 1 + fe->ox, | ||
1050 | fe->bbox_u - 1 + fe->oy, | ||
1051 | fe->bbox_r - fe->bbox_l + 2, | ||
1052 | fe->bbox_d - fe->bbox_u + 2); | ||
1053 | #else | ||
1054 | repaint_rectangle(fe, fe->area, | ||
1055 | fe->bbox_l - 1 + fe->ox, | ||
1056 | fe->bbox_u - 1 + fe->oy, | ||
1057 | fe->bbox_r - fe->bbox_l + 2, | ||
1058 | fe->bbox_d - fe->bbox_u + 2); | ||
1059 | #endif | ||
1060 | } | ||
1061 | } | ||
1062 | |||
1063 | #ifdef USE_PANGO | ||
1064 | char *gtk_text_fallback(void *handle, const char *const *strings, int nstrings) | ||
1065 | { | ||
1066 | /* | ||
1067 | * We assume Pango can cope with any UTF-8 likely to be emitted | ||
1068 | * by a puzzle. | ||
1069 | */ | ||
1070 | return dupstr(strings[0]); | ||
1071 | } | ||
1072 | #endif | ||
1073 | |||
1074 | const struct drawing_api gtk_drawing = { | ||
1075 | gtk_draw_text, | ||
1076 | gtk_draw_rect, | ||
1077 | gtk_draw_line, | ||
1078 | gtk_draw_poly, | ||
1079 | gtk_draw_circle, | ||
1080 | gtk_draw_update, | ||
1081 | gtk_clip, | ||
1082 | gtk_unclip, | ||
1083 | gtk_start_draw, | ||
1084 | gtk_end_draw, | ||
1085 | gtk_status_bar, | ||
1086 | gtk_blitter_new, | ||
1087 | gtk_blitter_free, | ||
1088 | gtk_blitter_save, | ||
1089 | gtk_blitter_load, | ||
1090 | NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */ | ||
1091 | NULL, NULL, /* line_width, line_dotted */ | ||
1092 | #ifdef USE_PANGO | ||
1093 | gtk_text_fallback, | ||
1094 | #else | ||
1095 | NULL, | ||
1096 | #endif | ||
1097 | #ifdef NO_THICK_LINE | ||
1098 | NULL, | ||
1099 | #else | ||
1100 | gtk_draw_thick_line, | ||
1101 | #endif | ||
1102 | }; | ||
1103 | |||
1104 | static void destroy(GtkWidget *widget, gpointer data) | ||
1105 | { | ||
1106 | frontend *fe = (frontend *)data; | ||
1107 | deactivate_timer(fe); | ||
1108 | midend_free(fe->me); | ||
1109 | gtk_main_quit(); | ||
1110 | } | ||
1111 | |||
1112 | static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data) | ||
1113 | { | ||
1114 | frontend *fe = (frontend *)data; | ||
1115 | int keyval; | ||
1116 | int shift = (event->state & GDK_SHIFT_MASK) ? MOD_SHFT : 0; | ||
1117 | int ctrl = (event->state & GDK_CONTROL_MASK) ? MOD_CTRL : 0; | ||
1118 | |||
1119 | if (!backing_store_ok(fe)) | ||
1120 | return TRUE; | ||
1121 | |||
1122 | #if !GTK_CHECK_VERSION(2,0,0) | ||
1123 | /* Gtk 1.2 passes a key event to this function even if it's also | ||
1124 | * defined as an accelerator. | ||
1125 | * Gtk 2 doesn't do this, and this function appears not to exist there. */ | ||
1126 | if (fe->accelgroup && | ||
1127 | gtk_accel_group_get_entry(fe->accelgroup, | ||
1128 | event->keyval, event->state)) | ||
1129 | return TRUE; | ||
1130 | #endif | ||
1131 | |||
1132 | /* Handle mnemonics. */ | ||
1133 | if (gtk_window_activate_key(GTK_WINDOW(fe->window), event)) | ||
1134 | return TRUE; | ||
1135 | |||
1136 | if (event->keyval == GDK_KEY_Up) | ||
1137 | keyval = shift | ctrl | CURSOR_UP; | ||
1138 | else if (event->keyval == GDK_KEY_KP_Up || | ||
1139 | event->keyval == GDK_KEY_KP_8) | ||
1140 | keyval = MOD_NUM_KEYPAD | '8'; | ||
1141 | else if (event->keyval == GDK_KEY_Down) | ||
1142 | keyval = shift | ctrl | CURSOR_DOWN; | ||
1143 | else if (event->keyval == GDK_KEY_KP_Down || | ||
1144 | event->keyval == GDK_KEY_KP_2) | ||
1145 | keyval = MOD_NUM_KEYPAD | '2'; | ||
1146 | else if (event->keyval == GDK_KEY_Left) | ||
1147 | keyval = shift | ctrl | CURSOR_LEFT; | ||
1148 | else if (event->keyval == GDK_KEY_KP_Left || | ||
1149 | event->keyval == GDK_KEY_KP_4) | ||
1150 | keyval = MOD_NUM_KEYPAD | '4'; | ||
1151 | else if (event->keyval == GDK_KEY_Right) | ||
1152 | keyval = shift | ctrl | CURSOR_RIGHT; | ||
1153 | else if (event->keyval == GDK_KEY_KP_Right || | ||
1154 | event->keyval == GDK_KEY_KP_6) | ||
1155 | keyval = MOD_NUM_KEYPAD | '6'; | ||
1156 | else if (event->keyval == GDK_KEY_KP_Home || | ||
1157 | event->keyval == GDK_KEY_KP_7) | ||
1158 | keyval = MOD_NUM_KEYPAD | '7'; | ||
1159 | else if (event->keyval == GDK_KEY_KP_End || | ||
1160 | event->keyval == GDK_KEY_KP_1) | ||
1161 | keyval = MOD_NUM_KEYPAD | '1'; | ||
1162 | else if (event->keyval == GDK_KEY_KP_Page_Up || | ||
1163 | event->keyval == GDK_KEY_KP_9) | ||
1164 | keyval = MOD_NUM_KEYPAD | '9'; | ||
1165 | else if (event->keyval == GDK_KEY_KP_Page_Down || | ||
1166 | event->keyval == GDK_KEY_KP_3) | ||
1167 | keyval = MOD_NUM_KEYPAD | '3'; | ||
1168 | else if (event->keyval == GDK_KEY_KP_Insert || | ||
1169 | event->keyval == GDK_KEY_KP_0) | ||
1170 | keyval = MOD_NUM_KEYPAD | '0'; | ||
1171 | else if (event->keyval == GDK_KEY_KP_Begin || | ||
1172 | event->keyval == GDK_KEY_KP_5) | ||
1173 | keyval = MOD_NUM_KEYPAD | '5'; | ||
1174 | else if (event->keyval == GDK_KEY_BackSpace || | ||
1175 | event->keyval == GDK_KEY_Delete || | ||
1176 | event->keyval == GDK_KEY_KP_Delete) | ||
1177 | keyval = '\177'; | ||
1178 | else if (event->string[0] && !event->string[1]) | ||
1179 | keyval = (unsigned char)event->string[0]; | ||
1180 | else | ||
1181 | keyval = -1; | ||
1182 | |||
1183 | if (keyval >= 0 && | ||
1184 | !midend_process_key(fe->me, 0, 0, keyval)) | ||
1185 | gtk_widget_destroy(fe->window); | ||
1186 | |||
1187 | return TRUE; | ||
1188 | } | ||
1189 | |||
1190 | static gint button_event(GtkWidget *widget, GdkEventButton *event, | ||
1191 | gpointer data) | ||
1192 | { | ||
1193 | frontend *fe = (frontend *)data; | ||
1194 | int button; | ||
1195 | |||
1196 | if (!backing_store_ok(fe)) | ||
1197 | return TRUE; | ||
1198 | |||
1199 | if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE) | ||
1200 | return TRUE; | ||
1201 | |||
1202 | if (event->button == 2 || (event->state & GDK_SHIFT_MASK)) | ||
1203 | button = MIDDLE_BUTTON; | ||
1204 | else if (event->button == 3 || (event->state & GDK_MOD1_MASK)) | ||
1205 | button = RIGHT_BUTTON; | ||
1206 | else if (event->button == 1) | ||
1207 | button = LEFT_BUTTON; | ||
1208 | else if (event->button == 8 && event->type == GDK_BUTTON_PRESS) | ||
1209 | button = 'u'; | ||
1210 | else if (event->button == 9 && event->type == GDK_BUTTON_PRESS) | ||
1211 | button = 'r'; | ||
1212 | else | ||
1213 | return FALSE; /* don't even know what button! */ | ||
1214 | |||
1215 | if (event->type == GDK_BUTTON_RELEASE && button >= LEFT_BUTTON) | ||
1216 | button += LEFT_RELEASE - LEFT_BUTTON; | ||
1217 | |||
1218 | if (!midend_process_key(fe->me, event->x - fe->ox, | ||
1219 | event->y - fe->oy, button)) | ||
1220 | gtk_widget_destroy(fe->window); | ||
1221 | |||
1222 | return TRUE; | ||
1223 | } | ||
1224 | |||
1225 | static gint motion_event(GtkWidget *widget, GdkEventMotion *event, | ||
1226 | gpointer data) | ||
1227 | { | ||
1228 | frontend *fe = (frontend *)data; | ||
1229 | int button; | ||
1230 | |||
1231 | if (!backing_store_ok(fe)) | ||
1232 | return TRUE; | ||
1233 | |||
1234 | if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK)) | ||
1235 | button = MIDDLE_DRAG; | ||
1236 | else if (event->state & GDK_BUTTON1_MASK) | ||
1237 | button = LEFT_DRAG; | ||
1238 | else if (event->state & GDK_BUTTON3_MASK) | ||
1239 | button = RIGHT_DRAG; | ||
1240 | else | ||
1241 | return FALSE; /* don't even know what button! */ | ||
1242 | |||
1243 | if (!midend_process_key(fe->me, event->x - fe->ox, | ||
1244 | event->y - fe->oy, button)) | ||
1245 | gtk_widget_destroy(fe->window); | ||
1246 | #if GTK_CHECK_VERSION(2,12,0) | ||
1247 | gdk_event_request_motions(event); | ||
1248 | #else | ||
1249 | gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, NULL); | ||
1250 | #endif | ||
1251 | |||
1252 | return TRUE; | ||
1253 | } | ||
1254 | |||
1255 | #if GTK_CHECK_VERSION(3,0,0) | ||
1256 | static gint draw_area(GtkWidget *widget, cairo_t *cr, gpointer data) | ||
1257 | { | ||
1258 | frontend *fe = (frontend *)data; | ||
1259 | GdkRectangle dirtyrect; | ||
1260 | |||
1261 | gdk_cairo_get_clip_rectangle(cr, &dirtyrect); | ||
1262 | cairo_set_source_surface(cr, fe->image, fe->ox, fe->oy); | ||
1263 | cairo_rectangle(cr, dirtyrect.x, dirtyrect.y, | ||
1264 | dirtyrect.width, dirtyrect.height); | ||
1265 | cairo_fill(cr); | ||
1266 | |||
1267 | return TRUE; | ||
1268 | } | ||
1269 | #else | ||
1270 | static gint expose_area(GtkWidget *widget, GdkEventExpose *event, | ||
1271 | gpointer data) | ||
1272 | { | ||
1273 | frontend *fe = (frontend *)data; | ||
1274 | |||
1275 | if (backing_store_ok(fe)) { | ||
1276 | #ifdef USE_CAIRO_WITHOUT_PIXMAP | ||
1277 | cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget)); | ||
1278 | cairo_set_source_surface(cr, fe->image, fe->ox, fe->oy); | ||
1279 | cairo_rectangle(cr, event->area.x, event->area.y, | ||
1280 | event->area.width, event->area.height); | ||
1281 | cairo_fill(cr); | ||
1282 | cairo_destroy(cr); | ||
1283 | #else | ||
1284 | repaint_rectangle(fe, widget, | ||
1285 | event->area.x, event->area.y, | ||
1286 | event->area.width, event->area.height); | ||
1287 | #endif | ||
1288 | } | ||
1289 | return TRUE; | ||
1290 | } | ||
1291 | #endif | ||
1292 | |||
1293 | static gint map_window(GtkWidget *widget, GdkEvent *event, | ||
1294 | gpointer data) | ||
1295 | { | ||
1296 | frontend *fe = (frontend *)data; | ||
1297 | |||
1298 | /* | ||
1299 | * Apparently we need to do this because otherwise the status | ||
1300 | * bar will fail to update immediately. Annoying, but there we | ||
1301 | * go. | ||
1302 | */ | ||
1303 | gtk_widget_queue_draw(fe->window); | ||
1304 | |||
1305 | return TRUE; | ||
1306 | } | ||
1307 | |||
1308 | static gint configure_area(GtkWidget *widget, | ||
1309 | GdkEventConfigure *event, gpointer data) | ||
1310 | { | ||
1311 | frontend *fe = (frontend *)data; | ||
1312 | int x, y; | ||
1313 | int oldw = fe->w, oldpw = fe->pw, oldh = fe->h, oldph = fe->ph; | ||
1314 | |||
1315 | x = event->width; | ||
1316 | y = event->height; | ||
1317 | fe->w = x; | ||
1318 | fe->h = y; | ||
1319 | midend_size(fe->me, &x, &y, TRUE); | ||
1320 | fe->pw = x; | ||
1321 | fe->ph = y; | ||
1322 | fe->ox = (fe->w - fe->pw) / 2; | ||
1323 | fe->oy = (fe->h - fe->ph) / 2; | ||
1324 | |||
1325 | if (oldw != fe->w || oldpw != fe->pw || | ||
1326 | oldh != fe->h || oldph != fe->ph || !backing_store_ok(fe)) { | ||
1327 | if (backing_store_ok(fe)) | ||
1328 | teardown_backing_store(fe); | ||
1329 | setup_backing_store(fe); | ||
1330 | } | ||
1331 | |||
1332 | midend_force_redraw(fe->me); | ||
1333 | |||
1334 | return TRUE; | ||
1335 | } | ||
1336 | |||
1337 | static gint timer_func(gpointer data) | ||
1338 | { | ||
1339 | frontend *fe = (frontend *)data; | ||
1340 | |||
1341 | if (fe->timer_active) { | ||
1342 | struct timeval now; | ||
1343 | float elapsed; | ||
1344 | gettimeofday(&now, NULL); | ||
1345 | elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F + | ||
1346 | (now.tv_sec - fe->last_time.tv_sec)); | ||
1347 | midend_timer(fe->me, elapsed); /* may clear timer_active */ | ||
1348 | fe->last_time = now; | ||
1349 | } | ||
1350 | |||
1351 | return fe->timer_active; | ||
1352 | } | ||
1353 | |||
1354 | void deactivate_timer(frontend *fe) | ||
1355 | { | ||
1356 | if (!fe) | ||
1357 | return; /* can happen due to --generate */ | ||
1358 | if (fe->timer_active) | ||
1359 | g_source_remove(fe->timer_id); | ||
1360 | fe->timer_active = FALSE; | ||
1361 | } | ||
1362 | |||
1363 | void activate_timer(frontend *fe) | ||
1364 | { | ||
1365 | if (!fe) | ||
1366 | return; /* can happen due to --generate */ | ||
1367 | if (!fe->timer_active) { | ||
1368 | fe->timer_id = g_timeout_add(20, timer_func, fe); | ||
1369 | gettimeofday(&fe->last_time, NULL); | ||
1370 | } | ||
1371 | fe->timer_active = TRUE; | ||
1372 | } | ||
1373 | |||
1374 | static void window_destroy(GtkWidget *widget, gpointer data) | ||
1375 | { | ||
1376 | gtk_main_quit(); | ||
1377 | } | ||
1378 | |||
1379 | static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) | ||
1380 | { | ||
1381 | GObject *cancelbutton = G_OBJECT(data); | ||
1382 | |||
1383 | /* | ||
1384 | * `Escape' effectively clicks the cancel button | ||
1385 | */ | ||
1386 | if (event->keyval == GDK_KEY_Escape) { | ||
1387 | g_signal_emit_by_name(cancelbutton, "clicked"); | ||
1388 | return TRUE; | ||
1389 | } | ||
1390 | |||
1391 | return FALSE; | ||
1392 | } | ||
1393 | |||
1394 | enum { MB_OK, MB_YESNO }; | ||
1395 | |||
1396 | static void align_label(GtkLabel *label, double x, double y) | ||
1397 | { | ||
1398 | #if GTK_CHECK_VERSION(3,16,0) | ||
1399 | gtk_label_set_xalign(label, x); | ||
1400 | gtk_label_set_yalign(label, y); | ||
1401 | #elif GTK_CHECK_VERSION(3,14,0) | ||
1402 | gtk_widget_set_halign(GTK_WIDGET(label), | ||
1403 | x == 0 ? GTK_ALIGN_START : | ||
1404 | x == 1 ? GTK_ALIGN_END : GTK_ALIGN_CENTER); | ||
1405 | gtk_widget_set_valign(GTK_WIDGET(label), | ||
1406 | y == 0 ? GTK_ALIGN_START : | ||
1407 | y == 1 ? GTK_ALIGN_END : GTK_ALIGN_CENTER); | ||
1408 | #else | ||
1409 | gtk_misc_set_alignment(GTK_MISC(label), x, y); | ||
1410 | #endif | ||
1411 | } | ||
1412 | |||
1413 | #if GTK_CHECK_VERSION(3,0,0) | ||
1414 | int message_box(GtkWidget *parent, char *title, char *msg, int centre, | ||
1415 | int type) | ||
1416 | { | ||
1417 | GtkWidget *window; | ||
1418 | gint ret; | ||
1419 | |||
1420 | window = gtk_message_dialog_new | ||
1421 | (GTK_WINDOW(parent), | ||
1422 | (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), | ||
1423 | (type == MB_OK ? GTK_MESSAGE_INFO : GTK_MESSAGE_QUESTION), | ||
1424 | (type == MB_OK ? GTK_BUTTONS_OK : GTK_BUTTONS_YES_NO), | ||
1425 | "%s", msg); | ||
1426 | gtk_window_set_title(GTK_WINDOW(window), title); | ||
1427 | ret = gtk_dialog_run(GTK_DIALOG(window)); | ||
1428 | gtk_widget_destroy(window); | ||
1429 | return (type == MB_OK ? TRUE : (ret == GTK_RESPONSE_YES)); | ||
1430 | } | ||
1431 | #else /* GTK_CHECK_VERSION(3,0,0) */ | ||
1432 | static void msgbox_button_clicked(GtkButton *button, gpointer data) | ||
1433 | { | ||
1434 | GtkWidget *window = GTK_WIDGET(data); | ||
1435 | int v, *ip; | ||
1436 | |||
1437 | ip = (int *)g_object_get_data(G_OBJECT(window), "user-data"); | ||
1438 | v = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "user-data")); | ||
1439 | *ip = v; | ||
1440 | |||
1441 | gtk_widget_destroy(GTK_WIDGET(data)); | ||
1442 | } | ||
1443 | |||
1444 | int message_box(GtkWidget *parent, char *title, char *msg, int centre, | ||
1445 | int type) | ||
1446 | { | ||
1447 | GtkWidget *window, *hbox, *text, *button; | ||
1448 | char *titles; | ||
1449 | int i, def, cancel; | ||
1450 | |||
1451 | window = gtk_dialog_new(); | ||
1452 | text = gtk_label_new(msg); | ||
1453 | align_label(GTK_LABEL(text), 0.0, 0.0); | ||
1454 | hbox = gtk_hbox_new(FALSE, 0); | ||
1455 | gtk_box_pack_start(GTK_BOX(hbox), text, FALSE, FALSE, 20); | ||
1456 | gtk_box_pack_start | ||
1457 | (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window))), | ||
1458 | hbox, FALSE, FALSE, 20); | ||
1459 | gtk_widget_show(text); | ||
1460 | gtk_widget_show(hbox); | ||
1461 | gtk_window_set_title(GTK_WINDOW(window), title); | ||
1462 | gtk_label_set_line_wrap(GTK_LABEL(text), TRUE); | ||
1463 | |||
1464 | if (type == MB_OK) { | ||
1465 | titles = LABEL_OK "\0"; | ||
1466 | def = cancel = 0; | ||
1467 | } else { | ||
1468 | assert(type == MB_YESNO); | ||
1469 | titles = LABEL_NO "\0" LABEL_YES "\0"; | ||
1470 | def = 1; | ||
1471 | cancel = 0; | ||
1472 | } | ||
1473 | i = 0; | ||
1474 | |||
1475 | while (*titles) { | ||
1476 | button = gtk_button_new_with_our_label(titles); | ||
1477 | gtk_box_pack_end | ||
1478 | (GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(window))), | ||
1479 | button, FALSE, FALSE, 0); | ||
1480 | gtk_widget_show(button); | ||
1481 | if (i == def) { | ||
1482 | gtk_widget_set_can_default(button, TRUE); | ||
1483 | gtk_window_set_default(GTK_WINDOW(window), button); | ||
1484 | } | ||
1485 | if (i == cancel) { | ||
1486 | g_signal_connect(G_OBJECT(window), "key_press_event", | ||
1487 | G_CALLBACK(win_key_press), button); | ||
1488 | } | ||
1489 | g_signal_connect(G_OBJECT(button), "clicked", | ||
1490 | G_CALLBACK(msgbox_button_clicked), window); | ||
1491 | g_object_set_data(G_OBJECT(button), "user-data", | ||
1492 | GINT_TO_POINTER(i)); | ||
1493 | titles += strlen(titles)+1; | ||
1494 | i++; | ||
1495 | } | ||
1496 | g_object_set_data(G_OBJECT(window), "user-data", &i); | ||
1497 | g_signal_connect(G_OBJECT(window), "destroy", | ||
1498 | G_CALLBACK(window_destroy), NULL); | ||
1499 | gtk_window_set_modal(GTK_WINDOW(window), TRUE); | ||
1500 | gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(parent)); | ||
1501 | /* set_transient_window_pos(parent, window); */ | ||
1502 | gtk_widget_show(window); | ||
1503 | i = -1; | ||
1504 | gtk_main(); | ||
1505 | return (type == MB_YESNO ? i == 1 : TRUE); | ||
1506 | } | ||
1507 | #endif /* GTK_CHECK_VERSION(3,0,0) */ | ||
1508 | |||
1509 | void error_box(GtkWidget *parent, char *msg) | ||
1510 | { | ||
1511 | message_box(parent, "Error", msg, FALSE, MB_OK); | ||
1512 | } | ||
1513 | |||
1514 | static void config_ok_button_clicked(GtkButton *button, gpointer data) | ||
1515 | { | ||
1516 | frontend *fe = (frontend *)data; | ||
1517 | char *err; | ||
1518 | |||
1519 | err = midend_set_config(fe->me, fe->cfg_which, fe->cfg); | ||
1520 | |||
1521 | if (err) | ||
1522 | error_box(fe->cfgbox, err); | ||
1523 | else { | ||
1524 | fe->cfgret = TRUE; | ||
1525 | gtk_widget_destroy(fe->cfgbox); | ||
1526 | changed_preset(fe); | ||
1527 | } | ||
1528 | } | ||
1529 | |||
1530 | static void config_cancel_button_clicked(GtkButton *button, gpointer data) | ||
1531 | { | ||
1532 | frontend *fe = (frontend *)data; | ||
1533 | |||
1534 | gtk_widget_destroy(fe->cfgbox); | ||
1535 | } | ||
1536 | |||
1537 | static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data) | ||
1538 | { | ||
1539 | /* | ||
1540 | * GtkEntry has a nasty habit of eating the Return key, which | ||
1541 | * is unhelpful since it doesn't actually _do_ anything with it | ||
1542 | * (it calls gtk_widget_activate, but our edit boxes never need | ||
1543 | * activating). So I catch Return before GtkEntry sees it, and | ||
1544 | * pass it straight on to the parent widget. Effect: hitting | ||
1545 | * Return in an edit box will now activate the default button | ||
1546 | * in the dialog just like it will everywhere else. | ||
1547 | */ | ||
1548 | if (event->keyval == GDK_KEY_Return && | ||
1549 | gtk_widget_get_parent(widget) != NULL) { | ||
1550 | gint return_val; | ||
1551 | g_signal_stop_emission_by_name(G_OBJECT(widget), "key_press_event"); | ||
1552 | g_signal_emit_by_name(G_OBJECT(gtk_widget_get_parent(widget)), | ||
1553 | "key_press_event", event, &return_val); | ||
1554 | return return_val; | ||
1555 | } | ||
1556 | return FALSE; | ||
1557 | } | ||
1558 | |||
1559 | static void editbox_changed(GtkEditable *ed, gpointer data) | ||
1560 | { | ||
1561 | config_item *i = (config_item *)data; | ||
1562 | |||
1563 | sfree(i->sval); | ||
1564 | i->sval = dupstr(gtk_entry_get_text(GTK_ENTRY(ed))); | ||
1565 | } | ||
1566 | |||
1567 | static void button_toggled(GtkToggleButton *tb, gpointer data) | ||
1568 | { | ||
1569 | config_item *i = (config_item *)data; | ||
1570 | |||
1571 | i->ival = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb)); | ||
1572 | } | ||
1573 | |||
1574 | static void droplist_sel(GtkComboBox *combo, gpointer data) | ||
1575 | { | ||
1576 | config_item *i = (config_item *)data; | ||
1577 | |||
1578 | i->ival = gtk_combo_box_get_active(combo); | ||
1579 | } | ||
1580 | |||
1581 | static int get_config(frontend *fe, int which) | ||
1582 | { | ||
1583 | GtkWidget *w, *table, *cancel; | ||
1584 | GtkBox *content_box, *button_box; | ||
1585 | char *title; | ||
1586 | config_item *i; | ||
1587 | int y; | ||
1588 | |||
1589 | fe->cfg = midend_get_config(fe->me, which, &title); | ||
1590 | fe->cfg_which = which; | ||
1591 | fe->cfgret = FALSE; | ||
1592 | |||
1593 | #if GTK_CHECK_VERSION(3,0,0) | ||
1594 | /* GtkDialog isn't quite flexible enough */ | ||
1595 | fe->cfgbox = gtk_window_new(GTK_WINDOW_TOPLEVEL); | ||
1596 | content_box = GTK_BOX(gtk_vbox_new(FALSE, 8)); | ||
1597 | g_object_set(G_OBJECT(content_box), "margin", 8, (const char *)NULL); | ||
1598 | gtk_widget_show(GTK_WIDGET(content_box)); | ||
1599 | gtk_container_add(GTK_CONTAINER(fe->cfgbox), GTK_WIDGET(content_box)); | ||
1600 | button_box = GTK_BOX(gtk_hbox_new(FALSE, 8)); | ||
1601 | gtk_widget_show(GTK_WIDGET(button_box)); | ||
1602 | gtk_box_pack_end(content_box, GTK_WIDGET(button_box), FALSE, FALSE, 0); | ||
1603 | { | ||
1604 | GtkWidget *sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); | ||
1605 | gtk_widget_show(sep); | ||
1606 | gtk_box_pack_end(content_box, sep, FALSE, FALSE, 0); | ||
1607 | } | ||
1608 | #else | ||
1609 | fe->cfgbox = gtk_dialog_new(); | ||
1610 | content_box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(fe->cfgbox))); | ||
1611 | button_box = GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(fe->cfgbox))); | ||
1612 | #endif | ||
1613 | gtk_window_set_title(GTK_WINDOW(fe->cfgbox), title); | ||
1614 | sfree(title); | ||
1615 | |||
1616 | w = gtk_button_new_with_our_label(LABEL_CANCEL); | ||
1617 | gtk_box_pack_end(button_box, w, FALSE, FALSE, 0); | ||
1618 | gtk_widget_show(w); | ||
1619 | g_signal_connect(G_OBJECT(w), "clicked", | ||
1620 | G_CALLBACK(config_cancel_button_clicked), fe); | ||
1621 | cancel = w; | ||
1622 | |||
1623 | w = gtk_button_new_with_our_label(LABEL_OK); | ||
1624 | gtk_box_pack_end(button_box, w, FALSE, FALSE, 0); | ||
1625 | gtk_widget_show(w); | ||
1626 | gtk_widget_set_can_default(w, TRUE); | ||
1627 | gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w); | ||
1628 | g_signal_connect(G_OBJECT(w), "clicked", | ||
1629 | G_CALLBACK(config_ok_button_clicked), fe); | ||
1630 | |||
1631 | #if GTK_CHECK_VERSION(3,0,0) | ||
1632 | table = gtk_grid_new(); | ||
1633 | #else | ||
1634 | table = gtk_table_new(1, 2, FALSE); | ||
1635 | #endif | ||
1636 | y = 0; | ||
1637 | gtk_box_pack_start(content_box, table, FALSE, FALSE, 0); | ||
1638 | gtk_widget_show(table); | ||
1639 | |||
1640 | for (i = fe->cfg; i->type != C_END; i++) { | ||
1641 | #if !GTK_CHECK_VERSION(3,0,0) | ||
1642 | gtk_table_resize(GTK_TABLE(table), y+1, 2); | ||
1643 | #endif | ||
1644 | |||
1645 | switch (i->type) { | ||
1646 | case C_STRING: | ||
1647 | /* | ||
1648 | * Edit box with a label beside it. | ||
1649 | */ | ||
1650 | |||
1651 | w = gtk_label_new(i->name); | ||
1652 | align_label(GTK_LABEL(w), 0.0, 0.5); | ||
1653 | #if GTK_CHECK_VERSION(3,0,0) | ||
1654 | gtk_grid_attach(GTK_GRID(table), w, 0, y, 1, 1); | ||
1655 | #else | ||
1656 | gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1, | ||
1657 | GTK_SHRINK | GTK_FILL, | ||
1658 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
1659 | 3, 3); | ||
1660 | #endif | ||
1661 | gtk_widget_show(w); | ||
1662 | |||
1663 | w = gtk_entry_new(); | ||
1664 | #if GTK_CHECK_VERSION(3,0,0) | ||
1665 | gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1); | ||
1666 | g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL); | ||
1667 | #else | ||
1668 | gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1, | ||
1669 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
1670 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
1671 | 3, 3); | ||
1672 | #endif | ||
1673 | gtk_entry_set_text(GTK_ENTRY(w), i->sval); | ||
1674 | g_signal_connect(G_OBJECT(w), "changed", | ||
1675 | G_CALLBACK(editbox_changed), i); | ||
1676 | g_signal_connect(G_OBJECT(w), "key_press_event", | ||
1677 | G_CALLBACK(editbox_key), NULL); | ||
1678 | gtk_widget_show(w); | ||
1679 | |||
1680 | break; | ||
1681 | |||
1682 | case C_BOOLEAN: | ||
1683 | /* | ||
1684 | * Simple checkbox. | ||
1685 | */ | ||
1686 | w = gtk_check_button_new_with_label(i->name); | ||
1687 | g_signal_connect(G_OBJECT(w), "toggled", | ||
1688 | G_CALLBACK(button_toggled), i); | ||
1689 | #if GTK_CHECK_VERSION(3,0,0) | ||
1690 | gtk_grid_attach(GTK_GRID(table), w, 0, y, 2, 1); | ||
1691 | g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL); | ||
1692 | #else | ||
1693 | gtk_table_attach(GTK_TABLE(table), w, 0, 2, y, y+1, | ||
1694 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
1695 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
1696 | 3, 3); | ||
1697 | #endif | ||
1698 | gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), i->ival); | ||
1699 | gtk_widget_show(w); | ||
1700 | break; | ||
1701 | |||
1702 | case C_CHOICES: | ||
1703 | /* | ||
1704 | * Drop-down list (GtkComboBox). | ||
1705 | */ | ||
1706 | |||
1707 | w = gtk_label_new(i->name); | ||
1708 | align_label(GTK_LABEL(w), 0.0, 0.5); | ||
1709 | #if GTK_CHECK_VERSION(3,0,0) | ||
1710 | gtk_grid_attach(GTK_GRID(table), w, 0, y, 1, 1); | ||
1711 | #else | ||
1712 | gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1, | ||
1713 | GTK_SHRINK | GTK_FILL, | ||
1714 | GTK_EXPAND | GTK_SHRINK | GTK_FILL , | ||
1715 | 3, 3); | ||
1716 | #endif | ||
1717 | gtk_widget_show(w); | ||
1718 | |||
1719 | { | ||
1720 | int c; | ||
1721 | char *p, *q, *name; | ||
1722 | GtkListStore *model; | ||
1723 | GtkCellRenderer *cr; | ||
1724 | GtkTreeIter iter; | ||
1725 | |||
1726 | model = gtk_list_store_new(1, G_TYPE_STRING); | ||
1727 | |||
1728 | c = *i->sval; | ||
1729 | p = i->sval+1; | ||
1730 | |||
1731 | while (*p) { | ||
1732 | q = p; | ||
1733 | while (*q && *q != c) | ||
1734 | q++; | ||
1735 | |||
1736 | name = snewn(q-p+1, char); | ||
1737 | strncpy(name, p, q-p); | ||
1738 | name[q-p] = '\0'; | ||
1739 | |||
1740 | if (*q) q++; /* eat delimiter */ | ||
1741 | |||
1742 | gtk_list_store_append(model, &iter); | ||
1743 | gtk_list_store_set(model, &iter, 0, name, -1); | ||
1744 | |||
1745 | p = q; | ||
1746 | } | ||
1747 | |||
1748 | w = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); | ||
1749 | |||
1750 | gtk_combo_box_set_active(GTK_COMBO_BOX(w), i->ival); | ||
1751 | |||
1752 | cr = gtk_cell_renderer_text_new(); | ||
1753 | gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(w), cr, TRUE); | ||
1754 | gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(w), cr, | ||
1755 | "text", 0, NULL); | ||
1756 | |||
1757 | g_signal_connect(G_OBJECT(w), "changed", | ||
1758 | G_CALLBACK(droplist_sel), i); | ||
1759 | } | ||
1760 | |||
1761 | #if GTK_CHECK_VERSION(3,0,0) | ||
1762 | gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1); | ||
1763 | g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL); | ||
1764 | #else | ||
1765 | gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1, | ||
1766 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
1767 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
1768 | 3, 3); | ||
1769 | #endif | ||
1770 | gtk_widget_show(w); | ||
1771 | break; | ||
1772 | } | ||
1773 | |||
1774 | y++; | ||
1775 | } | ||
1776 | |||
1777 | g_signal_connect(G_OBJECT(fe->cfgbox), "destroy", | ||
1778 | G_CALLBACK(window_destroy), NULL); | ||
1779 | g_signal_connect(G_OBJECT(fe->cfgbox), "key_press_event", | ||
1780 | G_CALLBACK(win_key_press), cancel); | ||
1781 | gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), TRUE); | ||
1782 | gtk_window_set_transient_for(GTK_WINDOW(fe->cfgbox), | ||
1783 | GTK_WINDOW(fe->window)); | ||
1784 | /* set_transient_window_pos(fe->window, fe->cfgbox); */ | ||
1785 | gtk_widget_show(fe->cfgbox); | ||
1786 | gtk_main(); | ||
1787 | |||
1788 | free_cfg(fe->cfg); | ||
1789 | |||
1790 | return fe->cfgret; | ||
1791 | } | ||
1792 | |||
1793 | static void menu_key_event(GtkMenuItem *menuitem, gpointer data) | ||
1794 | { | ||
1795 | frontend *fe = (frontend *)data; | ||
1796 | int key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), | ||
1797 | "user-data")); | ||
1798 | if (!midend_process_key(fe->me, 0, 0, key)) | ||
1799 | gtk_widget_destroy(fe->window); | ||
1800 | } | ||
1801 | |||
1802 | static void get_size(frontend *fe, int *px, int *py) | ||
1803 | { | ||
1804 | int x, y; | ||
1805 | |||
1806 | /* | ||
1807 | * Currently I don't want to make the GTK port scale large | ||
1808 | * puzzles to fit on the screen. This is because X does permit | ||
1809 | * extremely large windows and many window managers provide a | ||
1810 | * means of navigating round them, and the users I consulted | ||
1811 | * before deciding said that they'd rather have enormous puzzle | ||
1812 | * windows spanning multiple screen pages than have them | ||
1813 | * shrunk. I could change my mind later or introduce | ||
1814 | * configurability; this would be the place to do so, by | ||
1815 | * replacing the initial values of x and y with the screen | ||
1816 | * dimensions. | ||
1817 | */ | ||
1818 | x = INT_MAX; | ||
1819 | y = INT_MAX; | ||
1820 | midend_size(fe->me, &x, &y, FALSE); | ||
1821 | *px = x; | ||
1822 | *py = y; | ||
1823 | } | ||
1824 | |||
1825 | #if !GTK_CHECK_VERSION(2,0,0) | ||
1826 | #define gtk_window_resize(win, x, y) \ | ||
1827 | gdk_window_resize(GTK_WIDGET(win)->window, x, y) | ||
1828 | #endif | ||
1829 | |||
1830 | /* | ||
1831 | * Called when any other code in this file has changed the | ||
1832 | * selected game parameters. | ||
1833 | */ | ||
1834 | static void changed_preset(frontend *fe) | ||
1835 | { | ||
1836 | int n = midend_which_preset(fe->me); | ||
1837 | |||
1838 | fe->preset_threaded = TRUE; | ||
1839 | if (n < 0 && fe->preset_custom) { | ||
1840 | gtk_check_menu_item_set_active( | ||
1841 | GTK_CHECK_MENU_ITEM(fe->preset_custom), | ||
1842 | TRUE); | ||
1843 | } else { | ||
1844 | GSList *gs = fe->preset_radio; | ||
1845 | int i = fe->n_preset_menu_items - 1 - n; | ||
1846 | if (fe->preset_custom) | ||
1847 | gs = gs->next; | ||
1848 | while (i && gs) { | ||
1849 | i--; | ||
1850 | gs = gs->next; | ||
1851 | } | ||
1852 | if (gs) { | ||
1853 | gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gs->data), | ||
1854 | TRUE); | ||
1855 | } else for (gs = fe->preset_radio; gs; gs = gs->next) { | ||
1856 | gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gs->data), | ||
1857 | FALSE); | ||
1858 | } | ||
1859 | } | ||
1860 | fe->preset_threaded = FALSE; | ||
1861 | |||
1862 | /* | ||
1863 | * Update the greying on the Copy menu option. | ||
1864 | */ | ||
1865 | if (fe->copy_menu_item) { | ||
1866 | int enabled = midend_can_format_as_text_now(fe->me); | ||
1867 | gtk_widget_set_sensitive(fe->copy_menu_item, enabled); | ||
1868 | } | ||
1869 | } | ||
1870 | |||
1871 | #if !GTK_CHECK_VERSION(3,0,0) | ||
1872 | static gboolean not_size_allocated_yet(GtkWidget *w) | ||
1873 | { | ||
1874 | /* | ||
1875 | * This function tests whether a widget has not yet taken up space | ||
1876 | * on the screen which it will occupy in future. (Therefore, it | ||
1877 | * returns true only if the widget does exist but does not have a | ||
1878 | * size allocation. A null widget is already taking up all the | ||
1879 | * space it ever will.) | ||
1880 | */ | ||
1881 | if (!w) | ||
1882 | return FALSE; /* nonexistent widgets aren't a problem */ | ||
1883 | |||
1884 | #if GTK_CHECK_VERSION(2,18,0) /* skip if no gtk_widget_get_allocation */ | ||
1885 | { | ||
1886 | GtkAllocation a; | ||
1887 | gtk_widget_get_allocation(w, &a); | ||
1888 | if (a.height == 0 || a.width == 0) | ||
1889 | return TRUE; /* widget exists but has no size yet */ | ||
1890 | } | ||
1891 | #endif | ||
1892 | |||
1893 | return FALSE; | ||
1894 | } | ||
1895 | |||
1896 | static void try_shrink_drawing_area(frontend *fe) | ||
1897 | { | ||
1898 | if (fe->drawing_area_shrink_pending && | ||
1899 | (!fe->menubar_is_local || !not_size_allocated_yet(fe->menubar)) && | ||
1900 | !not_size_allocated_yet(fe->statusbar)) { | ||
1901 | /* | ||
1902 | * In order to permit the user to resize the window smaller as | ||
1903 | * well as bigger, we call this function after the window size | ||
1904 | * has ended up where we want it. This shouldn't shrink the | ||
1905 | * window immediately; it just arranges that the next time the | ||
1906 | * user tries to shrink it, they can. | ||
1907 | * | ||
1908 | * However, at puzzle creation time, we defer the first of | ||
1909 | * these operations until after the menu bar and status bar | ||
1910 | * are actually visible. On Ubuntu 12.04 I've found that these | ||
1911 | * can take a while to be displayed, and that it's a mistake | ||
1912 | * to reduce the drawing area's size allocation before they've | ||
1913 | * turned up or else the drawing area makes room for them by | ||
1914 | * shrinking to less than the size we intended. | ||
1915 | */ | ||
1916 | gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), 1, 1); | ||
1917 | fe->drawing_area_shrink_pending = FALSE; | ||
1918 | } | ||
1919 | } | ||
1920 | #endif /* !GTK_CHECK_VERSION(3,0,0) */ | ||
1921 | |||
1922 | static gint configure_window(GtkWidget *widget, | ||
1923 | GdkEventConfigure *event, gpointer data) | ||
1924 | { | ||
1925 | #if !GTK_CHECK_VERSION(3,0,0) | ||
1926 | /* | ||
1927 | * When the main puzzle window changes size, it might be because | ||
1928 | * the menu bar or status bar has turned up after starting off | ||
1929 | * absent, in which case we should have another go at enacting a | ||
1930 | * pending shrink of the drawing area. | ||
1931 | */ | ||
1932 | frontend *fe = (frontend *)data; | ||
1933 | try_shrink_drawing_area(fe); | ||
1934 | #endif | ||
1935 | return FALSE; | ||
1936 | } | ||
1937 | |||
1938 | static void resize_fe(frontend *fe) | ||
1939 | { | ||
1940 | int x, y; | ||
1941 | |||
1942 | get_size(fe, &x, &y); | ||
1943 | |||
1944 | #if GTK_CHECK_VERSION(3,0,0) | ||
1945 | gtk_window_resize_to_geometry(GTK_WINDOW(fe->window), x, y); | ||
1946 | #else | ||
1947 | fe->drawing_area_shrink_pending = FALSE; | ||
1948 | gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y); | ||
1949 | { | ||
1950 | GtkRequisition req; | ||
1951 | gtk_widget_size_request(GTK_WIDGET(fe->window), &req); | ||
1952 | gtk_window_resize(GTK_WINDOW(fe->window), req.width, req.height); | ||
1953 | } | ||
1954 | fe->drawing_area_shrink_pending = TRUE; | ||
1955 | try_shrink_drawing_area(fe); | ||
1956 | #endif | ||
1957 | } | ||
1958 | |||
1959 | static void menu_preset_event(GtkMenuItem *menuitem, gpointer data) | ||
1960 | { | ||
1961 | frontend *fe = (frontend *)data; | ||
1962 | game_params *params = | ||
1963 | (game_params *)g_object_get_data(G_OBJECT(menuitem), "user-data"); | ||
1964 | |||
1965 | if (fe->preset_threaded || | ||
1966 | (GTK_IS_CHECK_MENU_ITEM(menuitem) && | ||
1967 | !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)))) | ||
1968 | return; | ||
1969 | midend_set_params(fe->me, params); | ||
1970 | midend_new_game(fe->me); | ||
1971 | changed_preset(fe); | ||
1972 | resize_fe(fe); | ||
1973 | } | ||
1974 | |||
1975 | GdkAtom compound_text_atom, utf8_string_atom; | ||
1976 | int paste_initialised = FALSE; | ||
1977 | |||
1978 | static void set_selection(frontend *fe, GdkAtom selection) | ||
1979 | { | ||
1980 | if (!paste_initialised) { | ||
1981 | compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE); | ||
1982 | utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE); | ||
1983 | paste_initialised = TRUE; | ||
1984 | } | ||
1985 | |||
1986 | /* | ||
1987 | * For this simple application we can safely assume that the | ||
1988 | * data passed to this function is pure ASCII, which means we | ||
1989 | * can return precisely the same stuff for types STRING, | ||
1990 | * COMPOUND_TEXT or UTF8_STRING. | ||
1991 | */ | ||
1992 | |||
1993 | if (gtk_selection_owner_set(fe->area, selection, CurrentTime)) { | ||
1994 | gtk_selection_clear_targets(fe->area, selection); | ||
1995 | gtk_selection_add_target(fe->area, selection, | ||
1996 | GDK_SELECTION_TYPE_STRING, 1); | ||
1997 | gtk_selection_add_target(fe->area, selection, compound_text_atom, 1); | ||
1998 | gtk_selection_add_target(fe->area, selection, utf8_string_atom, 1); | ||
1999 | } | ||
2000 | } | ||
2001 | |||
2002 | void write_clip(frontend *fe, char *data) | ||
2003 | { | ||
2004 | if (fe->paste_data) | ||
2005 | sfree(fe->paste_data); | ||
2006 | |||
2007 | fe->paste_data = data; | ||
2008 | fe->paste_data_len = strlen(data); | ||
2009 | |||
2010 | set_selection(fe, GDK_SELECTION_PRIMARY); | ||
2011 | set_selection(fe, GDK_SELECTION_CLIPBOARD); | ||
2012 | } | ||
2013 | |||
2014 | void selection_get(GtkWidget *widget, GtkSelectionData *seldata, | ||
2015 | guint info, guint time_stamp, gpointer data) | ||
2016 | { | ||
2017 | frontend *fe = (frontend *)data; | ||
2018 | gtk_selection_data_set(seldata, gtk_selection_data_get_target(seldata), 8, | ||
2019 | fe->paste_data, fe->paste_data_len); | ||
2020 | } | ||
2021 | |||
2022 | gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata, | ||
2023 | gpointer data) | ||
2024 | { | ||
2025 | frontend *fe = (frontend *)data; | ||
2026 | |||
2027 | if (fe->paste_data) | ||
2028 | sfree(fe->paste_data); | ||
2029 | fe->paste_data = NULL; | ||
2030 | fe->paste_data_len = 0; | ||
2031 | return TRUE; | ||
2032 | } | ||
2033 | |||
2034 | static void menu_copy_event(GtkMenuItem *menuitem, gpointer data) | ||
2035 | { | ||
2036 | frontend *fe = (frontend *)data; | ||
2037 | char *text; | ||
2038 | |||
2039 | text = midend_text_format(fe->me); | ||
2040 | |||
2041 | if (text) { | ||
2042 | write_clip(fe, text); | ||
2043 | } else { | ||
2044 | gdk_beep(); | ||
2045 | } | ||
2046 | } | ||
2047 | |||
2048 | #ifdef OLD_FILESEL | ||
2049 | |||
2050 | static void filesel_ok(GtkButton *button, gpointer data) | ||
2051 | { | ||
2052 | frontend *fe = (frontend *)data; | ||
2053 | |||
2054 | gpointer filesel = g_object_get_data(G_OBJECT(button), "user-data"); | ||
2055 | |||
2056 | const char *name = | ||
2057 | gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel)); | ||
2058 | |||
2059 | fe->filesel_name = dupstr(name); | ||
2060 | } | ||
2061 | |||
2062 | static char *file_selector(frontend *fe, char *title, int save) | ||
2063 | { | ||
2064 | GtkWidget *filesel = | ||
2065 | gtk_file_selection_new(title); | ||
2066 | |||
2067 | fe->filesel_name = NULL; | ||
2068 | |||
2069 | gtk_window_set_modal(GTK_WINDOW(filesel), TRUE); | ||
2070 | g_object_set_data | ||
2071 | (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "user-data", | ||
2072 | (gpointer)filesel); | ||
2073 | g_signal_connect | ||
2074 | (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", | ||
2075 | G_CALLBACK(filesel_ok), fe); | ||
2076 | g_signal_connect_swapped | ||
2077 | (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", | ||
2078 | G_CALLBACK(gtk_widget_destroy), (gpointer)filesel); | ||
2079 | g_signal_connect_object | ||
2080 | (G_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button), "clicked", | ||
2081 | G_CALLBACK(gtk_widget_destroy), (gpointer)filesel); | ||
2082 | g_signal_connect(G_OBJECT(filesel), "destroy", | ||
2083 | G_CALLBACK(window_destroy), NULL); | ||
2084 | gtk_widget_show(filesel); | ||
2085 | gtk_window_set_transient_for(GTK_WINDOW(filesel), GTK_WINDOW(fe->window)); | ||
2086 | gtk_main(); | ||
2087 | |||
2088 | return fe->filesel_name; | ||
2089 | } | ||
2090 | |||
2091 | #else | ||
2092 | |||
2093 | static char *file_selector(frontend *fe, char *title, int save) | ||
2094 | { | ||
2095 | char *filesel_name = NULL; | ||
2096 | |||
2097 | GtkWidget *filesel = | ||
2098 | gtk_file_chooser_dialog_new(title, | ||
2099 | GTK_WINDOW(fe->window), | ||
2100 | save ? GTK_FILE_CHOOSER_ACTION_SAVE : | ||
2101 | GTK_FILE_CHOOSER_ACTION_OPEN, | ||
2102 | LABEL_CANCEL, GTK_RESPONSE_CANCEL, | ||
2103 | save ? LABEL_SAVE : LABEL_OPEN, | ||
2104 | GTK_RESPONSE_ACCEPT, | ||
2105 | NULL); | ||
2106 | |||
2107 | if (gtk_dialog_run(GTK_DIALOG(filesel)) == GTK_RESPONSE_ACCEPT) { | ||
2108 | char *name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filesel)); | ||
2109 | filesel_name = dupstr(name); | ||
2110 | g_free(name); | ||
2111 | } | ||
2112 | |||
2113 | gtk_widget_destroy(filesel); | ||
2114 | |||
2115 | return filesel_name; | ||
2116 | } | ||
2117 | |||
2118 | #endif | ||
2119 | |||
2120 | struct savefile_write_ctx { | ||
2121 | FILE *fp; | ||
2122 | int error; | ||
2123 | }; | ||
2124 | |||
2125 | static void savefile_write(void *wctx, void *buf, int len) | ||
2126 | { | ||
2127 | struct savefile_write_ctx *ctx = (struct savefile_write_ctx *)wctx; | ||
2128 | if (fwrite(buf, 1, len, ctx->fp) < len) | ||
2129 | ctx->error = errno; | ||
2130 | } | ||
2131 | |||
2132 | static int savefile_read(void *wctx, void *buf, int len) | ||
2133 | { | ||
2134 | FILE *fp = (FILE *)wctx; | ||
2135 | int ret; | ||
2136 | |||
2137 | ret = fread(buf, 1, len, fp); | ||
2138 | return (ret == len); | ||
2139 | } | ||
2140 | |||
2141 | static void menu_save_event(GtkMenuItem *menuitem, gpointer data) | ||
2142 | { | ||
2143 | frontend *fe = (frontend *)data; | ||
2144 | char *name; | ||
2145 | |||
2146 | name = file_selector(fe, "Enter name of game file to save", TRUE); | ||
2147 | |||
2148 | if (name) { | ||
2149 | FILE *fp; | ||
2150 | |||
2151 | if ((fp = fopen(name, "r")) != NULL) { | ||
2152 | char buf[256 + FILENAME_MAX]; | ||
2153 | fclose(fp); | ||
2154 | /* file exists */ | ||
2155 | |||
2156 | sprintf(buf, "Are you sure you want to overwrite the" | ||
2157 | " file \"%.*s\"?", | ||
2158 | FILENAME_MAX, name); | ||
2159 | if (!message_box(fe->window, "Question", buf, TRUE, MB_YESNO)) | ||
2160 | goto free_and_return; | ||
2161 | } | ||
2162 | |||
2163 | fp = fopen(name, "w"); | ||
2164 | |||
2165 | if (!fp) { | ||
2166 | error_box(fe->window, "Unable to open save file"); | ||
2167 | goto free_and_return; | ||
2168 | } | ||
2169 | |||
2170 | { | ||
2171 | struct savefile_write_ctx ctx; | ||
2172 | ctx.fp = fp; | ||
2173 | ctx.error = 0; | ||
2174 | midend_serialise(fe->me, savefile_write, &ctx); | ||
2175 | fclose(fp); | ||
2176 | if (ctx.error) { | ||
2177 | char boxmsg[512]; | ||
2178 | sprintf(boxmsg, "Error writing save file: %.400s", | ||
2179 | strerror(errno)); | ||
2180 | error_box(fe->window, boxmsg); | ||
2181 | goto free_and_return; | ||
2182 | } | ||
2183 | } | ||
2184 | free_and_return: | ||
2185 | sfree(name); | ||
2186 | } | ||
2187 | } | ||
2188 | |||
2189 | static void menu_load_event(GtkMenuItem *menuitem, gpointer data) | ||
2190 | { | ||
2191 | frontend *fe = (frontend *)data; | ||
2192 | char *name, *err; | ||
2193 | |||
2194 | name = file_selector(fe, "Enter name of saved game file to load", FALSE); | ||
2195 | |||
2196 | if (name) { | ||
2197 | FILE *fp = fopen(name, "r"); | ||
2198 | sfree(name); | ||
2199 | |||
2200 | if (!fp) { | ||
2201 | error_box(fe->window, "Unable to open saved game file"); | ||
2202 | return; | ||
2203 | } | ||
2204 | |||
2205 | err = midend_deserialise(fe->me, savefile_read, fp); | ||
2206 | |||
2207 | fclose(fp); | ||
2208 | |||
2209 | if (err) { | ||
2210 | error_box(fe->window, err); | ||
2211 | return; | ||
2212 | } | ||
2213 | |||
2214 | changed_preset(fe); | ||
2215 | resize_fe(fe); | ||
2216 | } | ||
2217 | } | ||
2218 | |||
2219 | static void menu_solve_event(GtkMenuItem *menuitem, gpointer data) | ||
2220 | { | ||
2221 | frontend *fe = (frontend *)data; | ||
2222 | char *msg; | ||
2223 | |||
2224 | msg = midend_solve(fe->me); | ||
2225 | |||
2226 | if (msg) | ||
2227 | error_box(fe->window, msg); | ||
2228 | } | ||
2229 | |||
2230 | static void menu_restart_event(GtkMenuItem *menuitem, gpointer data) | ||
2231 | { | ||
2232 | frontend *fe = (frontend *)data; | ||
2233 | |||
2234 | midend_restart_game(fe->me); | ||
2235 | } | ||
2236 | |||
2237 | static void menu_config_event(GtkMenuItem *menuitem, gpointer data) | ||
2238 | { | ||
2239 | frontend *fe = (frontend *)data; | ||
2240 | int which = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), | ||
2241 | "user-data")); | ||
2242 | |||
2243 | if (fe->preset_threaded || | ||
2244 | (GTK_IS_CHECK_MENU_ITEM(menuitem) && | ||
2245 | !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)))) | ||
2246 | return; | ||
2247 | changed_preset(fe); /* Put the old preset back! */ | ||
2248 | if (!get_config(fe, which)) | ||
2249 | return; | ||
2250 | |||
2251 | midend_new_game(fe->me); | ||
2252 | resize_fe(fe); | ||
2253 | } | ||
2254 | |||
2255 | static void menu_about_event(GtkMenuItem *menuitem, gpointer data) | ||
2256 | { | ||
2257 | frontend *fe = (frontend *)data; | ||
2258 | |||
2259 | #if GTK_CHECK_VERSION(3,0,0) | ||
2260 | extern char *const *const xpm_icons[]; | ||
2261 | extern const int n_xpm_icons; | ||
2262 | GdkPixbuf *icon = gdk_pixbuf_new_from_xpm_data | ||
2263 | ((const gchar **)xpm_icons[n_xpm_icons-1]); | ||
2264 | gtk_show_about_dialog | ||
2265 | (GTK_WINDOW(fe->window), | ||
2266 | "program-name", thegame.name, | ||
2267 | "version", ver, | ||
2268 | "comments", "Part of Simon Tatham's Portable Puzzle Collection", | ||
2269 | "logo", icon, | ||
2270 | (const gchar *)NULL); | ||
2271 | g_object_unref(G_OBJECT(icon)); | ||
2272 | #else | ||
2273 | char titlebuf[256]; | ||
2274 | char textbuf[1024]; | ||
2275 | |||
2276 | sprintf(titlebuf, "About %.200s", thegame.name); | ||
2277 | sprintf(textbuf, | ||
2278 | "%.200s\n\n" | ||
2279 | "from Simon Tatham's Portable Puzzle Collection\n\n" | ||
2280 | "%.500s", thegame.name, ver); | ||
2281 | |||
2282 | message_box(fe->window, titlebuf, textbuf, TRUE, MB_OK); | ||
2283 | #endif | ||
2284 | } | ||
2285 | |||
2286 | static GtkWidget *add_menu_item_with_key(frontend *fe, GtkContainer *cont, | ||
2287 | char *text, int key) | ||
2288 | { | ||
2289 | GtkWidget *menuitem = gtk_menu_item_new_with_label(text); | ||
2290 | int keyqual; | ||
2291 | gtk_container_add(cont, menuitem); | ||
2292 | g_object_set_data(G_OBJECT(menuitem), "user-data", GINT_TO_POINTER(key)); | ||
2293 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2294 | G_CALLBACK(menu_key_event), fe); | ||
2295 | switch (key & ~0x1F) { | ||
2296 | case 0x00: | ||
2297 | key += 0x60; | ||
2298 | keyqual = GDK_CONTROL_MASK; | ||
2299 | break; | ||
2300 | case 0x40: | ||
2301 | key += 0x20; | ||
2302 | keyqual = GDK_SHIFT_MASK; | ||
2303 | break; | ||
2304 | default: | ||
2305 | keyqual = 0; | ||
2306 | break; | ||
2307 | } | ||
2308 | gtk_widget_add_accelerator(menuitem, | ||
2309 | "activate", fe->accelgroup, | ||
2310 | key, keyqual, | ||
2311 | GTK_ACCEL_VISIBLE); | ||
2312 | gtk_widget_show(menuitem); | ||
2313 | return menuitem; | ||
2314 | } | ||
2315 | |||
2316 | static void add_menu_separator(GtkContainer *cont) | ||
2317 | { | ||
2318 | GtkWidget *menuitem = gtk_menu_item_new(); | ||
2319 | gtk_container_add(cont, menuitem); | ||
2320 | gtk_widget_show(menuitem); | ||
2321 | } | ||
2322 | |||
2323 | enum { ARG_EITHER, ARG_SAVE, ARG_ID }; /* for argtype */ | ||
2324 | |||
2325 | static frontend *new_window(char *arg, int argtype, char **error) | ||
2326 | { | ||
2327 | frontend *fe; | ||
2328 | GtkBox *vbox, *hbox; | ||
2329 | GtkWidget *menu, *menuitem; | ||
2330 | GList *iconlist; | ||
2331 | int x, y, n; | ||
2332 | char errbuf[1024]; | ||
2333 | extern char *const *const xpm_icons[]; | ||
2334 | extern const int n_xpm_icons; | ||
2335 | |||
2336 | fe = snew(frontend); | ||
2337 | |||
2338 | fe->timer_active = FALSE; | ||
2339 | fe->timer_id = -1; | ||
2340 | |||
2341 | fe->me = midend_new(fe, &thegame, >k_drawing, fe); | ||
2342 | |||
2343 | if (arg) { | ||
2344 | char *err; | ||
2345 | FILE *fp; | ||
2346 | |||
2347 | errbuf[0] = '\0'; | ||
2348 | |||
2349 | switch (argtype) { | ||
2350 | case ARG_ID: | ||
2351 | err = midend_game_id(fe->me, arg); | ||
2352 | if (!err) | ||
2353 | midend_new_game(fe->me); | ||
2354 | else | ||
2355 | sprintf(errbuf, "Invalid game ID: %.800s", err); | ||
2356 | break; | ||
2357 | case ARG_SAVE: | ||
2358 | fp = fopen(arg, "r"); | ||
2359 | if (!fp) { | ||
2360 | sprintf(errbuf, "Error opening file: %.800s", strerror(errno)); | ||
2361 | } else { | ||
2362 | err = midend_deserialise(fe->me, savefile_read, fp); | ||
2363 | if (err) | ||
2364 | sprintf(errbuf, "Invalid save file: %.800s", err); | ||
2365 | fclose(fp); | ||
2366 | } | ||
2367 | break; | ||
2368 | default /*case ARG_EITHER*/: | ||
2369 | /* | ||
2370 | * First try treating the argument as a game ID. | ||
2371 | */ | ||
2372 | err = midend_game_id(fe->me, arg); | ||
2373 | if (!err) { | ||
2374 | /* | ||
2375 | * It's a valid game ID. | ||
2376 | */ | ||
2377 | midend_new_game(fe->me); | ||
2378 | } else { | ||
2379 | FILE *fp = fopen(arg, "r"); | ||
2380 | if (!fp) { | ||
2381 | sprintf(errbuf, "Supplied argument is neither a game ID (%.400s)" | ||
2382 | " nor a save file (%.400s)", err, strerror(errno)); | ||
2383 | } else { | ||
2384 | err = midend_deserialise(fe->me, savefile_read, fp); | ||
2385 | if (err) | ||
2386 | sprintf(errbuf, "%.800s", err); | ||
2387 | fclose(fp); | ||
2388 | } | ||
2389 | } | ||
2390 | break; | ||
2391 | } | ||
2392 | if (*errbuf) { | ||
2393 | *error = dupstr(errbuf); | ||
2394 | midend_free(fe->me); | ||
2395 | sfree(fe); | ||
2396 | return NULL; | ||
2397 | } | ||
2398 | |||
2399 | } else { | ||
2400 | midend_new_game(fe->me); | ||
2401 | } | ||
2402 | |||
2403 | #if !GTK_CHECK_VERSION(3,0,0) | ||
2404 | { | ||
2405 | /* | ||
2406 | * try_shrink_drawing_area() will do some fiddling with the | ||
2407 | * window size request (see comment in that function) after | ||
2408 | * all the bits and pieces such as the menu bar and status bar | ||
2409 | * have appeared in the puzzle window. | ||
2410 | * | ||
2411 | * However, on Unity systems, the menu bar _doesn't_ appear in | ||
2412 | * the puzzle window, because the Unity shell hijacks it into | ||
2413 | * the menu bar at the very top of the screen. We therefore | ||
2414 | * try to detect that situation here, so that we don't sit | ||
2415 | * here forever waiting for a menu bar. | ||
2416 | */ | ||
2417 | const char prop[] = "gtk-shell-shows-menubar"; | ||
2418 | GtkSettings *settings = gtk_settings_get_default(); | ||
2419 | if (!g_object_class_find_property(G_OBJECT_GET_CLASS(settings), | ||
2420 | prop)) { | ||
2421 | fe->menubar_is_local = TRUE; | ||
2422 | } else { | ||
2423 | int unity_mode; | ||
2424 | g_object_get(gtk_settings_get_default(), | ||
2425 | prop, &unity_mode, | ||
2426 | (const gchar *)NULL); | ||
2427 | fe->menubar_is_local = !unity_mode; | ||
2428 | } | ||
2429 | } | ||
2430 | #endif | ||
2431 | |||
2432 | fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); | ||
2433 | gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name); | ||
2434 | |||
2435 | vbox = GTK_BOX(gtk_vbox_new(FALSE, 0)); | ||
2436 | gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox)); | ||
2437 | gtk_widget_show(GTK_WIDGET(vbox)); | ||
2438 | |||
2439 | fe->accelgroup = gtk_accel_group_new(); | ||
2440 | gtk_window_add_accel_group(GTK_WINDOW(fe->window), fe->accelgroup); | ||
2441 | |||
2442 | hbox = GTK_BOX(gtk_hbox_new(FALSE, 0)); | ||
2443 | gtk_box_pack_start(vbox, GTK_WIDGET(hbox), FALSE, FALSE, 0); | ||
2444 | gtk_widget_show(GTK_WIDGET(hbox)); | ||
2445 | |||
2446 | fe->menubar = gtk_menu_bar_new(); | ||
2447 | gtk_box_pack_start(hbox, fe->menubar, TRUE, TRUE, 0); | ||
2448 | gtk_widget_show(fe->menubar); | ||
2449 | |||
2450 | menuitem = gtk_menu_item_new_with_mnemonic("_Game"); | ||
2451 | gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); | ||
2452 | gtk_widget_show(menuitem); | ||
2453 | |||
2454 | menu = gtk_menu_new(); | ||
2455 | gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu); | ||
2456 | |||
2457 | add_menu_item_with_key(fe, GTK_CONTAINER(menu), "New", 'n'); | ||
2458 | |||
2459 | menuitem = gtk_menu_item_new_with_label("Restart"); | ||
2460 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
2461 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2462 | G_CALLBACK(menu_restart_event), fe); | ||
2463 | gtk_widget_show(menuitem); | ||
2464 | |||
2465 | menuitem = gtk_menu_item_new_with_label("Specific..."); | ||
2466 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
2467 | GINT_TO_POINTER(CFG_DESC)); | ||
2468 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
2469 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2470 | G_CALLBACK(menu_config_event), fe); | ||
2471 | gtk_widget_show(menuitem); | ||
2472 | |||
2473 | menuitem = gtk_menu_item_new_with_label("Random Seed..."); | ||
2474 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
2475 | GINT_TO_POINTER(CFG_SEED)); | ||
2476 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
2477 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2478 | G_CALLBACK(menu_config_event), fe); | ||
2479 | gtk_widget_show(menuitem); | ||
2480 | |||
2481 | fe->preset_radio = NULL; | ||
2482 | fe->preset_custom = NULL; | ||
2483 | fe->n_preset_menu_items = 0; | ||
2484 | fe->preset_threaded = FALSE; | ||
2485 | if ((n = midend_num_presets(fe->me)) > 0 || thegame.can_configure) { | ||
2486 | GtkWidget *submenu; | ||
2487 | int i; | ||
2488 | |||
2489 | menuitem = gtk_menu_item_new_with_mnemonic("_Type"); | ||
2490 | gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); | ||
2491 | gtk_widget_show(menuitem); | ||
2492 | |||
2493 | submenu = gtk_menu_new(); | ||
2494 | gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); | ||
2495 | |||
2496 | for (i = 0; i < n; i++) { | ||
2497 | char *name; | ||
2498 | game_params *params; | ||
2499 | |||
2500 | midend_fetch_preset(fe->me, i, &name, ¶ms); | ||
2501 | |||
2502 | menuitem = | ||
2503 | gtk_radio_menu_item_new_with_label(fe->preset_radio, name); | ||
2504 | fe->preset_radio = | ||
2505 | gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); | ||
2506 | fe->n_preset_menu_items++; | ||
2507 | gtk_container_add(GTK_CONTAINER(submenu), menuitem); | ||
2508 | g_object_set_data(G_OBJECT(menuitem), "user-data", params); | ||
2509 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2510 | G_CALLBACK(menu_preset_event), fe); | ||
2511 | gtk_widget_show(menuitem); | ||
2512 | } | ||
2513 | |||
2514 | if (thegame.can_configure) { | ||
2515 | menuitem = fe->preset_custom = | ||
2516 | gtk_radio_menu_item_new_with_label(fe->preset_radio, | ||
2517 | "Custom..."); | ||
2518 | fe->preset_radio = | ||
2519 | gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); | ||
2520 | gtk_container_add(GTK_CONTAINER(submenu), menuitem); | ||
2521 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
2522 | GINT_TO_POINTER(CFG_SETTINGS)); | ||
2523 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2524 | G_CALLBACK(menu_config_event), fe); | ||
2525 | gtk_widget_show(menuitem); | ||
2526 | } | ||
2527 | |||
2528 | } | ||
2529 | |||
2530 | add_menu_separator(GTK_CONTAINER(menu)); | ||
2531 | menuitem = gtk_menu_item_new_with_label("Load..."); | ||
2532 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
2533 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2534 | G_CALLBACK(menu_load_event), fe); | ||
2535 | gtk_widget_show(menuitem); | ||
2536 | menuitem = gtk_menu_item_new_with_label("Save..."); | ||
2537 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
2538 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2539 | G_CALLBACK(menu_save_event), fe); | ||
2540 | gtk_widget_show(menuitem); | ||
2541 | #ifndef STYLUS_BASED | ||
2542 | add_menu_separator(GTK_CONTAINER(menu)); | ||
2543 | add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Undo", 'u'); | ||
2544 | add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Redo", 'r'); | ||
2545 | #endif | ||
2546 | if (thegame.can_format_as_text_ever) { | ||
2547 | add_menu_separator(GTK_CONTAINER(menu)); | ||
2548 | menuitem = gtk_menu_item_new_with_label("Copy"); | ||
2549 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
2550 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2551 | G_CALLBACK(menu_copy_event), fe); | ||
2552 | gtk_widget_show(menuitem); | ||
2553 | fe->copy_menu_item = menuitem; | ||
2554 | } else { | ||
2555 | fe->copy_menu_item = NULL; | ||
2556 | } | ||
2557 | if (thegame.can_solve) { | ||
2558 | add_menu_separator(GTK_CONTAINER(menu)); | ||
2559 | menuitem = gtk_menu_item_new_with_label("Solve"); | ||
2560 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
2561 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2562 | G_CALLBACK(menu_solve_event), fe); | ||
2563 | gtk_widget_show(menuitem); | ||
2564 | } | ||
2565 | add_menu_separator(GTK_CONTAINER(menu)); | ||
2566 | add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Exit", 'q'); | ||
2567 | |||
2568 | menuitem = gtk_menu_item_new_with_mnemonic("_Help"); | ||
2569 | gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); | ||
2570 | gtk_widget_show(menuitem); | ||
2571 | |||
2572 | menu = gtk_menu_new(); | ||
2573 | gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu); | ||
2574 | |||
2575 | menuitem = gtk_menu_item_new_with_label("About"); | ||
2576 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
2577 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
2578 | G_CALLBACK(menu_about_event), fe); | ||
2579 | gtk_widget_show(menuitem); | ||
2580 | |||
2581 | #ifdef STYLUS_BASED | ||
2582 | menuitem=gtk_button_new_with_mnemonic("_Redo"); | ||
2583 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
2584 | GINT_TO_POINTER((int)('r'))); | ||
2585 | g_signal_connect(G_OBJECT(menuitem), "clicked", | ||
2586 | G_CALLBACK(menu_key_event), fe); | ||
2587 | gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0); | ||
2588 | gtk_widget_show(menuitem); | ||
2589 | |||
2590 | menuitem=gtk_button_new_with_mnemonic("_Undo"); | ||
2591 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
2592 | GINT_TO_POINTER((int)('u'))); | ||
2593 | g_signal_connect(G_OBJECT(menuitem), "clicked", | ||
2594 | G_CALLBACK(menu_key_event), fe); | ||
2595 | gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0); | ||
2596 | gtk_widget_show(menuitem); | ||
2597 | |||
2598 | if (thegame.flags & REQUIRE_NUMPAD) { | ||
2599 | hbox = GTK_BOX(gtk_hbox_new(FALSE, 0)); | ||
2600 | gtk_box_pack_start(vbox, GTK_WIDGET(hbox), FALSE, FALSE, 0); | ||
2601 | gtk_widget_show(GTK_WIDGET(hbox)); | ||
2602 | |||
2603 | *((int*)errbuf)=0; | ||
2604 | errbuf[1]='\0'; | ||
2605 | for(errbuf[0]='0';errbuf[0]<='9';errbuf[0]++) { | ||
2606 | menuitem=gtk_button_new_with_label(errbuf); | ||
2607 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
2608 | GINT_TO_POINTER((int)(errbuf[0]))); | ||
2609 | g_signal_connect(G_OBJECT(menuitem), "clicked", | ||
2610 | G_CALLBACK(menu_key_event), fe); | ||
2611 | gtk_box_pack_start(hbox, menuitem, TRUE, TRUE, 0); | ||
2612 | gtk_widget_show(menuitem); | ||
2613 | } | ||
2614 | } | ||
2615 | #endif /* STYLUS_BASED */ | ||
2616 | |||
2617 | changed_preset(fe); | ||
2618 | |||
2619 | snaffle_colours(fe); | ||
2620 | |||
2621 | if (midend_wants_statusbar(fe->me)) { | ||
2622 | GtkWidget *viewport; | ||
2623 | GtkRequisition req; | ||
2624 | |||
2625 | viewport = gtk_viewport_new(NULL, NULL); | ||
2626 | gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE); | ||
2627 | fe->statusbar = gtk_statusbar_new(); | ||
2628 | gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar); | ||
2629 | gtk_widget_show(viewport); | ||
2630 | gtk_box_pack_end(vbox, viewport, FALSE, FALSE, 0); | ||
2631 | gtk_widget_show(fe->statusbar); | ||
2632 | fe->statusctx = gtk_statusbar_get_context_id | ||
2633 | (GTK_STATUSBAR(fe->statusbar), "game"); | ||
2634 | gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, | ||
2635 | DEFAULT_STATUSBAR_TEXT); | ||
2636 | #if GTK_CHECK_VERSION(3,0,0) | ||
2637 | gtk_widget_get_preferred_size(fe->statusbar, &req, NULL); | ||
2638 | #else | ||
2639 | gtk_widget_size_request(fe->statusbar, &req); | ||
2640 | #endif | ||
2641 | gtk_widget_set_size_request(viewport, -1, req.height); | ||
2642 | } else | ||
2643 | fe->statusbar = NULL; | ||
2644 | |||
2645 | fe->area = gtk_drawing_area_new(); | ||
2646 | #if GTK_CHECK_VERSION(2,0,0) && !GTK_CHECK_VERSION(3,0,0) | ||
2647 | gtk_widget_set_double_buffered(fe->area, FALSE); | ||
2648 | #endif | ||
2649 | { | ||
2650 | GdkGeometry geom; | ||
2651 | geom.base_width = geom.base_height = 0; | ||
2652 | gtk_window_set_geometry_hints(GTK_WINDOW(fe->window), fe->area, | ||
2653 | &geom, GDK_HINT_BASE_SIZE); | ||
2654 | } | ||
2655 | fe->w = -1; | ||
2656 | fe->h = -1; | ||
2657 | get_size(fe, &x, &y); | ||
2658 | #if GTK_CHECK_VERSION(3,0,0) | ||
2659 | gtk_window_set_default_geometry(GTK_WINDOW(fe->window), x, y); | ||
2660 | #else | ||
2661 | fe->drawing_area_shrink_pending = FALSE; | ||
2662 | gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y); | ||
2663 | #endif | ||
2664 | |||
2665 | gtk_box_pack_end(vbox, fe->area, TRUE, TRUE, 0); | ||
2666 | |||
2667 | clear_backing_store(fe); | ||
2668 | fe->fonts = NULL; | ||
2669 | fe->nfonts = fe->fontsize = 0; | ||
2670 | |||
2671 | fe->paste_data = NULL; | ||
2672 | fe->paste_data_len = 0; | ||
2673 | |||
2674 | g_signal_connect(G_OBJECT(fe->window), "destroy", | ||
2675 | G_CALLBACK(destroy), fe); | ||
2676 | g_signal_connect(G_OBJECT(fe->window), "key_press_event", | ||
2677 | G_CALLBACK(key_event), fe); | ||
2678 | g_signal_connect(G_OBJECT(fe->area), "button_press_event", | ||
2679 | G_CALLBACK(button_event), fe); | ||
2680 | g_signal_connect(G_OBJECT(fe->area), "button_release_event", | ||
2681 | G_CALLBACK(button_event), fe); | ||
2682 | g_signal_connect(G_OBJECT(fe->area), "motion_notify_event", | ||
2683 | G_CALLBACK(motion_event), fe); | ||
2684 | g_signal_connect(G_OBJECT(fe->area), "selection_get", | ||
2685 | G_CALLBACK(selection_get), fe); | ||
2686 | g_signal_connect(G_OBJECT(fe->area), "selection_clear_event", | ||
2687 | G_CALLBACK(selection_clear), fe); | ||
2688 | #if GTK_CHECK_VERSION(3,0,0) | ||
2689 | g_signal_connect(G_OBJECT(fe->area), "draw", | ||
2690 | G_CALLBACK(draw_area), fe); | ||
2691 | #else | ||
2692 | g_signal_connect(G_OBJECT(fe->area), "expose_event", | ||
2693 | G_CALLBACK(expose_area), fe); | ||
2694 | #endif | ||
2695 | g_signal_connect(G_OBJECT(fe->window), "map_event", | ||
2696 | G_CALLBACK(map_window), fe); | ||
2697 | g_signal_connect(G_OBJECT(fe->area), "configure_event", | ||
2698 | G_CALLBACK(configure_area), fe); | ||
2699 | g_signal_connect(G_OBJECT(fe->window), "configure_event", | ||
2700 | G_CALLBACK(configure_window), fe); | ||
2701 | |||
2702 | gtk_widget_add_events(GTK_WIDGET(fe->area), | ||
2703 | GDK_BUTTON_PRESS_MASK | | ||
2704 | GDK_BUTTON_RELEASE_MASK | | ||
2705 | GDK_BUTTON_MOTION_MASK | | ||
2706 | GDK_POINTER_MOTION_HINT_MASK); | ||
2707 | |||
2708 | if (n_xpm_icons) { | ||
2709 | gtk_window_set_icon(GTK_WINDOW(fe->window), | ||
2710 | gdk_pixbuf_new_from_xpm_data | ||
2711 | ((const gchar **)xpm_icons[0])); | ||
2712 | |||
2713 | iconlist = NULL; | ||
2714 | for (n = 0; n < n_xpm_icons; n++) { | ||
2715 | iconlist = | ||
2716 | g_list_append(iconlist, | ||
2717 | gdk_pixbuf_new_from_xpm_data((const gchar **) | ||
2718 | xpm_icons[n])); | ||
2719 | } | ||
2720 | gtk_window_set_icon_list(GTK_WINDOW(fe->window), iconlist); | ||
2721 | } | ||
2722 | |||
2723 | gtk_widget_show(fe->area); | ||
2724 | gtk_widget_show(fe->window); | ||
2725 | |||
2726 | #if !GTK_CHECK_VERSION(3,0,0) | ||
2727 | fe->drawing_area_shrink_pending = TRUE; | ||
2728 | try_shrink_drawing_area(fe); | ||
2729 | #endif | ||
2730 | |||
2731 | set_window_background(fe, 0); | ||
2732 | |||
2733 | return fe; | ||
2734 | } | ||
2735 | |||
2736 | char *fgetline(FILE *fp) | ||
2737 | { | ||
2738 | char *ret = snewn(512, char); | ||
2739 | int size = 512, len = 0; | ||
2740 | while (fgets(ret + len, size - len, fp)) { | ||
2741 | len += strlen(ret + len); | ||
2742 | if (ret[len-1] == '\n') | ||
2743 | break; /* got a newline, we're done */ | ||
2744 | size = len + 512; | ||
2745 | ret = sresize(ret, size, char); | ||
2746 | } | ||
2747 | if (len == 0) { /* first fgets returned NULL */ | ||
2748 | sfree(ret); | ||
2749 | return NULL; | ||
2750 | } | ||
2751 | ret[len] = '\0'; | ||
2752 | return ret; | ||
2753 | } | ||
2754 | |||
2755 | int main(int argc, char **argv) | ||
2756 | { | ||
2757 | char *pname = argv[0]; | ||
2758 | char *error; | ||
2759 | int ngenerate = 0, print = FALSE, px = 1, py = 1; | ||
2760 | int time_generation = FALSE, test_solve = FALSE, list_presets = FALSE; | ||
2761 | int soln = FALSE, colour = FALSE; | ||
2762 | float scale = 1.0F; | ||
2763 | float redo_proportion = 0.0F; | ||
2764 | char *savefile = NULL, *savesuffix = NULL; | ||
2765 | char *arg = NULL; | ||
2766 | int argtype = ARG_EITHER; | ||
2767 | char *screenshot_file = NULL; | ||
2768 | int doing_opts = TRUE; | ||
2769 | int ac = argc; | ||
2770 | char **av = argv; | ||
2771 | char errbuf[500]; | ||
2772 | |||
2773 | /* | ||
2774 | * Command line parsing in this function is rather fiddly, | ||
2775 | * because GTK wants to have a go at argc/argv _first_ - and | ||
2776 | * yet we can't let it, because gtk_init() will bomb out if it | ||
2777 | * can't open an X display, whereas in fact we want to permit | ||
2778 | * our --generate and --print modes to run without an X | ||
2779 | * display. | ||
2780 | * | ||
2781 | * So what we do is: | ||
2782 | * - we parse the command line ourselves, without modifying | ||
2783 | * argc/argv | ||
2784 | * - if we encounter an error which might plausibly be the | ||
2785 | * result of a GTK command line (i.e. not detailed errors in | ||
2786 | * particular options of ours) we store the error message | ||
2787 | * and terminate parsing. | ||
2788 | * - if we got enough out of the command line to know it | ||
2789 | * specifies a non-X mode of operation, we either display | ||
2790 | * the stored error and return failure, or if there is no | ||
2791 | * stored error we do the non-X operation and return | ||
2792 | * success. | ||
2793 | * - otherwise, we go straight to gtk_init(). | ||
2794 | */ | ||
2795 | |||
2796 | errbuf[0] = '\0'; | ||
2797 | while (--ac > 0) { | ||
2798 | char *p = *++av; | ||
2799 | if (doing_opts && !strcmp(p, "--version")) { | ||
2800 | printf("%s, from Simon Tatham's Portable Puzzle Collection\n%s\n", | ||
2801 | thegame.name, ver); | ||
2802 | return 0; | ||
2803 | } else if (doing_opts && !strcmp(p, "--generate")) { | ||
2804 | if (--ac > 0) { | ||
2805 | ngenerate = atoi(*++av); | ||
2806 | if (!ngenerate) { | ||
2807 | fprintf(stderr, "%s: '--generate' expected a number\n", | ||
2808 | pname); | ||
2809 | return 1; | ||
2810 | } | ||
2811 | } else | ||
2812 | ngenerate = 1; | ||
2813 | } else if (doing_opts && !strcmp(p, "--time-generation")) { | ||
2814 | time_generation = TRUE; | ||
2815 | } else if (doing_opts && !strcmp(p, "--test-solve")) { | ||
2816 | test_solve = TRUE; | ||
2817 | } else if (doing_opts && !strcmp(p, "--list-presets")) { | ||
2818 | list_presets = TRUE; | ||
2819 | } else if (doing_opts && !strcmp(p, "--save")) { | ||
2820 | if (--ac > 0) { | ||
2821 | savefile = *++av; | ||
2822 | } else { | ||
2823 | fprintf(stderr, "%s: '--save' expected a filename\n", | ||
2824 | pname); | ||
2825 | return 1; | ||
2826 | } | ||
2827 | } else if (doing_opts && (!strcmp(p, "--save-suffix") || | ||
2828 | !strcmp(p, "--savesuffix"))) { | ||
2829 | if (--ac > 0) { | ||
2830 | savesuffix = *++av; | ||
2831 | } else { | ||
2832 | fprintf(stderr, "%s: '--save-suffix' expected a filename\n", | ||
2833 | pname); | ||
2834 | return 1; | ||
2835 | } | ||
2836 | } else if (doing_opts && !strcmp(p, "--print")) { | ||
2837 | if (!thegame.can_print) { | ||
2838 | fprintf(stderr, "%s: this game does not support printing\n", | ||
2839 | pname); | ||
2840 | return 1; | ||
2841 | } | ||
2842 | print = TRUE; | ||
2843 | if (--ac > 0) { | ||
2844 | char *dim = *++av; | ||
2845 | if (sscanf(dim, "%dx%d", &px, &py) != 2) { | ||
2846 | fprintf(stderr, "%s: unable to parse argument '%s' to " | ||
2847 | "'--print'\n", pname, dim); | ||
2848 | return 1; | ||
2849 | } | ||
2850 | } else { | ||
2851 | px = py = 1; | ||
2852 | } | ||
2853 | } else if (doing_opts && !strcmp(p, "--scale")) { | ||
2854 | if (--ac > 0) { | ||
2855 | scale = atof(*++av); | ||
2856 | } else { | ||
2857 | fprintf(stderr, "%s: no argument supplied to '--scale'\n", | ||
2858 | pname); | ||
2859 | return 1; | ||
2860 | } | ||
2861 | } else if (doing_opts && !strcmp(p, "--redo")) { | ||
2862 | /* | ||
2863 | * This is an internal option which I don't expect | ||
2864 | * users to have any particular use for. The effect of | ||
2865 | * --redo is that once the game has been loaded and | ||
2866 | * initialised, the next move in the redo chain is | ||
2867 | * replayed, and the game screen is redrawn part way | ||
2868 | * through the making of the move. This is only | ||
2869 | * meaningful if there _is_ a next move in the redo | ||
2870 | * chain, which means in turn that this option is only | ||
2871 | * useful if you're also passing a save file on the | ||
2872 | * command line. | ||
2873 | * | ||
2874 | * This option is used by the script which generates | ||
2875 | * the puzzle icons and website screenshots, and I | ||
2876 | * don't imagine it's useful for anything else. | ||
2877 | * (Unless, I suppose, users don't like my screenshots | ||
2878 | * and want to generate their own in the same way for | ||
2879 | * some repackaged version of the puzzles.) | ||
2880 | */ | ||
2881 | if (--ac > 0) { | ||
2882 | redo_proportion = atof(*++av); | ||
2883 | } else { | ||
2884 | fprintf(stderr, "%s: no argument supplied to '--redo'\n", | ||
2885 | pname); | ||
2886 | return 1; | ||
2887 | } | ||
2888 | } else if (doing_opts && !strcmp(p, "--screenshot")) { | ||
2889 | /* | ||
2890 | * Another internal option for the icon building | ||
2891 | * script. This causes a screenshot of the central | ||
2892 | * drawing area (i.e. not including the menu bar or | ||
2893 | * status bar) to be saved to a PNG file once the | ||
2894 | * window has been drawn, and then the application | ||
2895 | * quits immediately. | ||
2896 | */ | ||
2897 | if (--ac > 0) { | ||
2898 | screenshot_file = *++av; | ||
2899 | } else { | ||
2900 | fprintf(stderr, "%s: no argument supplied to '--screenshot'\n", | ||
2901 | pname); | ||
2902 | return 1; | ||
2903 | } | ||
2904 | } else if (doing_opts && (!strcmp(p, "--with-solutions") || | ||
2905 | !strcmp(p, "--with-solution") || | ||
2906 | !strcmp(p, "--with-solns") || | ||
2907 | !strcmp(p, "--with-soln") || | ||
2908 | !strcmp(p, "--solutions") || | ||
2909 | !strcmp(p, "--solution") || | ||
2910 | !strcmp(p, "--solns") || | ||
2911 | !strcmp(p, "--soln"))) { | ||
2912 | soln = TRUE; | ||
2913 | } else if (doing_opts && !strcmp(p, "--colour")) { | ||
2914 | if (!thegame.can_print_in_colour) { | ||
2915 | fprintf(stderr, "%s: this game does not support colour" | ||
2916 | " printing\n", pname); | ||
2917 | return 1; | ||
2918 | } | ||
2919 | colour = TRUE; | ||
2920 | } else if (doing_opts && !strcmp(p, "--load")) { | ||
2921 | argtype = ARG_SAVE; | ||
2922 | } else if (doing_opts && !strcmp(p, "--game")) { | ||
2923 | argtype = ARG_ID; | ||
2924 | } else if (doing_opts && !strcmp(p, "--")) { | ||
2925 | doing_opts = FALSE; | ||
2926 | } else if (!doing_opts || p[0] != '-') { | ||
2927 | if (arg) { | ||
2928 | fprintf(stderr, "%s: more than one argument supplied\n", | ||
2929 | pname); | ||
2930 | return 1; | ||
2931 | } | ||
2932 | arg = p; | ||
2933 | } else { | ||
2934 | sprintf(errbuf, "%.100s: unrecognised option '%.100s'\n", | ||
2935 | pname, p); | ||
2936 | break; | ||
2937 | } | ||
2938 | } | ||
2939 | |||
2940 | /* | ||
2941 | * Special standalone mode for generating puzzle IDs on the | ||
2942 | * command line. Useful for generating puzzles to be printed | ||
2943 | * out and solved offline (for puzzles where that even makes | ||
2944 | * sense - Solo, for example, is a lot more pencil-and-paper | ||
2945 | * friendly than Twiddle!) | ||
2946 | * | ||
2947 | * Usage: | ||
2948 | * | ||
2949 | * <puzzle-name> --generate [<n> [<params>]] | ||
2950 | * | ||
2951 | * <n>, if present, is the number of puzzle IDs to generate. | ||
2952 | * <params>, if present, is the same type of parameter string | ||
2953 | * you would pass to the puzzle when running it in GUI mode, | ||
2954 | * including optional extras such as the expansion factor in | ||
2955 | * Rectangles and the difficulty level in Solo. | ||
2956 | * | ||
2957 | * If you specify <params>, you must also specify <n> (although | ||
2958 | * you may specify it to be 1). Sorry; that was the | ||
2959 | * simplest-to-parse command-line syntax I came up with. | ||
2960 | */ | ||
2961 | if (ngenerate > 0 || print || savefile || savesuffix) { | ||
2962 | int i, n = 1; | ||
2963 | midend *me; | ||
2964 | char *id; | ||
2965 | document *doc = NULL; | ||
2966 | |||
2967 | /* | ||
2968 | * If we're in this branch, we should display any pending | ||
2969 | * error message from the command line, since GTK isn't going | ||
2970 | * to take another crack at making sense of it. | ||
2971 | */ | ||
2972 | if (*errbuf) { | ||
2973 | fputs(errbuf, stderr); | ||
2974 | return 1; | ||
2975 | } | ||
2976 | |||
2977 | n = ngenerate; | ||
2978 | |||
2979 | me = midend_new(NULL, &thegame, NULL, NULL); | ||
2980 | i = 0; | ||
2981 | |||
2982 | if (savefile && !savesuffix) | ||
2983 | savesuffix = ""; | ||
2984 | if (!savefile && savesuffix) | ||
2985 | savefile = ""; | ||
2986 | |||
2987 | if (print) | ||
2988 | doc = document_new(px, py, scale); | ||
2989 | |||
2990 | /* | ||
2991 | * In this loop, we either generate a game ID or read one | ||
2992 | * from stdin depending on whether we're in generate mode; | ||
2993 | * then we either write it to stdout or print it, depending | ||
2994 | * on whether we're in print mode. Thus, this loop handles | ||
2995 | * generate-to-stdout, print-from-stdin and generate-and- | ||
2996 | * immediately-print modes. | ||
2997 | * | ||
2998 | * (It could also handle a copy-stdin-to-stdout mode, | ||
2999 | * although there's currently no combination of options | ||
3000 | * which will cause this loop to be activated in that mode. | ||
3001 | * It wouldn't be _entirely_ pointless, though, because | ||
3002 | * stdin could contain bare params strings or random-seed | ||
3003 | * IDs, and stdout would contain nothing but fully | ||
3004 | * generated descriptive game IDs.) | ||
3005 | */ | ||
3006 | while (ngenerate == 0 || i < n) { | ||
3007 | char *pstr, *err, *seed; | ||
3008 | struct rusage before, after; | ||
3009 | |||
3010 | if (ngenerate == 0) { | ||
3011 | pstr = fgetline(stdin); | ||
3012 | if (!pstr) | ||
3013 | break; | ||
3014 | pstr[strcspn(pstr, "\r\n")] = '\0'; | ||
3015 | } else { | ||
3016 | if (arg) { | ||
3017 | pstr = snewn(strlen(arg) + 40, char); | ||
3018 | |||
3019 | strcpy(pstr, arg); | ||
3020 | if (i > 0 && strchr(arg, '#')) | ||
3021 | sprintf(pstr + strlen(pstr), "-%d", i); | ||
3022 | } else | ||
3023 | pstr = NULL; | ||
3024 | } | ||
3025 | |||
3026 | if (pstr) { | ||
3027 | err = midend_game_id(me, pstr); | ||
3028 | if (err) { | ||
3029 | fprintf(stderr, "%s: error parsing '%s': %s\n", | ||
3030 | pname, pstr, err); | ||
3031 | return 1; | ||
3032 | } | ||
3033 | } | ||
3034 | |||
3035 | if (time_generation) | ||
3036 | getrusage(RUSAGE_SELF, &before); | ||
3037 | |||
3038 | midend_new_game(me); | ||
3039 | |||
3040 | seed = midend_get_random_seed(me); | ||
3041 | |||
3042 | if (time_generation) { | ||
3043 | double elapsed; | ||
3044 | |||
3045 | getrusage(RUSAGE_SELF, &after); | ||
3046 | |||
3047 | elapsed = (after.ru_utime.tv_sec - | ||
3048 | before.ru_utime.tv_sec); | ||
3049 | elapsed += (after.ru_utime.tv_usec - | ||
3050 | before.ru_utime.tv_usec) / 1000000.0; | ||
3051 | |||
3052 | printf("%s %s: %.6f\n", thegame.name, seed, elapsed); | ||
3053 | } | ||
3054 | |||
3055 | if (test_solve && thegame.can_solve) { | ||
3056 | /* | ||
3057 | * Now destroy the aux_info in the midend, by means of | ||
3058 | * re-entering the same game id, and then try to solve | ||
3059 | * it. | ||
3060 | */ | ||
3061 | char *game_id, *err; | ||
3062 | |||
3063 | game_id = midend_get_game_id(me); | ||
3064 | err = midend_game_id(me, game_id); | ||
3065 | if (err) { | ||
3066 | fprintf(stderr, "%s %s: game id re-entry error: %s\n", | ||
3067 | thegame.name, seed, err); | ||
3068 | return 1; | ||
3069 | } | ||
3070 | midend_new_game(me); | ||
3071 | sfree(game_id); | ||
3072 | |||
3073 | err = midend_solve(me); | ||
3074 | /* | ||
3075 | * If the solve operation returned the error "Solution | ||
3076 | * not known for this puzzle", that's OK, because that | ||
3077 | * just means it's a puzzle for which we don't have an | ||
3078 | * algorithmic solver and hence can't solve it without | ||
3079 | * the aux_info, e.g. Netslide. Any other error is a | ||
3080 | * problem, though. | ||
3081 | */ | ||
3082 | if (err && strcmp(err, "Solution not known for this puzzle")) { | ||
3083 | fprintf(stderr, "%s %s: solve error: %s\n", | ||
3084 | thegame.name, seed, err); | ||
3085 | return 1; | ||
3086 | } | ||
3087 | } | ||
3088 | |||
3089 | sfree(pstr); | ||
3090 | sfree(seed); | ||
3091 | |||
3092 | if (doc) { | ||
3093 | err = midend_print_puzzle(me, doc, soln); | ||
3094 | if (err) { | ||
3095 | fprintf(stderr, "%s: error in printing: %s\n", pname, err); | ||
3096 | return 1; | ||
3097 | } | ||
3098 | } | ||
3099 | if (savefile) { | ||
3100 | struct savefile_write_ctx ctx; | ||
3101 | char *realname = snewn(40 + strlen(savefile) + | ||
3102 | strlen(savesuffix), char); | ||
3103 | sprintf(realname, "%s%d%s", savefile, i, savesuffix); | ||
3104 | |||
3105 | if (soln) { | ||
3106 | char *err = midend_solve(me); | ||
3107 | if (err) { | ||
3108 | fprintf(stderr, "%s: unable to show solution: %s\n", | ||
3109 | realname, err); | ||
3110 | return 1; | ||
3111 | } | ||
3112 | } | ||
3113 | |||
3114 | ctx.fp = fopen(realname, "w"); | ||
3115 | if (!ctx.fp) { | ||
3116 | fprintf(stderr, "%s: open: %s\n", realname, | ||
3117 | strerror(errno)); | ||
3118 | return 1; | ||
3119 | } | ||
3120 | ctx.error = 0; | ||
3121 | midend_serialise(me, savefile_write, &ctx); | ||
3122 | if (ctx.error) { | ||
3123 | fprintf(stderr, "%s: write: %s\n", realname, | ||
3124 | strerror(ctx.error)); | ||
3125 | return 1; | ||
3126 | } | ||
3127 | if (fclose(ctx.fp)) { | ||
3128 | fprintf(stderr, "%s: close: %s\n", realname, | ||
3129 | strerror(errno)); | ||
3130 | return 1; | ||
3131 | } | ||
3132 | sfree(realname); | ||
3133 | } | ||
3134 | if (!doc && !savefile && !time_generation) { | ||
3135 | id = midend_get_game_id(me); | ||
3136 | puts(id); | ||
3137 | sfree(id); | ||
3138 | } | ||
3139 | |||
3140 | i++; | ||
3141 | } | ||
3142 | |||
3143 | if (doc) { | ||
3144 | psdata *ps = ps_init(stdout, colour); | ||
3145 | document_print(doc, ps_drawing_api(ps)); | ||
3146 | document_free(doc); | ||
3147 | ps_free(ps); | ||
3148 | } | ||
3149 | |||
3150 | midend_free(me); | ||
3151 | |||
3152 | return 0; | ||
3153 | } else if (list_presets) { | ||
3154 | /* | ||
3155 | * Another specialist mode which causes the puzzle to list the | ||
3156 | * game_params strings for all its preset configurations. | ||
3157 | */ | ||
3158 | int i, npresets; | ||
3159 | midend *me; | ||
3160 | |||
3161 | me = midend_new(NULL, &thegame, NULL, NULL); | ||
3162 | npresets = midend_num_presets(me); | ||
3163 | |||
3164 | for (i = 0; i < npresets; i++) { | ||
3165 | game_params *params; | ||
3166 | char *name, *paramstr; | ||
3167 | |||
3168 | midend_fetch_preset(me, i, &name, ¶ms); | ||
3169 | paramstr = thegame.encode_params(params, TRUE); | ||
3170 | |||
3171 | printf("%s %s\n", paramstr, name); | ||
3172 | sfree(paramstr); | ||
3173 | } | ||
3174 | |||
3175 | midend_free(me); | ||
3176 | return 0; | ||
3177 | } else { | ||
3178 | frontend *fe; | ||
3179 | |||
3180 | gtk_init(&argc, &argv); | ||
3181 | |||
3182 | fe = new_window(arg, argtype, &error); | ||
3183 | |||
3184 | if (!fe) { | ||
3185 | fprintf(stderr, "%s: %s\n", pname, error); | ||
3186 | return 1; | ||
3187 | } | ||
3188 | |||
3189 | if (screenshot_file) { | ||
3190 | /* | ||
3191 | * Some puzzles will not redraw their entire area if | ||
3192 | * given a partially completed animation, which means | ||
3193 | * we must redraw now and _then_ redraw again after | ||
3194 | * freezing the move timer. | ||
3195 | */ | ||
3196 | midend_force_redraw(fe->me); | ||
3197 | } | ||
3198 | |||
3199 | if (redo_proportion) { | ||
3200 | /* Start a redo. */ | ||
3201 | midend_process_key(fe->me, 0, 0, 'r'); | ||
3202 | /* And freeze the timer at the specified position. */ | ||
3203 | midend_freeze_timer(fe->me, redo_proportion); | ||
3204 | } | ||
3205 | |||
3206 | if (screenshot_file) { | ||
3207 | save_screenshot_png(fe, screenshot_file); | ||
3208 | exit(0); | ||
3209 | } | ||
3210 | |||
3211 | gtk_main(); | ||
3212 | } | ||
3213 | |||
3214 | return 0; | ||
3215 | } | ||