diff options
Diffstat (limited to 'apps/plugins/puzzles/src/gtk.c')
-rw-r--r-- | apps/plugins/puzzles/src/gtk.c | 4031 |
1 files changed, 0 insertions, 4031 deletions
diff --git a/apps/plugins/puzzles/src/gtk.c b/apps/plugins/puzzles/src/gtk.c deleted file mode 100644 index 7588ee0dc6..0000000000 --- a/apps/plugins/puzzles/src/gtk.c +++ /dev/null | |||
@@ -1,4031 +0,0 @@ | |||
1 | /* | ||
2 | * gtk.c: GTK front end for my puzzle collection. | ||
3 | */ | ||
4 | |||
5 | #include <stdio.h> | ||
6 | #include <assert.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 defined USE_CAIRO && GTK_CHECK_VERSION(2,10,0) | ||
48 | /* We can only use printing if we are using Cairo for drawing and we | ||
49 | have a GTK version >= 2.10 (when GtkPrintOperation was added). */ | ||
50 | # define USE_PRINTING | ||
51 | # if GTK_CHECK_VERSION(2,18,0) | ||
52 | /* We can embed the page setup. Before 2.18, we needed to have a | ||
53 | separate page setup. */ | ||
54 | # define USE_EMBED_PAGE_SETUP | ||
55 | # endif | ||
56 | #endif | ||
57 | |||
58 | #if GTK_CHECK_VERSION(3,0,0) | ||
59 | /* The old names are still more concise! */ | ||
60 | #define gtk_hbox_new(x,y) gtk_box_new(GTK_ORIENTATION_HORIZONTAL,y) | ||
61 | #define gtk_vbox_new(x,y) gtk_box_new(GTK_ORIENTATION_VERTICAL,y) | ||
62 | /* GTK 3 has retired stock button labels */ | ||
63 | #define LABEL_OK "_OK" | ||
64 | #define LABEL_CANCEL "_Cancel" | ||
65 | #define LABEL_NO "_No" | ||
66 | #define LABEL_YES "_Yes" | ||
67 | #define LABEL_SAVE "_Save" | ||
68 | #define LABEL_OPEN "_Open" | ||
69 | #define gtk_button_new_with_our_label gtk_button_new_with_mnemonic | ||
70 | #else | ||
71 | #define LABEL_OK GTK_STOCK_OK | ||
72 | #define LABEL_CANCEL GTK_STOCK_CANCEL | ||
73 | #define LABEL_NO GTK_STOCK_NO | ||
74 | #define LABEL_YES GTK_STOCK_YES | ||
75 | #define LABEL_SAVE GTK_STOCK_SAVE | ||
76 | #define LABEL_OPEN GTK_STOCK_OPEN | ||
77 | #define gtk_button_new_with_our_label gtk_button_new_from_stock | ||
78 | #endif | ||
79 | |||
80 | /* #undef USE_CAIRO */ | ||
81 | /* #define NO_THICK_LINE */ | ||
82 | #ifdef DEBUGGING | ||
83 | static FILE *debug_fp = NULL; | ||
84 | |||
85 | void dputs(const char *buf) | ||
86 | { | ||
87 | if (!debug_fp) { | ||
88 | debug_fp = fopen("debug.log", "w"); | ||
89 | } | ||
90 | |||
91 | fputs(buf, stderr); | ||
92 | |||
93 | if (debug_fp) { | ||
94 | fputs(buf, debug_fp); | ||
95 | fflush(debug_fp); | ||
96 | } | ||
97 | } | ||
98 | |||
99 | void debug_printf(const char *fmt, ...) | ||
100 | { | ||
101 | char buf[4096]; | ||
102 | va_list ap; | ||
103 | |||
104 | va_start(ap, fmt); | ||
105 | vsprintf(buf, fmt, ap); | ||
106 | dputs(buf); | ||
107 | va_end(ap); | ||
108 | } | ||
109 | #endif | ||
110 | |||
111 | /* ---------------------------------------------------------------------- | ||
112 | * Error reporting functions used elsewhere. | ||
113 | */ | ||
114 | |||
115 | void fatal(const char *fmt, ...) | ||
116 | { | ||
117 | va_list ap; | ||
118 | |||
119 | fprintf(stderr, "fatal error: "); | ||
120 | |||
121 | va_start(ap, fmt); | ||
122 | vfprintf(stderr, fmt, ap); | ||
123 | va_end(ap); | ||
124 | |||
125 | fprintf(stderr, "\n"); | ||
126 | exit(1); | ||
127 | } | ||
128 | |||
129 | /* ---------------------------------------------------------------------- | ||
130 | * GTK front end to puzzles. | ||
131 | */ | ||
132 | |||
133 | static void changed_preset(frontend *fe); | ||
134 | |||
135 | struct font { | ||
136 | #ifdef USE_PANGO | ||
137 | PangoFontDescription *desc; | ||
138 | #else | ||
139 | GdkFont *font; | ||
140 | #endif | ||
141 | int type; | ||
142 | int size; | ||
143 | }; | ||
144 | |||
145 | /* | ||
146 | * An internal API for functions which need to be different for | ||
147 | * printing and drawing. | ||
148 | */ | ||
149 | struct internal_drawing_api { | ||
150 | void (*set_colour)(frontend *fe, int colour); | ||
151 | #ifdef USE_CAIRO | ||
152 | void (*fill)(frontend *fe); | ||
153 | void (*fill_preserve)(frontend *fe); | ||
154 | #endif | ||
155 | }; | ||
156 | |||
157 | /* | ||
158 | * This structure holds all the data relevant to a single window. | ||
159 | * In principle this would allow us to open multiple independent | ||
160 | * puzzle windows, although I can't currently see any real point in | ||
161 | * doing so. I'm just coding cleanly because there's no | ||
162 | * particularly good reason not to. | ||
163 | */ | ||
164 | struct frontend { | ||
165 | bool headless; /* true if we're running without GTK, for --screenshot */ | ||
166 | |||
167 | GtkWidget *window; | ||
168 | GtkAccelGroup *dummy_accelgroup; | ||
169 | GtkWidget *area; | ||
170 | GtkWidget *statusbar; | ||
171 | GtkWidget *menubar; | ||
172 | #if GTK_CHECK_VERSION(3,20,0) | ||
173 | GtkCssProvider *css_provider; | ||
174 | #endif | ||
175 | guint statusctx; | ||
176 | int w, h; | ||
177 | midend *me; | ||
178 | #ifdef USE_CAIRO | ||
179 | const float *colours; | ||
180 | cairo_t *cr; | ||
181 | cairo_surface_t *image; | ||
182 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
183 | GdkPixmap *pixmap; | ||
184 | #endif | ||
185 | GdkColor background; /* for painting outside puzzle area */ | ||
186 | #else | ||
187 | GdkPixmap *pixmap; | ||
188 | GdkGC *gc; | ||
189 | GdkColor *colours; | ||
190 | GdkColormap *colmap; | ||
191 | int backgroundindex; /* which of colours[] is background */ | ||
192 | #endif | ||
193 | int ncolours; | ||
194 | int bbox_l, bbox_r, bbox_u, bbox_d; | ||
195 | bool timer_active; | ||
196 | int timer_id; | ||
197 | struct timeval last_time; | ||
198 | struct font *fonts; | ||
199 | int nfonts, fontsize; | ||
200 | config_item *cfg; | ||
201 | int cfg_which; | ||
202 | bool cfgret; | ||
203 | GtkWidget *cfgbox; | ||
204 | void *paste_data; | ||
205 | int paste_data_len; | ||
206 | int pw, ph, ps; /* pixmap size (w, h are area size, s is GDK scale) */ | ||
207 | int ox, oy; /* offset of pixmap in drawing area */ | ||
208 | #ifdef OLD_FILESEL | ||
209 | char *filesel_name; | ||
210 | #endif | ||
211 | GSList *preset_radio; | ||
212 | bool preset_threaded; | ||
213 | GtkWidget *preset_custom; | ||
214 | GtkWidget *copy_menu_item; | ||
215 | #if !GTK_CHECK_VERSION(3,0,0) | ||
216 | bool drawing_area_shrink_pending; | ||
217 | bool menubar_is_local; | ||
218 | #endif | ||
219 | #if GTK_CHECK_VERSION(3,0,0) | ||
220 | /* | ||
221 | * This is used to get round an annoying lack of GTK notification | ||
222 | * message. If we request a window resize with | ||
223 | * gtk_window_resize(), we normally get back a "configure" event | ||
224 | * on the window and on its drawing area, and we respond to the | ||
225 | * latter by doing an appropriate resize of the puzzle. If the | ||
226 | * window is maximised, so that gtk_window_resize() _doesn't_ | ||
227 | * change its size, then that configure event never shows up. But | ||
228 | * if we requested the resize in response to a change of puzzle | ||
229 | * parameters (say, the user selected a differently-sized preset | ||
230 | * from the menu), then we would still like to be _notified_ that | ||
231 | * the window size was staying the same, so that we can respond by | ||
232 | * choosing an appropriate tile size for the new puzzle preset in | ||
233 | * the existing window size. | ||
234 | * | ||
235 | * Fortunately, in GTK 3, we may not get a "configure" event on | ||
236 | * the drawing area in this situation, but we still get a | ||
237 | * "size_allocate" event on the whole window (which, in other | ||
238 | * situations when we _do_ get a "configure" on the area, turns up | ||
239 | * second). So we treat _that_ event as indicating that if the | ||
240 | * "configure" event hasn't already shown up then it's not going | ||
241 | * to arrive. | ||
242 | * | ||
243 | * This flag is where we bookkeep this system. On | ||
244 | * gtk_window_resize we set this flag to true; the area's | ||
245 | * configure handler sets it back to false; then if that doesn't | ||
246 | * happen, the window's size_allocate handler does a fallback | ||
247 | * puzzle resize when it sees this flag still set to true. | ||
248 | */ | ||
249 | bool awaiting_resize_ack; | ||
250 | #endif | ||
251 | #ifdef USE_CAIRO | ||
252 | int printcount, printw, printh; | ||
253 | float printscale; | ||
254 | bool printsolns, printcolour; | ||
255 | int hatch; | ||
256 | float hatchthick, hatchspace; | ||
257 | drawing *print_dr; | ||
258 | document *doc; | ||
259 | #endif | ||
260 | #ifdef USE_PRINTING | ||
261 | GtkPrintOperation *printop; | ||
262 | GtkPrintContext *printcontext; | ||
263 | GtkSpinButton *printcount_spin_button, *printw_spin_button, | ||
264 | *printh_spin_button, *printscale_spin_button; | ||
265 | GtkCheckButton *soln_check_button, *colour_check_button; | ||
266 | #endif | ||
267 | const struct internal_drawing_api *dr_api; | ||
268 | }; | ||
269 | |||
270 | struct blitter { | ||
271 | #ifdef USE_CAIRO | ||
272 | cairo_surface_t *image; | ||
273 | #else | ||
274 | GdkPixmap *pixmap; | ||
275 | #endif | ||
276 | int w, h, x, y; | ||
277 | }; | ||
278 | |||
279 | void get_random_seed(void **randseed, int *randseedsize) | ||
280 | { | ||
281 | struct timeval *tvp = snew(struct timeval); | ||
282 | gettimeofday(tvp, NULL); | ||
283 | *randseed = (void *)tvp; | ||
284 | *randseedsize = sizeof(struct timeval); | ||
285 | } | ||
286 | |||
287 | void frontend_default_colour(frontend *fe, float *output) | ||
288 | { | ||
289 | #if !GTK_CHECK_VERSION(3,0,0) | ||
290 | if (!fe->headless) { | ||
291 | /* | ||
292 | * If we have a widget and it has a style that specifies a | ||
293 | * default background colour, use that as the background for | ||
294 | * the puzzle drawing area. | ||
295 | */ | ||
296 | GdkColor col = gtk_widget_get_style(fe->window)->bg[GTK_STATE_NORMAL]; | ||
297 | output[0] = col.red / 65535.0; | ||
298 | output[1] = col.green / 65535.0; | ||
299 | output[2] = col.blue / 65535.0; | ||
300 | } | ||
301 | #endif | ||
302 | |||
303 | /* | ||
304 | * GTK 3 has decided that there's no such thing as a 'default | ||
305 | * background colour' any more, because widget styles might set | ||
306 | * the background to something more complicated like a background | ||
307 | * image. We don't want to get into overlaying our entire puzzle | ||
308 | * on an arbitrary background image, so we'll just make up a | ||
309 | * reasonable shade of grey. | ||
310 | * | ||
311 | * This is also what we do on GTK 2 in headless mode, where we | ||
312 | * don't have a widget style to query. | ||
313 | */ | ||
314 | output[0] = output[1] = output[2] = 0.9F; | ||
315 | } | ||
316 | |||
317 | void gtk_status_bar(void *handle, const char *text) | ||
318 | { | ||
319 | frontend *fe = (frontend *)handle; | ||
320 | |||
321 | if (fe->headless) | ||
322 | return; | ||
323 | |||
324 | assert(fe->statusbar); | ||
325 | |||
326 | gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx); | ||
327 | gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, text); | ||
328 | } | ||
329 | |||
330 | /* ---------------------------------------------------------------------- | ||
331 | * Cairo drawing functions. | ||
332 | */ | ||
333 | |||
334 | #ifdef USE_CAIRO | ||
335 | |||
336 | static void setup_drawing(frontend *fe) | ||
337 | { | ||
338 | fe->cr = cairo_create(fe->image); | ||
339 | cairo_scale(fe->cr, fe->ps, fe->ps); | ||
340 | cairo_set_antialias(fe->cr, CAIRO_ANTIALIAS_GRAY); | ||
341 | cairo_set_line_width(fe->cr, 1.0); | ||
342 | cairo_set_line_cap(fe->cr, CAIRO_LINE_CAP_SQUARE); | ||
343 | cairo_set_line_join(fe->cr, CAIRO_LINE_JOIN_ROUND); | ||
344 | } | ||
345 | |||
346 | static void teardown_drawing(frontend *fe) | ||
347 | { | ||
348 | cairo_destroy(fe->cr); | ||
349 | fe->cr = NULL; | ||
350 | |||
351 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
352 | if (!fe->headless) { | ||
353 | cairo_t *cr = gdk_cairo_create(fe->pixmap); | ||
354 | cairo_set_source_surface(cr, fe->image, 0, 0); | ||
355 | cairo_rectangle(cr, | ||
356 | fe->bbox_l - 1, | ||
357 | fe->bbox_u - 1, | ||
358 | fe->bbox_r - fe->bbox_l + 2, | ||
359 | fe->bbox_d - fe->bbox_u + 2); | ||
360 | cairo_fill(cr); | ||
361 | cairo_destroy(cr); | ||
362 | } | ||
363 | #endif | ||
364 | } | ||
365 | |||
366 | static void snaffle_colours(frontend *fe) | ||
367 | { | ||
368 | fe->colours = midend_colours(fe->me, &fe->ncolours); | ||
369 | } | ||
370 | |||
371 | static void draw_set_colour(frontend *fe, int colour) | ||
372 | { | ||
373 | cairo_set_source_rgb(fe->cr, | ||
374 | fe->colours[3*colour + 0], | ||
375 | fe->colours[3*colour + 1], | ||
376 | fe->colours[3*colour + 2]); | ||
377 | } | ||
378 | |||
379 | static void print_set_colour(frontend *fe, int colour) | ||
380 | { | ||
381 | float r, g, b; | ||
382 | |||
383 | print_get_colour(fe->print_dr, colour, fe->printcolour, | ||
384 | &(fe->hatch), &r, &g, &b); | ||
385 | |||
386 | if (fe->hatch < 0) | ||
387 | cairo_set_source_rgb(fe->cr, r, g, b); | ||
388 | } | ||
389 | |||
390 | static void set_window_background(frontend *fe, int colour) | ||
391 | { | ||
392 | #if GTK_CHECK_VERSION(3,20,0) | ||
393 | char css_buf[512]; | ||
394 | sprintf(css_buf, ".background { " | ||
395 | "background-color: #%02x%02x%02x; }", | ||
396 | (unsigned)(fe->colours[3*colour + 0] * 255), | ||
397 | (unsigned)(fe->colours[3*colour + 1] * 255), | ||
398 | (unsigned)(fe->colours[3*colour + 2] * 255)); | ||
399 | if (!fe->css_provider) | ||
400 | fe->css_provider = gtk_css_provider_new(); | ||
401 | if (!gtk_css_provider_load_from_data( | ||
402 | GTK_CSS_PROVIDER(fe->css_provider), css_buf, -1, NULL)) | ||
403 | assert(0 && "Couldn't load CSS"); | ||
404 | gtk_style_context_add_provider( | ||
405 | gtk_widget_get_style_context(fe->window), | ||
406 | GTK_STYLE_PROVIDER(fe->css_provider), | ||
407 | GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); | ||
408 | gtk_style_context_add_provider( | ||
409 | gtk_widget_get_style_context(fe->area), | ||
410 | GTK_STYLE_PROVIDER(fe->css_provider), | ||
411 | GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); | ||
412 | #elif GTK_CHECK_VERSION(3,0,0) | ||
413 | GdkRGBA rgba; | ||
414 | rgba.red = fe->colours[3*colour + 0]; | ||
415 | rgba.green = fe->colours[3*colour + 1]; | ||
416 | rgba.blue = fe->colours[3*colour + 2]; | ||
417 | rgba.alpha = 1.0; | ||
418 | gdk_window_set_background_rgba(gtk_widget_get_window(fe->area), &rgba); | ||
419 | gdk_window_set_background_rgba(gtk_widget_get_window(fe->window), &rgba); | ||
420 | #else | ||
421 | GdkColormap *colmap; | ||
422 | |||
423 | colmap = gdk_colormap_get_system(); | ||
424 | fe->background.red = fe->colours[3*colour + 0] * 65535; | ||
425 | fe->background.green = fe->colours[3*colour + 1] * 65535; | ||
426 | fe->background.blue = fe->colours[3*colour + 2] * 65535; | ||
427 | if (!gdk_colormap_alloc_color(colmap, &fe->background, false, false)) { | ||
428 | g_error("couldn't allocate background (#%02x%02x%02x)\n", | ||
429 | fe->background.red >> 8, fe->background.green >> 8, | ||
430 | fe->background.blue >> 8); | ||
431 | } | ||
432 | gdk_window_set_background(gtk_widget_get_window(fe->area), | ||
433 | &fe->background); | ||
434 | gdk_window_set_background(gtk_widget_get_window(fe->window), | ||
435 | &fe->background); | ||
436 | #endif | ||
437 | } | ||
438 | |||
439 | static PangoLayout *make_pango_layout(frontend *fe) | ||
440 | { | ||
441 | return (pango_cairo_create_layout(fe->cr)); | ||
442 | } | ||
443 | |||
444 | static void draw_pango_layout(frontend *fe, PangoLayout *layout, | ||
445 | int x, int y) | ||
446 | { | ||
447 | cairo_move_to(fe->cr, x, y); | ||
448 | pango_cairo_show_layout(fe->cr, layout); | ||
449 | } | ||
450 | |||
451 | static void save_screenshot_png(frontend *fe, const char *screenshot_file) | ||
452 | { | ||
453 | cairo_surface_write_to_png(fe->image, screenshot_file); | ||
454 | } | ||
455 | |||
456 | static void do_hatch(frontend *fe) | ||
457 | { | ||
458 | double i, x, y, width, height, maxdim; | ||
459 | |||
460 | /* Get the dimensions of the region to be hatched. */ | ||
461 | cairo_path_extents(fe->cr, &x, &y, &width, &height); | ||
462 | |||
463 | maxdim = max(width, height); | ||
464 | |||
465 | cairo_save(fe->cr); | ||
466 | |||
467 | /* Set the line color and width. */ | ||
468 | cairo_set_source_rgb(fe->cr, 0, 0, 0); | ||
469 | cairo_set_line_width(fe->cr, fe->hatchthick); | ||
470 | /* Clip to the region. */ | ||
471 | cairo_clip(fe->cr); | ||
472 | /* Hatch the bounding area of the fill region. */ | ||
473 | if (fe->hatch == HATCH_VERT || fe->hatch == HATCH_PLUS) { | ||
474 | for (i = 0.0; i <= width; i += fe->hatchspace) { | ||
475 | cairo_move_to(fe->cr, i, 0); | ||
476 | cairo_rel_line_to(fe->cr, 0, height); | ||
477 | } | ||
478 | } | ||
479 | if (fe->hatch == HATCH_HORIZ || fe->hatch == HATCH_PLUS) { | ||
480 | for (i = 0.0; i <= height; i += fe->hatchspace) { | ||
481 | cairo_move_to(fe->cr, 0, i); | ||
482 | cairo_rel_line_to(fe->cr, width, 0); | ||
483 | } | ||
484 | } | ||
485 | if (fe->hatch == HATCH_SLASH || fe->hatch == HATCH_X) { | ||
486 | for (i = -height; i <= width; i += fe->hatchspace * ROOT2) { | ||
487 | cairo_move_to(fe->cr, i, 0); | ||
488 | cairo_rel_line_to(fe->cr, maxdim, maxdim); | ||
489 | } | ||
490 | } | ||
491 | if (fe->hatch == HATCH_BACKSLASH || fe->hatch == HATCH_X) { | ||
492 | for (i = 0.0; i <= width + height; i += fe->hatchspace * ROOT2) { | ||
493 | cairo_move_to(fe->cr, i, 0); | ||
494 | cairo_rel_line_to(fe->cr, -maxdim, maxdim); | ||
495 | } | ||
496 | } | ||
497 | cairo_stroke(fe->cr); | ||
498 | |||
499 | cairo_restore(fe->cr); | ||
500 | } | ||
501 | |||
502 | static void do_draw_fill(frontend *fe) | ||
503 | { | ||
504 | cairo_fill(fe->cr); | ||
505 | } | ||
506 | |||
507 | static void do_draw_fill_preserve(frontend *fe) | ||
508 | { | ||
509 | cairo_fill_preserve(fe->cr); | ||
510 | } | ||
511 | |||
512 | static void do_print_fill(frontend *fe) | ||
513 | { | ||
514 | if (fe->hatch < 0) | ||
515 | cairo_fill(fe->cr); | ||
516 | else | ||
517 | do_hatch(fe); | ||
518 | } | ||
519 | |||
520 | static void do_print_fill_preserve(frontend *fe) | ||
521 | { | ||
522 | if (fe->hatch < 0) { | ||
523 | cairo_fill_preserve(fe->cr); | ||
524 | } else { | ||
525 | cairo_path_t *oldpath; | ||
526 | oldpath = cairo_copy_path(fe->cr); | ||
527 | do_hatch(fe); | ||
528 | cairo_append_path(fe->cr, oldpath); | ||
529 | } | ||
530 | } | ||
531 | |||
532 | static void do_clip(frontend *fe, int x, int y, int w, int h) | ||
533 | { | ||
534 | cairo_new_path(fe->cr); | ||
535 | cairo_rectangle(fe->cr, x, y, w, h); | ||
536 | cairo_clip(fe->cr); | ||
537 | } | ||
538 | |||
539 | static void do_unclip(frontend *fe) | ||
540 | { | ||
541 | cairo_reset_clip(fe->cr); | ||
542 | } | ||
543 | |||
544 | static void do_draw_rect(frontend *fe, int x, int y, int w, int h) | ||
545 | { | ||
546 | cairo_save(fe->cr); | ||
547 | cairo_new_path(fe->cr); | ||
548 | cairo_set_antialias(fe->cr, CAIRO_ANTIALIAS_NONE); | ||
549 | cairo_rectangle(fe->cr, x, y, w, h); | ||
550 | fe->dr_api->fill(fe); | ||
551 | cairo_restore(fe->cr); | ||
552 | } | ||
553 | |||
554 | static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2) | ||
555 | { | ||
556 | cairo_new_path(fe->cr); | ||
557 | cairo_move_to(fe->cr, x1 + 0.5, y1 + 0.5); | ||
558 | cairo_line_to(fe->cr, x2 + 0.5, y2 + 0.5); | ||
559 | cairo_stroke(fe->cr); | ||
560 | } | ||
561 | |||
562 | static void do_draw_thick_line(frontend *fe, float thickness, | ||
563 | float x1, float y1, float x2, float y2) | ||
564 | { | ||
565 | cairo_save(fe->cr); | ||
566 | cairo_set_line_width(fe->cr, thickness); | ||
567 | cairo_new_path(fe->cr); | ||
568 | cairo_move_to(fe->cr, x1, y1); | ||
569 | cairo_line_to(fe->cr, x2, y2); | ||
570 | cairo_stroke(fe->cr); | ||
571 | cairo_restore(fe->cr); | ||
572 | } | ||
573 | |||
574 | static void do_draw_poly(frontend *fe, int *coords, int npoints, | ||
575 | int fillcolour, int outlinecolour) | ||
576 | { | ||
577 | int i; | ||
578 | |||
579 | cairo_new_path(fe->cr); | ||
580 | for (i = 0; i < npoints; i++) | ||
581 | cairo_line_to(fe->cr, coords[i*2] + 0.5, coords[i*2 + 1] + 0.5); | ||
582 | cairo_close_path(fe->cr); | ||
583 | if (fillcolour >= 0) { | ||
584 | fe->dr_api->set_colour(fe, fillcolour); | ||
585 | fe->dr_api->fill_preserve(fe); | ||
586 | } | ||
587 | assert(outlinecolour >= 0); | ||
588 | fe->dr_api->set_colour(fe, outlinecolour); | ||
589 | cairo_stroke(fe->cr); | ||
590 | } | ||
591 | |||
592 | static void do_draw_circle(frontend *fe, int cx, int cy, int radius, | ||
593 | int fillcolour, int outlinecolour) | ||
594 | { | ||
595 | cairo_new_path(fe->cr); | ||
596 | cairo_arc(fe->cr, cx + 0.5, cy + 0.5, radius, 0, 2*PI); | ||
597 | cairo_close_path(fe->cr); /* Just in case... */ | ||
598 | if (fillcolour >= 0) { | ||
599 | fe->dr_api->set_colour(fe, fillcolour); | ||
600 | fe->dr_api->fill_preserve(fe); | ||
601 | } | ||
602 | assert(outlinecolour >= 0); | ||
603 | fe->dr_api->set_colour(fe, outlinecolour); | ||
604 | cairo_stroke(fe->cr); | ||
605 | } | ||
606 | |||
607 | static void setup_blitter(blitter *bl, int w, int h) | ||
608 | { | ||
609 | bl->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, w, h); | ||
610 | } | ||
611 | |||
612 | static void teardown_blitter(blitter *bl) | ||
613 | { | ||
614 | cairo_surface_destroy(bl->image); | ||
615 | } | ||
616 | |||
617 | static void do_blitter_save(frontend *fe, blitter *bl, int x, int y) | ||
618 | { | ||
619 | cairo_t *cr = cairo_create(bl->image); | ||
620 | |||
621 | cairo_set_source_surface(cr, fe->image, -x, -y); | ||
622 | cairo_paint(cr); | ||
623 | cairo_destroy(cr); | ||
624 | } | ||
625 | |||
626 | static void do_blitter_load(frontend *fe, blitter *bl, int x, int y) | ||
627 | { | ||
628 | cairo_set_source_surface(fe->cr, bl->image, x, y); | ||
629 | cairo_paint(fe->cr); | ||
630 | } | ||
631 | |||
632 | static void clear_backing_store(frontend *fe) | ||
633 | { | ||
634 | fe->image = NULL; | ||
635 | } | ||
636 | |||
637 | static void wipe_and_maybe_destroy_cairo(frontend *fe, cairo_t *cr, | ||
638 | bool destroy) | ||
639 | { | ||
640 | cairo_set_source_rgb(cr, fe->colours[0], fe->colours[1], fe->colours[2]); | ||
641 | cairo_paint(cr); | ||
642 | if (destroy) | ||
643 | cairo_destroy(cr); | ||
644 | } | ||
645 | |||
646 | static void setup_backing_store(frontend *fe) | ||
647 | { | ||
648 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
649 | if (!fe->headless) { | ||
650 | fe->pixmap = gdk_pixmap_new(gtk_widget_get_window(fe->area), | ||
651 | fe->pw*fe->ps, fe->ph*fe->ps, -1); | ||
652 | } else { | ||
653 | fe->pixmap = NULL; | ||
654 | } | ||
655 | #endif | ||
656 | |||
657 | fe->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, | ||
658 | fe->pw*fe->ps, fe->ph*fe->ps); | ||
659 | |||
660 | wipe_and_maybe_destroy_cairo(fe, cairo_create(fe->image), true); | ||
661 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
662 | if (!fe->headless) | ||
663 | wipe_and_maybe_destroy_cairo(fe, gdk_cairo_create(fe->pixmap), true); | ||
664 | #endif | ||
665 | if (!fe->headless) { | ||
666 | #if GTK_CHECK_VERSION(3,22,0) | ||
667 | GdkWindow *gdkwin; | ||
668 | cairo_region_t *region; | ||
669 | GdkDrawingContext *drawctx; | ||
670 | cairo_t *cr; | ||
671 | |||
672 | gdkwin = gtk_widget_get_window(fe->area); | ||
673 | region = gdk_window_get_clip_region(gdkwin); | ||
674 | drawctx = gdk_window_begin_draw_frame(gdkwin, region); | ||
675 | cr = gdk_drawing_context_get_cairo_context(drawctx); | ||
676 | wipe_and_maybe_destroy_cairo(fe, cr, false); | ||
677 | gdk_window_end_draw_frame(gdkwin, drawctx); | ||
678 | cairo_region_destroy(region); | ||
679 | #else | ||
680 | wipe_and_maybe_destroy_cairo( | ||
681 | fe, gdk_cairo_create(gtk_widget_get_window(fe->area)), true); | ||
682 | #endif | ||
683 | } | ||
684 | } | ||
685 | |||
686 | static bool backing_store_ok(frontend *fe) | ||
687 | { | ||
688 | return fe->image != NULL; | ||
689 | } | ||
690 | |||
691 | static void teardown_backing_store(frontend *fe) | ||
692 | { | ||
693 | cairo_surface_destroy(fe->image); | ||
694 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
695 | gdk_pixmap_unref(fe->pixmap); | ||
696 | #endif | ||
697 | fe->image = NULL; | ||
698 | } | ||
699 | |||
700 | #endif | ||
701 | |||
702 | /* ---------------------------------------------------------------------- | ||
703 | * GDK drawing functions. | ||
704 | */ | ||
705 | |||
706 | #ifndef USE_CAIRO | ||
707 | |||
708 | static void setup_drawing(frontend *fe) | ||
709 | { | ||
710 | fe->gc = gdk_gc_new(fe->area->window); | ||
711 | } | ||
712 | |||
713 | static void teardown_drawing(frontend *fe) | ||
714 | { | ||
715 | gdk_gc_unref(fe->gc); | ||
716 | fe->gc = NULL; | ||
717 | } | ||
718 | |||
719 | static void snaffle_colours(frontend *fe) | ||
720 | { | ||
721 | int i, ncolours; | ||
722 | float *colours; | ||
723 | gboolean *success; | ||
724 | |||
725 | fe->colmap = gdk_colormap_get_system(); | ||
726 | colours = midend_colours(fe->me, &ncolours); | ||
727 | fe->ncolours = ncolours; | ||
728 | fe->colours = snewn(ncolours, GdkColor); | ||
729 | for (i = 0; i < ncolours; i++) { | ||
730 | fe->colours[i].red = colours[i*3] * 0xFFFF; | ||
731 | fe->colours[i].green = colours[i*3+1] * 0xFFFF; | ||
732 | fe->colours[i].blue = colours[i*3+2] * 0xFFFF; | ||
733 | } | ||
734 | success = snewn(ncolours, gboolean); | ||
735 | gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours, | ||
736 | false, false, success); | ||
737 | for (i = 0; i < ncolours; i++) { | ||
738 | if (!success[i]) { | ||
739 | g_error("couldn't allocate colour %d (#%02x%02x%02x)\n", | ||
740 | i, fe->colours[i].red >> 8, | ||
741 | fe->colours[i].green >> 8, | ||
742 | fe->colours[i].blue >> 8); | ||
743 | } | ||
744 | } | ||
745 | } | ||
746 | |||
747 | static void set_window_background(frontend *fe, int colour) | ||
748 | { | ||
749 | fe->backgroundindex = colour; | ||
750 | gdk_window_set_background(fe->area->window, &fe->colours[colour]); | ||
751 | gdk_window_set_background(fe->window->window, &fe->colours[colour]); | ||
752 | } | ||
753 | |||
754 | static void draw_set_colour(frontend *fe, int colour) | ||
755 | { | ||
756 | gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); | ||
757 | } | ||
758 | |||
759 | #ifdef USE_PANGO | ||
760 | static PangoLayout *make_pango_layout(frontend *fe) | ||
761 | { | ||
762 | return (pango_layout_new(gtk_widget_get_pango_context(fe->area))); | ||
763 | } | ||
764 | |||
765 | static void draw_pango_layout(frontend *fe, PangoLayout *layout, | ||
766 | int x, int y) | ||
767 | { | ||
768 | gdk_draw_layout(fe->pixmap, fe->gc, x, y, layout); | ||
769 | } | ||
770 | #endif | ||
771 | |||
772 | static void save_screenshot_png(frontend *fe, const char *screenshot_file) | ||
773 | { | ||
774 | GdkPixbuf *pb; | ||
775 | GError *gerror = NULL; | ||
776 | |||
777 | midend_redraw(fe->me); | ||
778 | |||
779 | pb = gdk_pixbuf_get_from_drawable(NULL, fe->pixmap, | ||
780 | NULL, 0, 0, 0, 0, -1, -1); | ||
781 | gdk_pixbuf_save(pb, screenshot_file, "png", &gerror, NULL); | ||
782 | } | ||
783 | |||
784 | static void do_clip(frontend *fe, int x, int y, int w, int h) | ||
785 | { | ||
786 | GdkRectangle rect; | ||
787 | |||
788 | rect.x = x; | ||
789 | rect.y = y; | ||
790 | rect.width = w; | ||
791 | rect.height = h; | ||
792 | gdk_gc_set_clip_rectangle(fe->gc, &rect); | ||
793 | } | ||
794 | |||
795 | static void do_unclip(frontend *fe) | ||
796 | { | ||
797 | GdkRectangle rect; | ||
798 | |||
799 | rect.x = 0; | ||
800 | rect.y = 0; | ||
801 | rect.width = fe->w; | ||
802 | rect.height = fe->h; | ||
803 | gdk_gc_set_clip_rectangle(fe->gc, &rect); | ||
804 | } | ||
805 | |||
806 | static void do_draw_rect(frontend *fe, int x, int y, int w, int h) | ||
807 | { | ||
808 | gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h); | ||
809 | } | ||
810 | |||
811 | static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2) | ||
812 | { | ||
813 | gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2); | ||
814 | } | ||
815 | |||
816 | static void do_draw_thick_line(frontend *fe, float thickness, | ||
817 | float x1, float y1, float x2, float y2) | ||
818 | { | ||
819 | GdkGCValues save; | ||
820 | |||
821 | gdk_gc_get_values(fe->gc, &save); | ||
822 | gdk_gc_set_line_attributes(fe->gc, | ||
823 | thickness, | ||
824 | GDK_LINE_SOLID, | ||
825 | GDK_CAP_BUTT, | ||
826 | GDK_JOIN_BEVEL); | ||
827 | gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2); | ||
828 | gdk_gc_set_line_attributes(fe->gc, | ||
829 | save.line_width, | ||
830 | save.line_style, | ||
831 | save.cap_style, | ||
832 | save.join_style); | ||
833 | } | ||
834 | |||
835 | static void do_draw_poly(frontend *fe, int *coords, int npoints, | ||
836 | int fillcolour, int outlinecolour) | ||
837 | { | ||
838 | GdkPoint *points = snewn(npoints, GdkPoint); | ||
839 | int i; | ||
840 | |||
841 | for (i = 0; i < npoints; i++) { | ||
842 | points[i].x = coords[i*2]; | ||
843 | points[i].y = coords[i*2+1]; | ||
844 | } | ||
845 | |||
846 | if (fillcolour >= 0) { | ||
847 | fe->dr_api->set_colour(fe, fillcolour); | ||
848 | gdk_draw_polygon(fe->pixmap, fe->gc, true, points, npoints); | ||
849 | } | ||
850 | assert(outlinecolour >= 0); | ||
851 | fe->dr_api->set_colour(fe, outlinecolour); | ||
852 | |||
853 | /* | ||
854 | * In principle we ought to be able to use gdk_draw_polygon for | ||
855 | * the outline as well. In fact, it turns out to interact badly | ||
856 | * with a clipping region, for no terribly obvious reason, so I | ||
857 | * draw the outline as a sequence of lines instead. | ||
858 | */ | ||
859 | for (i = 0; i < npoints; i++) | ||
860 | gdk_draw_line(fe->pixmap, fe->gc, | ||
861 | points[i].x, points[i].y, | ||
862 | points[(i+1)%npoints].x, points[(i+1)%npoints].y); | ||
863 | |||
864 | sfree(points); | ||
865 | } | ||
866 | |||
867 | static void do_draw_circle(frontend *fe, int cx, int cy, int radius, | ||
868 | int fillcolour, int outlinecolour) | ||
869 | { | ||
870 | if (fillcolour >= 0) { | ||
871 | fe->dr_api->set_colour(fe, fillcolour); | ||
872 | gdk_draw_arc(fe->pixmap, fe->gc, true, | ||
873 | cx - radius, cy - radius, | ||
874 | 2 * radius, 2 * radius, 0, 360 * 64); | ||
875 | } | ||
876 | |||
877 | assert(outlinecolour >= 0); | ||
878 | fe->dr_api->set_colour(fe, outlinecolour); | ||
879 | gdk_draw_arc(fe->pixmap, fe->gc, false, | ||
880 | cx - radius, cy - radius, | ||
881 | 2 * radius, 2 * radius, 0, 360 * 64); | ||
882 | } | ||
883 | |||
884 | static void setup_blitter(blitter *bl, int w, int h) | ||
885 | { | ||
886 | /* | ||
887 | * We can't create the pixmap right now, because fe->window | ||
888 | * might not yet exist. So we just cache w and h and create it | ||
889 | * during the firs call to blitter_save. | ||
890 | */ | ||
891 | bl->pixmap = NULL; | ||
892 | } | ||
893 | |||
894 | static void teardown_blitter(blitter *bl) | ||
895 | { | ||
896 | if (bl->pixmap) | ||
897 | gdk_pixmap_unref(bl->pixmap); | ||
898 | } | ||
899 | |||
900 | static void do_blitter_save(frontend *fe, blitter *bl, int x, int y) | ||
901 | { | ||
902 | if (!bl->pixmap) | ||
903 | bl->pixmap = gdk_pixmap_new(fe->area->window, bl->w, bl->h, -1); | ||
904 | gdk_draw_pixmap(bl->pixmap, | ||
905 | fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], | ||
906 | fe->pixmap, | ||
907 | x, y, 0, 0, bl->w, bl->h); | ||
908 | } | ||
909 | |||
910 | static void do_blitter_load(frontend *fe, blitter *bl, int x, int y) | ||
911 | { | ||
912 | assert(bl->pixmap); | ||
913 | gdk_draw_pixmap(fe->pixmap, | ||
914 | fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], | ||
915 | bl->pixmap, | ||
916 | 0, 0, x, y, bl->w, bl->h); | ||
917 | } | ||
918 | |||
919 | static void clear_backing_store(frontend *fe) | ||
920 | { | ||
921 | fe->pixmap = NULL; | ||
922 | } | ||
923 | |||
924 | static void setup_backing_store(frontend *fe) | ||
925 | { | ||
926 | GdkGC *gc; | ||
927 | |||
928 | if (fe->headless) { | ||
929 | fprintf(stderr, "headless mode does not work with GDK drawing\n"); | ||
930 | exit(1); | ||
931 | } | ||
932 | |||
933 | fe->pixmap = gdk_pixmap_new(fe->area->window, fe->pw, fe->ph, -1); | ||
934 | |||
935 | gc = gdk_gc_new(fe->area->window); | ||
936 | gdk_gc_set_foreground(gc, &fe->colours[0]); | ||
937 | gdk_draw_rectangle(fe->pixmap, gc, 1, 0, 0, fe->pw, fe->ph); | ||
938 | gdk_draw_rectangle(fe->area->window, gc, 1, 0, 0, fe->w, fe->h); | ||
939 | gdk_gc_unref(gc); | ||
940 | } | ||
941 | |||
942 | static int backing_store_ok(frontend *fe) | ||
943 | { | ||
944 | return (!!fe->pixmap); | ||
945 | } | ||
946 | |||
947 | static void teardown_backing_store(frontend *fe) | ||
948 | { | ||
949 | gdk_pixmap_unref(fe->pixmap); | ||
950 | fe->pixmap = NULL; | ||
951 | } | ||
952 | |||
953 | #endif | ||
954 | |||
955 | #ifndef USE_CAIRO_WITHOUT_PIXMAP | ||
956 | static void repaint_rectangle(frontend *fe, GtkWidget *widget, | ||
957 | int x, int y, int w, int h) | ||
958 | { | ||
959 | GdkGC *gc = gdk_gc_new(gtk_widget_get_window(widget)); | ||
960 | #ifdef USE_CAIRO | ||
961 | gdk_gc_set_foreground(gc, &fe->background); | ||
962 | #else | ||
963 | gdk_gc_set_foreground(gc, &fe->colours[fe->backgroundindex]); | ||
964 | #endif | ||
965 | if (x < fe->ox) { | ||
966 | gdk_draw_rectangle(gtk_widget_get_window(widget), gc, | ||
967 | true, x, y, fe->ox - x, h); | ||
968 | w -= (fe->ox - x); | ||
969 | x = fe->ox; | ||
970 | } | ||
971 | if (y < fe->oy) { | ||
972 | gdk_draw_rectangle(gtk_widget_get_window(widget), gc, | ||
973 | true, x, y, w, fe->oy - y); | ||
974 | h -= (fe->oy - y); | ||
975 | y = fe->oy; | ||
976 | } | ||
977 | if (w > fe->pw) { | ||
978 | gdk_draw_rectangle(gtk_widget_get_window(widget), gc, | ||
979 | true, x + fe->pw, y, w - fe->pw, h); | ||
980 | w = fe->pw; | ||
981 | } | ||
982 | if (h > fe->ph) { | ||
983 | gdk_draw_rectangle(gtk_widget_get_window(widget), gc, | ||
984 | true, x, y + fe->ph, w, h - fe->ph); | ||
985 | h = fe->ph; | ||
986 | } | ||
987 | gdk_draw_pixmap(gtk_widget_get_window(widget), gc, fe->pixmap, | ||
988 | x - fe->ox, y - fe->oy, x, y, w, h); | ||
989 | gdk_gc_unref(gc); | ||
990 | } | ||
991 | #endif | ||
992 | |||
993 | /* ---------------------------------------------------------------------- | ||
994 | * Pango font functions. | ||
995 | */ | ||
996 | |||
997 | #ifdef USE_PANGO | ||
998 | |||
999 | static void add_font(frontend *fe, int index, int fonttype, int fontsize) | ||
1000 | { | ||
1001 | /* | ||
1002 | * Use Pango to find the closest match to the requested | ||
1003 | * font. | ||
1004 | */ | ||
1005 | PangoFontDescription *fd; | ||
1006 | |||
1007 | fd = pango_font_description_new(); | ||
1008 | /* `Monospace' and `Sans' are meta-families guaranteed to exist */ | ||
1009 | pango_font_description_set_family(fd, fonttype == FONT_FIXED ? | ||
1010 | "Monospace" : "Sans"); | ||
1011 | pango_font_description_set_weight(fd, PANGO_WEIGHT_BOLD); | ||
1012 | /* | ||
1013 | * I found some online Pango documentation which | ||
1014 | * described a function called | ||
1015 | * pango_font_description_set_absolute_size(), which is | ||
1016 | * _exactly_ what I want here. Unfortunately, none of | ||
1017 | * my local Pango installations have it (presumably | ||
1018 | * they're too old), so I'm going to have to hack round | ||
1019 | * it by figuring out the point size myself. This | ||
1020 | * limits me to X and probably also breaks in later | ||
1021 | * Pango installations, so ideally I should add another | ||
1022 | * CHECK_VERSION type ifdef and use set_absolute_size | ||
1023 | * where available. All very annoying. | ||
1024 | */ | ||
1025 | #ifdef HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION | ||
1026 | pango_font_description_set_absolute_size(fd, PANGO_SCALE*fontsize); | ||
1027 | #else | ||
1028 | { | ||
1029 | Display *d = GDK_DISPLAY(); | ||
1030 | int s = DefaultScreen(d); | ||
1031 | double resolution = | ||
1032 | (PANGO_SCALE * 72.27 / 25.4) * | ||
1033 | ((double) DisplayWidthMM(d, s) / DisplayWidth (d, s)); | ||
1034 | pango_font_description_set_size(fd, resolution * fontsize); | ||
1035 | } | ||
1036 | #endif | ||
1037 | fe->fonts[index].desc = fd; | ||
1038 | } | ||
1039 | |||
1040 | static void align_and_draw_text(frontend *fe, | ||
1041 | int index, int align, int x, int y, | ||
1042 | const char *text) | ||
1043 | { | ||
1044 | PangoLayout *layout; | ||
1045 | PangoRectangle rect; | ||
1046 | |||
1047 | layout = make_pango_layout(fe); | ||
1048 | |||
1049 | /* | ||
1050 | * Create a layout. | ||
1051 | */ | ||
1052 | pango_layout_set_font_description(layout, fe->fonts[index].desc); | ||
1053 | pango_layout_set_text(layout, text, strlen(text)); | ||
1054 | pango_layout_get_pixel_extents(layout, NULL, &rect); | ||
1055 | |||
1056 | if (align & ALIGN_VCENTRE) | ||
1057 | rect.y -= rect.height / 2; | ||
1058 | else | ||
1059 | rect.y -= rect.height; | ||
1060 | |||
1061 | if (align & ALIGN_HCENTRE) | ||
1062 | rect.x -= rect.width / 2; | ||
1063 | else if (align & ALIGN_HRIGHT) | ||
1064 | rect.x -= rect.width; | ||
1065 | |||
1066 | draw_pango_layout(fe, layout, rect.x + x, rect.y + y); | ||
1067 | |||
1068 | g_object_unref(layout); | ||
1069 | } | ||
1070 | |||
1071 | #endif | ||
1072 | |||
1073 | /* ---------------------------------------------------------------------- | ||
1074 | * Old-fashioned font functions. | ||
1075 | */ | ||
1076 | |||
1077 | #ifndef USE_PANGO | ||
1078 | |||
1079 | static void add_font(int index, int fonttype, int fontsize) | ||
1080 | { | ||
1081 | /* | ||
1082 | * In GTK 1.2, I don't know of any plausible way to | ||
1083 | * pick a suitable font, so I'm just going to be | ||
1084 | * tedious. | ||
1085 | */ | ||
1086 | fe->fonts[i].font = gdk_font_load(fonttype == FONT_FIXED ? | ||
1087 | "fixed" : "variable"); | ||
1088 | } | ||
1089 | |||
1090 | static void align_and_draw_text(int index, int align, int x, int y, | ||
1091 | const char *text) | ||
1092 | { | ||
1093 | int lb, rb, wid, asc, desc; | ||
1094 | |||
1095 | /* | ||
1096 | * Measure vertical string extents with respect to the same | ||
1097 | * string always... | ||
1098 | */ | ||
1099 | gdk_string_extents(fe->fonts[i].font, | ||
1100 | "ABCDEFGHIJKLMNOPQRSTUVWXYZ", | ||
1101 | &lb, &rb, &wid, &asc, &desc); | ||
1102 | if (align & ALIGN_VCENTRE) | ||
1103 | y += asc - (asc+desc)/2; | ||
1104 | else | ||
1105 | y += asc; | ||
1106 | |||
1107 | /* | ||
1108 | * ... but horizontal extents with respect to the provided | ||
1109 | * string. This means that multiple pieces of text centred | ||
1110 | * on the same y-coordinate don't have different baselines. | ||
1111 | */ | ||
1112 | gdk_string_extents(fe->fonts[i].font, text, | ||
1113 | &lb, &rb, &wid, &asc, &desc); | ||
1114 | |||
1115 | if (align & ALIGN_HCENTRE) | ||
1116 | x -= wid / 2; | ||
1117 | else if (align & ALIGN_HRIGHT) | ||
1118 | x -= wid; | ||
1119 | |||
1120 | /* | ||
1121 | * Actually draw the text. | ||
1122 | */ | ||
1123 | gdk_draw_string(fe->pixmap, fe->fonts[i].font, fe->gc, x, y, text); | ||
1124 | } | ||
1125 | |||
1126 | #endif | ||
1127 | |||
1128 | /* ---------------------------------------------------------------------- | ||
1129 | * The exported drawing functions. | ||
1130 | */ | ||
1131 | |||
1132 | void gtk_start_draw(void *handle) | ||
1133 | { | ||
1134 | frontend *fe = (frontend *)handle; | ||
1135 | fe->bbox_l = fe->w; | ||
1136 | fe->bbox_r = 0; | ||
1137 | fe->bbox_u = fe->h; | ||
1138 | fe->bbox_d = 0; | ||
1139 | setup_drawing(fe); | ||
1140 | } | ||
1141 | |||
1142 | void gtk_clip(void *handle, int x, int y, int w, int h) | ||
1143 | { | ||
1144 | frontend *fe = (frontend *)handle; | ||
1145 | do_clip(fe, x, y, w, h); | ||
1146 | } | ||
1147 | |||
1148 | void gtk_unclip(void *handle) | ||
1149 | { | ||
1150 | frontend *fe = (frontend *)handle; | ||
1151 | do_unclip(fe); | ||
1152 | } | ||
1153 | |||
1154 | void gtk_draw_text(void *handle, int x, int y, int fonttype, int fontsize, | ||
1155 | int align, int colour, const char *text) | ||
1156 | { | ||
1157 | frontend *fe = (frontend *)handle; | ||
1158 | int i; | ||
1159 | |||
1160 | /* | ||
1161 | * Find or create the font. | ||
1162 | */ | ||
1163 | for (i = 0; i < fe->nfonts; i++) | ||
1164 | if (fe->fonts[i].type == fonttype && fe->fonts[i].size == fontsize) | ||
1165 | break; | ||
1166 | |||
1167 | if (i == fe->nfonts) { | ||
1168 | if (fe->fontsize <= fe->nfonts) { | ||
1169 | fe->fontsize = fe->nfonts + 10; | ||
1170 | fe->fonts = sresize(fe->fonts, fe->fontsize, struct font); | ||
1171 | } | ||
1172 | |||
1173 | fe->nfonts++; | ||
1174 | |||
1175 | fe->fonts[i].type = fonttype; | ||
1176 | fe->fonts[i].size = fontsize; | ||
1177 | add_font(fe, i, fonttype, fontsize); | ||
1178 | } | ||
1179 | |||
1180 | /* | ||
1181 | * Do the job. | ||
1182 | */ | ||
1183 | fe->dr_api->set_colour(fe, colour); | ||
1184 | align_and_draw_text(fe, i, align, x, y, text); | ||
1185 | } | ||
1186 | |||
1187 | void gtk_draw_rect(void *handle, int x, int y, int w, int h, int colour) | ||
1188 | { | ||
1189 | frontend *fe = (frontend *)handle; | ||
1190 | fe->dr_api->set_colour(fe, colour); | ||
1191 | do_draw_rect(fe, x, y, w, h); | ||
1192 | } | ||
1193 | |||
1194 | void gtk_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour) | ||
1195 | { | ||
1196 | frontend *fe = (frontend *)handle; | ||
1197 | fe->dr_api->set_colour(fe, colour); | ||
1198 | do_draw_line(fe, x1, y1, x2, y2); | ||
1199 | } | ||
1200 | |||
1201 | void gtk_draw_thick_line(void *handle, float thickness, | ||
1202 | float x1, float y1, float x2, float y2, int colour) | ||
1203 | { | ||
1204 | frontend *fe = (frontend *)handle; | ||
1205 | fe->dr_api->set_colour(fe, colour); | ||
1206 | do_draw_thick_line(fe, thickness, x1, y1, x2, y2); | ||
1207 | } | ||
1208 | |||
1209 | void gtk_draw_poly(void *handle, int *coords, int npoints, | ||
1210 | int fillcolour, int outlinecolour) | ||
1211 | { | ||
1212 | frontend *fe = (frontend *)handle; | ||
1213 | do_draw_poly(fe, coords, npoints, fillcolour, outlinecolour); | ||
1214 | } | ||
1215 | |||
1216 | void gtk_draw_circle(void *handle, int cx, int cy, int radius, | ||
1217 | int fillcolour, int outlinecolour) | ||
1218 | { | ||
1219 | frontend *fe = (frontend *)handle; | ||
1220 | do_draw_circle(fe, cx, cy, radius, fillcolour, outlinecolour); | ||
1221 | } | ||
1222 | |||
1223 | blitter *gtk_blitter_new(void *handle, int w, int h) | ||
1224 | { | ||
1225 | blitter *bl = snew(blitter); | ||
1226 | setup_blitter(bl, w, h); | ||
1227 | bl->w = w; | ||
1228 | bl->h = h; | ||
1229 | return bl; | ||
1230 | } | ||
1231 | |||
1232 | void gtk_blitter_free(void *handle, blitter *bl) | ||
1233 | { | ||
1234 | teardown_blitter(bl); | ||
1235 | sfree(bl); | ||
1236 | } | ||
1237 | |||
1238 | void gtk_blitter_save(void *handle, blitter *bl, int x, int y) | ||
1239 | { | ||
1240 | frontend *fe = (frontend *)handle; | ||
1241 | do_blitter_save(fe, bl, x, y); | ||
1242 | bl->x = x; | ||
1243 | bl->y = y; | ||
1244 | } | ||
1245 | |||
1246 | void gtk_blitter_load(void *handle, blitter *bl, int x, int y) | ||
1247 | { | ||
1248 | frontend *fe = (frontend *)handle; | ||
1249 | if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) { | ||
1250 | x = bl->x; | ||
1251 | y = bl->y; | ||
1252 | } | ||
1253 | do_blitter_load(fe, bl, x, y); | ||
1254 | } | ||
1255 | |||
1256 | void gtk_draw_update(void *handle, int x, int y, int w, int h) | ||
1257 | { | ||
1258 | frontend *fe = (frontend *)handle; | ||
1259 | if (fe->bbox_l > x ) fe->bbox_l = x ; | ||
1260 | if (fe->bbox_r < x+w) fe->bbox_r = x+w; | ||
1261 | if (fe->bbox_u > y ) fe->bbox_u = y ; | ||
1262 | if (fe->bbox_d < y+h) fe->bbox_d = y+h; | ||
1263 | } | ||
1264 | |||
1265 | void gtk_end_draw(void *handle) | ||
1266 | { | ||
1267 | frontend *fe = (frontend *)handle; | ||
1268 | |||
1269 | teardown_drawing(fe); | ||
1270 | |||
1271 | if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d && !fe->headless) { | ||
1272 | #ifdef USE_CAIRO_WITHOUT_PIXMAP | ||
1273 | gtk_widget_queue_draw_area(fe->area, | ||
1274 | fe->bbox_l - 1 + fe->ox, | ||
1275 | fe->bbox_u - 1 + fe->oy, | ||
1276 | fe->bbox_r - fe->bbox_l + 2, | ||
1277 | fe->bbox_d - fe->bbox_u + 2); | ||
1278 | #else | ||
1279 | repaint_rectangle(fe, fe->area, | ||
1280 | fe->bbox_l - 1 + fe->ox, | ||
1281 | fe->bbox_u - 1 + fe->oy, | ||
1282 | fe->bbox_r - fe->bbox_l + 2, | ||
1283 | fe->bbox_d - fe->bbox_u + 2); | ||
1284 | #endif | ||
1285 | } | ||
1286 | } | ||
1287 | |||
1288 | #ifdef USE_PANGO | ||
1289 | char *gtk_text_fallback(void *handle, const char *const *strings, int nstrings) | ||
1290 | { | ||
1291 | /* | ||
1292 | * We assume Pango can cope with any UTF-8 likely to be emitted | ||
1293 | * by a puzzle. | ||
1294 | */ | ||
1295 | return dupstr(strings[0]); | ||
1296 | } | ||
1297 | #endif | ||
1298 | |||
1299 | #ifdef USE_PRINTING | ||
1300 | void gtk_begin_doc(void *handle, int pages) | ||
1301 | { | ||
1302 | frontend *fe = (frontend *)handle; | ||
1303 | gtk_print_operation_set_n_pages(fe->printop, pages); | ||
1304 | } | ||
1305 | |||
1306 | void gtk_begin_page(void *handle, int number) | ||
1307 | { | ||
1308 | } | ||
1309 | |||
1310 | void gtk_begin_puzzle(void *handle, float xm, float xc, | ||
1311 | float ym, float yc, int pw, int ph, float wmm) | ||
1312 | { | ||
1313 | frontend *fe = (frontend *)handle; | ||
1314 | double ppw, pph, pox, poy, dpmmx, dpmmy; | ||
1315 | double scale; | ||
1316 | |||
1317 | ppw = gtk_print_context_get_width(fe->printcontext); | ||
1318 | pph = gtk_print_context_get_height(fe->printcontext); | ||
1319 | dpmmx = gtk_print_context_get_dpi_x(fe->printcontext) / 25.4; | ||
1320 | dpmmy = gtk_print_context_get_dpi_y(fe->printcontext) / 25.4; | ||
1321 | |||
1322 | /* | ||
1323 | * Compute the puzzle's position in pixels on the logical page. | ||
1324 | */ | ||
1325 | pox = xm * ppw + xc * dpmmx; | ||
1326 | poy = ym * pph + yc * dpmmy; | ||
1327 | |||
1328 | /* | ||
1329 | * And determine the scale. | ||
1330 | * | ||
1331 | * I need a scale such that the maximum puzzle-coordinate | ||
1332 | * extent of the rectangle (pw * scale) is equal to the pixel | ||
1333 | * equivalent of the puzzle's millimetre width (wmm * dpmmx). | ||
1334 | */ | ||
1335 | scale = wmm * dpmmx / pw; | ||
1336 | |||
1337 | /* | ||
1338 | * Now instruct Cairo to transform points based on our calculated | ||
1339 | * values (order here *is* important). | ||
1340 | */ | ||
1341 | cairo_save(fe->cr); | ||
1342 | cairo_translate(fe->cr, pox, poy); | ||
1343 | cairo_scale(fe->cr, scale, scale); | ||
1344 | |||
1345 | fe->hatchthick = 0.2 * pw / wmm; | ||
1346 | fe->hatchspace = 1.0 * pw / wmm; | ||
1347 | } | ||
1348 | |||
1349 | void gtk_end_puzzle(void *handle) | ||
1350 | { | ||
1351 | frontend *fe = (frontend *)handle; | ||
1352 | cairo_restore(fe->cr); | ||
1353 | } | ||
1354 | |||
1355 | void gtk_end_page(void *handle, int number) | ||
1356 | { | ||
1357 | } | ||
1358 | |||
1359 | void gtk_end_doc(void *handle) | ||
1360 | { | ||
1361 | } | ||
1362 | |||
1363 | void gtk_line_width(void *handle, float width) | ||
1364 | { | ||
1365 | frontend *fe = (frontend *)handle; | ||
1366 | cairo_set_line_width(fe->cr, width); | ||
1367 | } | ||
1368 | |||
1369 | void gtk_line_dotted(void *handle, bool dotted) | ||
1370 | { | ||
1371 | frontend *fe = (frontend *)handle; | ||
1372 | |||
1373 | if (dotted) { | ||
1374 | const double dash = 35.0; | ||
1375 | cairo_set_dash(fe->cr, &dash, 1, 0); | ||
1376 | } else { | ||
1377 | cairo_set_dash(fe->cr, NULL, 0, 0); | ||
1378 | } | ||
1379 | } | ||
1380 | #endif /* USE_PRINTING */ | ||
1381 | |||
1382 | const struct internal_drawing_api internal_drawing = { | ||
1383 | draw_set_colour, | ||
1384 | #ifdef USE_CAIRO | ||
1385 | do_draw_fill, | ||
1386 | do_draw_fill_preserve, | ||
1387 | #endif | ||
1388 | }; | ||
1389 | |||
1390 | #ifdef USE_CAIRO | ||
1391 | const struct internal_drawing_api internal_printing = { | ||
1392 | print_set_colour, | ||
1393 | do_print_fill, | ||
1394 | do_print_fill_preserve, | ||
1395 | }; | ||
1396 | #endif | ||
1397 | |||
1398 | const struct drawing_api gtk_drawing = { | ||
1399 | gtk_draw_text, | ||
1400 | gtk_draw_rect, | ||
1401 | gtk_draw_line, | ||
1402 | gtk_draw_poly, | ||
1403 | gtk_draw_circle, | ||
1404 | gtk_draw_update, | ||
1405 | gtk_clip, | ||
1406 | gtk_unclip, | ||
1407 | gtk_start_draw, | ||
1408 | gtk_end_draw, | ||
1409 | gtk_status_bar, | ||
1410 | gtk_blitter_new, | ||
1411 | gtk_blitter_free, | ||
1412 | gtk_blitter_save, | ||
1413 | gtk_blitter_load, | ||
1414 | #ifdef USE_PRINTING | ||
1415 | gtk_begin_doc, | ||
1416 | gtk_begin_page, | ||
1417 | gtk_begin_puzzle, | ||
1418 | gtk_end_puzzle, | ||
1419 | gtk_end_page, | ||
1420 | gtk_end_doc, | ||
1421 | gtk_line_width, | ||
1422 | gtk_line_dotted, | ||
1423 | #else | ||
1424 | NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */ | ||
1425 | NULL, NULL, /* line_width, line_dotted */ | ||
1426 | #endif | ||
1427 | #ifdef USE_PANGO | ||
1428 | gtk_text_fallback, | ||
1429 | #else | ||
1430 | NULL, | ||
1431 | #endif | ||
1432 | #ifdef NO_THICK_LINE | ||
1433 | NULL, | ||
1434 | #else | ||
1435 | gtk_draw_thick_line, | ||
1436 | #endif | ||
1437 | }; | ||
1438 | |||
1439 | static void destroy(GtkWidget *widget, gpointer data) | ||
1440 | { | ||
1441 | frontend *fe = (frontend *)data; | ||
1442 | deactivate_timer(fe); | ||
1443 | midend_free(fe->me); | ||
1444 | gtk_main_quit(); | ||
1445 | } | ||
1446 | |||
1447 | static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data) | ||
1448 | { | ||
1449 | frontend *fe = (frontend *)data; | ||
1450 | int keyval; | ||
1451 | int shift = (event->state & GDK_SHIFT_MASK) ? MOD_SHFT : 0; | ||
1452 | int ctrl = (event->state & GDK_CONTROL_MASK) ? MOD_CTRL : 0; | ||
1453 | |||
1454 | if (!backing_store_ok(fe)) | ||
1455 | return true; | ||
1456 | |||
1457 | /* Handle mnemonics. */ | ||
1458 | if (gtk_window_activate_key(GTK_WINDOW(fe->window), event)) | ||
1459 | return true; | ||
1460 | |||
1461 | if (event->keyval == GDK_KEY_Up) | ||
1462 | keyval = shift | ctrl | CURSOR_UP; | ||
1463 | else if (event->keyval == GDK_KEY_KP_Up || | ||
1464 | event->keyval == GDK_KEY_KP_8) | ||
1465 | keyval = MOD_NUM_KEYPAD | '8'; | ||
1466 | else if (event->keyval == GDK_KEY_Down) | ||
1467 | keyval = shift | ctrl | CURSOR_DOWN; | ||
1468 | else if (event->keyval == GDK_KEY_KP_Down || | ||
1469 | event->keyval == GDK_KEY_KP_2) | ||
1470 | keyval = MOD_NUM_KEYPAD | '2'; | ||
1471 | else if (event->keyval == GDK_KEY_Left) | ||
1472 | keyval = shift | ctrl | CURSOR_LEFT; | ||
1473 | else if (event->keyval == GDK_KEY_KP_Left || | ||
1474 | event->keyval == GDK_KEY_KP_4) | ||
1475 | keyval = MOD_NUM_KEYPAD | '4'; | ||
1476 | else if (event->keyval == GDK_KEY_Right) | ||
1477 | keyval = shift | ctrl | CURSOR_RIGHT; | ||
1478 | else if (event->keyval == GDK_KEY_KP_Right || | ||
1479 | event->keyval == GDK_KEY_KP_6) | ||
1480 | keyval = MOD_NUM_KEYPAD | '6'; | ||
1481 | else if (event->keyval == GDK_KEY_KP_Home || | ||
1482 | event->keyval == GDK_KEY_KP_7) | ||
1483 | keyval = MOD_NUM_KEYPAD | '7'; | ||
1484 | else if (event->keyval == GDK_KEY_KP_End || | ||
1485 | event->keyval == GDK_KEY_KP_1) | ||
1486 | keyval = MOD_NUM_KEYPAD | '1'; | ||
1487 | else if (event->keyval == GDK_KEY_KP_Page_Up || | ||
1488 | event->keyval == GDK_KEY_KP_9) | ||
1489 | keyval = MOD_NUM_KEYPAD | '9'; | ||
1490 | else if (event->keyval == GDK_KEY_KP_Page_Down || | ||
1491 | event->keyval == GDK_KEY_KP_3) | ||
1492 | keyval = MOD_NUM_KEYPAD | '3'; | ||
1493 | else if (event->keyval == GDK_KEY_KP_Insert || | ||
1494 | event->keyval == GDK_KEY_KP_0) | ||
1495 | keyval = MOD_NUM_KEYPAD | '0'; | ||
1496 | else if (event->keyval == GDK_KEY_KP_Begin || | ||
1497 | event->keyval == GDK_KEY_KP_5) | ||
1498 | keyval = MOD_NUM_KEYPAD | '5'; | ||
1499 | else if (event->keyval == GDK_KEY_BackSpace || | ||
1500 | event->keyval == GDK_KEY_Delete || | ||
1501 | event->keyval == GDK_KEY_KP_Delete) | ||
1502 | keyval = '\177'; | ||
1503 | else if ((event->keyval == 'z' || event->keyval == 'Z') && shift && ctrl) | ||
1504 | keyval = UI_REDO; | ||
1505 | else if (event->string[0] && !event->string[1]) | ||
1506 | keyval = (unsigned char)event->string[0]; | ||
1507 | else | ||
1508 | keyval = -1; | ||
1509 | |||
1510 | if (keyval >= 0 && | ||
1511 | !midend_process_key(fe->me, 0, 0, keyval)) | ||
1512 | gtk_widget_destroy(fe->window); | ||
1513 | |||
1514 | return true; | ||
1515 | } | ||
1516 | |||
1517 | static gint button_event(GtkWidget *widget, GdkEventButton *event, | ||
1518 | gpointer data) | ||
1519 | { | ||
1520 | frontend *fe = (frontend *)data; | ||
1521 | int button; | ||
1522 | |||
1523 | if (!backing_store_ok(fe)) | ||
1524 | return true; | ||
1525 | |||
1526 | if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE) | ||
1527 | return true; | ||
1528 | |||
1529 | if (event->button == 2 || (event->state & GDK_SHIFT_MASK)) | ||
1530 | button = MIDDLE_BUTTON; | ||
1531 | else if (event->button == 3 || (event->state & GDK_MOD1_MASK)) | ||
1532 | button = RIGHT_BUTTON; | ||
1533 | else if (event->button == 1) | ||
1534 | button = LEFT_BUTTON; | ||
1535 | else if (event->button == 8 && event->type == GDK_BUTTON_PRESS) | ||
1536 | button = 'u'; | ||
1537 | else if (event->button == 9 && event->type == GDK_BUTTON_PRESS) | ||
1538 | button = 'r'; | ||
1539 | else | ||
1540 | return false; /* don't even know what button! */ | ||
1541 | |||
1542 | if (event->type == GDK_BUTTON_RELEASE && button >= LEFT_BUTTON) | ||
1543 | button += LEFT_RELEASE - LEFT_BUTTON; | ||
1544 | |||
1545 | if (!midend_process_key(fe->me, event->x - fe->ox, | ||
1546 | event->y - fe->oy, button)) | ||
1547 | gtk_widget_destroy(fe->window); | ||
1548 | |||
1549 | return true; | ||
1550 | } | ||
1551 | |||
1552 | static gint motion_event(GtkWidget *widget, GdkEventMotion *event, | ||
1553 | gpointer data) | ||
1554 | { | ||
1555 | frontend *fe = (frontend *)data; | ||
1556 | int button; | ||
1557 | |||
1558 | if (!backing_store_ok(fe)) | ||
1559 | return true; | ||
1560 | |||
1561 | if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK)) | ||
1562 | button = MIDDLE_DRAG; | ||
1563 | else if (event->state & GDK_BUTTON1_MASK) | ||
1564 | button = LEFT_DRAG; | ||
1565 | else if (event->state & GDK_BUTTON3_MASK) | ||
1566 | button = RIGHT_DRAG; | ||
1567 | else | ||
1568 | return false; /* don't even know what button! */ | ||
1569 | |||
1570 | if (!midend_process_key(fe->me, event->x - fe->ox, | ||
1571 | event->y - fe->oy, button)) | ||
1572 | gtk_widget_destroy(fe->window); | ||
1573 | #if GTK_CHECK_VERSION(2,12,0) | ||
1574 | gdk_event_request_motions(event); | ||
1575 | #else | ||
1576 | gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, NULL); | ||
1577 | #endif | ||
1578 | |||
1579 | return true; | ||
1580 | } | ||
1581 | |||
1582 | #if GTK_CHECK_VERSION(3,0,0) | ||
1583 | static gint draw_area(GtkWidget *widget, cairo_t *cr, gpointer data) | ||
1584 | { | ||
1585 | frontend *fe = (frontend *)data; | ||
1586 | GdkRectangle dirtyrect; | ||
1587 | |||
1588 | cairo_surface_t *target_surface = cairo_get_target(cr); | ||
1589 | cairo_matrix_t m; | ||
1590 | cairo_get_matrix(cr, &m); | ||
1591 | double orig_sx, orig_sy; | ||
1592 | cairo_surface_get_device_scale(target_surface, &orig_sx, &orig_sy); | ||
1593 | cairo_surface_set_device_scale(target_surface, 1.0, 1.0); | ||
1594 | cairo_translate(cr, m.x0 * (orig_sx - 1.0), m.y0 * (orig_sy - 1.0)); | ||
1595 | |||
1596 | gdk_cairo_get_clip_rectangle(cr, &dirtyrect); | ||
1597 | cairo_set_source_surface(cr, fe->image, fe->ox, fe->oy); | ||
1598 | cairo_rectangle(cr, dirtyrect.x, dirtyrect.y, | ||
1599 | dirtyrect.width, dirtyrect.height); | ||
1600 | cairo_fill(cr); | ||
1601 | |||
1602 | cairo_surface_set_device_scale(target_surface, orig_sx, orig_sy); | ||
1603 | |||
1604 | return true; | ||
1605 | } | ||
1606 | #else | ||
1607 | static gint expose_area(GtkWidget *widget, GdkEventExpose *event, | ||
1608 | gpointer data) | ||
1609 | { | ||
1610 | frontend *fe = (frontend *)data; | ||
1611 | |||
1612 | if (backing_store_ok(fe)) { | ||
1613 | #ifdef USE_CAIRO_WITHOUT_PIXMAP | ||
1614 | cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget)); | ||
1615 | cairo_set_source_surface(cr, fe->image, fe->ox, fe->oy); | ||
1616 | cairo_rectangle(cr, event->area.x, event->area.y, | ||
1617 | event->area.width, event->area.height); | ||
1618 | cairo_fill(cr); | ||
1619 | cairo_destroy(cr); | ||
1620 | #else | ||
1621 | repaint_rectangle(fe, widget, | ||
1622 | event->area.x, event->area.y, | ||
1623 | event->area.width, event->area.height); | ||
1624 | #endif | ||
1625 | } | ||
1626 | return true; | ||
1627 | } | ||
1628 | #endif | ||
1629 | |||
1630 | static gint map_window(GtkWidget *widget, GdkEvent *event, | ||
1631 | gpointer data) | ||
1632 | { | ||
1633 | frontend *fe = (frontend *)data; | ||
1634 | |||
1635 | /* | ||
1636 | * Apparently we need to do this because otherwise the status | ||
1637 | * bar will fail to update immediately. Annoying, but there we | ||
1638 | * go. | ||
1639 | */ | ||
1640 | gtk_widget_queue_draw(fe->window); | ||
1641 | |||
1642 | return true; | ||
1643 | } | ||
1644 | |||
1645 | static void resize_puzzle_to_area(frontend *fe, int x, int y) | ||
1646 | { | ||
1647 | int oldw = fe->w, oldpw = fe->pw, oldh = fe->h, oldph = fe->ph; | ||
1648 | int oldps = fe->ps; | ||
1649 | |||
1650 | fe->w = x; | ||
1651 | fe->h = y; | ||
1652 | midend_size(fe->me, &x, &y, true); | ||
1653 | fe->pw = x; | ||
1654 | fe->ph = y; | ||
1655 | #if GTK_CHECK_VERSION(3,10,0) | ||
1656 | fe->ps = gtk_widget_get_scale_factor(fe->area); | ||
1657 | #else | ||
1658 | fe->ps = 1; | ||
1659 | #endif | ||
1660 | fe->ox = (fe->w - fe->pw) / 2; | ||
1661 | fe->oy = (fe->h - fe->ph) / 2; | ||
1662 | |||
1663 | if (oldw != fe->w || oldpw != fe->pw || oldps != fe->ps || | ||
1664 | oldh != fe->h || oldph != fe->ph || !backing_store_ok(fe)) { | ||
1665 | if (backing_store_ok(fe)) | ||
1666 | teardown_backing_store(fe); | ||
1667 | setup_backing_store(fe); | ||
1668 | } | ||
1669 | |||
1670 | midend_force_redraw(fe->me); | ||
1671 | } | ||
1672 | |||
1673 | static gint configure_area(GtkWidget *widget, | ||
1674 | GdkEventConfigure *event, gpointer data) | ||
1675 | { | ||
1676 | frontend *fe = (frontend *)data; | ||
1677 | |||
1678 | resize_puzzle_to_area(fe, event->width, event->height); | ||
1679 | #if GTK_CHECK_VERSION(3,0,0) | ||
1680 | fe->awaiting_resize_ack = false; | ||
1681 | #endif | ||
1682 | return true; | ||
1683 | } | ||
1684 | |||
1685 | #if GTK_CHECK_VERSION(3,0,0) | ||
1686 | static void window_size_alloc(GtkWidget *widget, GtkAllocation *allocation, | ||
1687 | gpointer data) | ||
1688 | { | ||
1689 | frontend *fe = (frontend *)data; | ||
1690 | if (fe->awaiting_resize_ack) { | ||
1691 | GtkAllocation a; | ||
1692 | gtk_widget_get_allocation(fe->area, &a); | ||
1693 | resize_puzzle_to_area(fe, a.width, a.height); | ||
1694 | fe->awaiting_resize_ack = false; | ||
1695 | } | ||
1696 | } | ||
1697 | #endif | ||
1698 | |||
1699 | static gint timer_func(gpointer data) | ||
1700 | { | ||
1701 | frontend *fe = (frontend *)data; | ||
1702 | |||
1703 | if (fe->timer_active) { | ||
1704 | struct timeval now; | ||
1705 | float elapsed; | ||
1706 | gettimeofday(&now, NULL); | ||
1707 | elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F + | ||
1708 | (now.tv_sec - fe->last_time.tv_sec)); | ||
1709 | midend_timer(fe->me, elapsed); /* may clear timer_active */ | ||
1710 | fe->last_time = now; | ||
1711 | } | ||
1712 | |||
1713 | return fe->timer_active; | ||
1714 | } | ||
1715 | |||
1716 | void deactivate_timer(frontend *fe) | ||
1717 | { | ||
1718 | if (!fe) | ||
1719 | return; /* can happen due to --generate */ | ||
1720 | if (fe->timer_active) | ||
1721 | g_source_remove(fe->timer_id); | ||
1722 | fe->timer_active = false; | ||
1723 | } | ||
1724 | |||
1725 | void activate_timer(frontend *fe) | ||
1726 | { | ||
1727 | if (!fe) | ||
1728 | return; /* can happen due to --generate */ | ||
1729 | if (!fe->timer_active) { | ||
1730 | fe->timer_id = g_timeout_add(20, timer_func, fe); | ||
1731 | gettimeofday(&fe->last_time, NULL); | ||
1732 | } | ||
1733 | fe->timer_active = true; | ||
1734 | } | ||
1735 | |||
1736 | static void window_destroy(GtkWidget *widget, gpointer data) | ||
1737 | { | ||
1738 | gtk_main_quit(); | ||
1739 | } | ||
1740 | |||
1741 | static gint win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) | ||
1742 | { | ||
1743 | GObject *cancelbutton = G_OBJECT(data); | ||
1744 | |||
1745 | /* | ||
1746 | * `Escape' effectively clicks the cancel button | ||
1747 | */ | ||
1748 | if (event->keyval == GDK_KEY_Escape) { | ||
1749 | g_signal_emit_by_name(cancelbutton, "clicked"); | ||
1750 | return true; | ||
1751 | } | ||
1752 | |||
1753 | return false; | ||
1754 | } | ||
1755 | |||
1756 | enum { MB_OK, MB_YESNO }; | ||
1757 | |||
1758 | static void align_label(GtkLabel *label, double x, double y) | ||
1759 | { | ||
1760 | #if GTK_CHECK_VERSION(3,16,0) | ||
1761 | gtk_label_set_xalign(label, x); | ||
1762 | gtk_label_set_yalign(label, y); | ||
1763 | #elif GTK_CHECK_VERSION(3,14,0) | ||
1764 | gtk_widget_set_halign(GTK_WIDGET(label), | ||
1765 | x == 0 ? GTK_ALIGN_START : | ||
1766 | x == 1 ? GTK_ALIGN_END : GTK_ALIGN_CENTER); | ||
1767 | gtk_widget_set_valign(GTK_WIDGET(label), | ||
1768 | y == 0 ? GTK_ALIGN_START : | ||
1769 | y == 1 ? GTK_ALIGN_END : GTK_ALIGN_CENTER); | ||
1770 | #else | ||
1771 | gtk_misc_set_alignment(GTK_MISC(label), x, y); | ||
1772 | #endif | ||
1773 | } | ||
1774 | |||
1775 | #if GTK_CHECK_VERSION(3,0,0) | ||
1776 | bool message_box(GtkWidget *parent, const char *title, const char *msg, | ||
1777 | bool centre, int type) | ||
1778 | { | ||
1779 | GtkWidget *window; | ||
1780 | gint ret; | ||
1781 | |||
1782 | window = gtk_message_dialog_new | ||
1783 | (GTK_WINDOW(parent), | ||
1784 | (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), | ||
1785 | (type == MB_OK ? GTK_MESSAGE_INFO : GTK_MESSAGE_QUESTION), | ||
1786 | (type == MB_OK ? GTK_BUTTONS_OK : GTK_BUTTONS_YES_NO), | ||
1787 | "%s", msg); | ||
1788 | gtk_window_set_title(GTK_WINDOW(window), title); | ||
1789 | ret = gtk_dialog_run(GTK_DIALOG(window)); | ||
1790 | gtk_widget_destroy(window); | ||
1791 | return (type == MB_OK ? true : (ret == GTK_RESPONSE_YES)); | ||
1792 | } | ||
1793 | #else /* GTK_CHECK_VERSION(3,0,0) */ | ||
1794 | static void msgbox_button_clicked(GtkButton *button, gpointer data) | ||
1795 | { | ||
1796 | GtkWidget *window = GTK_WIDGET(data); | ||
1797 | int v, *ip; | ||
1798 | |||
1799 | ip = (int *)g_object_get_data(G_OBJECT(window), "user-data"); | ||
1800 | v = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "user-data")); | ||
1801 | *ip = v; | ||
1802 | |||
1803 | gtk_widget_destroy(GTK_WIDGET(data)); | ||
1804 | } | ||
1805 | |||
1806 | bool message_box(GtkWidget *parent, const char *title, const char *msg, | ||
1807 | bool centre, int type) | ||
1808 | { | ||
1809 | GtkWidget *window, *hbox, *text, *button; | ||
1810 | char *titles; | ||
1811 | int i, def, cancel; | ||
1812 | |||
1813 | window = gtk_dialog_new(); | ||
1814 | text = gtk_label_new(msg); | ||
1815 | align_label(GTK_LABEL(text), 0.0, 0.0); | ||
1816 | hbox = gtk_hbox_new(false, 0); | ||
1817 | gtk_box_pack_start(GTK_BOX(hbox), text, false, false, 20); | ||
1818 | gtk_box_pack_start | ||
1819 | (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window))), | ||
1820 | hbox, false, false, 20); | ||
1821 | gtk_widget_show(text); | ||
1822 | gtk_widget_show(hbox); | ||
1823 | gtk_window_set_title(GTK_WINDOW(window), title); | ||
1824 | gtk_label_set_line_wrap(GTK_LABEL(text), true); | ||
1825 | |||
1826 | if (type == MB_OK) { | ||
1827 | titles = LABEL_OK "\0"; | ||
1828 | def = cancel = 0; | ||
1829 | } else { | ||
1830 | assert(type == MB_YESNO); | ||
1831 | titles = LABEL_NO "\0" LABEL_YES "\0"; | ||
1832 | def = 1; | ||
1833 | cancel = 0; | ||
1834 | } | ||
1835 | i = 0; | ||
1836 | |||
1837 | while (*titles) { | ||
1838 | button = gtk_button_new_with_our_label(titles); | ||
1839 | gtk_box_pack_end | ||
1840 | (GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(window))), | ||
1841 | button, false, false, 0); | ||
1842 | gtk_widget_show(button); | ||
1843 | if (i == def) { | ||
1844 | gtk_widget_set_can_default(button, true); | ||
1845 | gtk_window_set_default(GTK_WINDOW(window), button); | ||
1846 | } | ||
1847 | if (i == cancel) { | ||
1848 | g_signal_connect(G_OBJECT(window), "key_press_event", | ||
1849 | G_CALLBACK(win_key_press), button); | ||
1850 | } | ||
1851 | g_signal_connect(G_OBJECT(button), "clicked", | ||
1852 | G_CALLBACK(msgbox_button_clicked), window); | ||
1853 | g_object_set_data(G_OBJECT(button), "user-data", | ||
1854 | GINT_TO_POINTER(i)); | ||
1855 | titles += strlen(titles)+1; | ||
1856 | i++; | ||
1857 | } | ||
1858 | g_object_set_data(G_OBJECT(window), "user-data", &i); | ||
1859 | g_signal_connect(G_OBJECT(window), "destroy", | ||
1860 | G_CALLBACK(window_destroy), NULL); | ||
1861 | gtk_window_set_modal(GTK_WINDOW(window), true); | ||
1862 | gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(parent)); | ||
1863 | /* set_transient_window_pos(parent, window); */ | ||
1864 | gtk_widget_show(window); | ||
1865 | i = -1; | ||
1866 | gtk_main(); | ||
1867 | return (type == MB_YESNO ? i == 1 : true); | ||
1868 | } | ||
1869 | #endif /* GTK_CHECK_VERSION(3,0,0) */ | ||
1870 | |||
1871 | void error_box(GtkWidget *parent, const char *msg) | ||
1872 | { | ||
1873 | message_box(parent, "Error", msg, false, MB_OK); | ||
1874 | } | ||
1875 | |||
1876 | static void config_ok_button_clicked(GtkButton *button, gpointer data) | ||
1877 | { | ||
1878 | frontend *fe = (frontend *)data; | ||
1879 | const char *err; | ||
1880 | |||
1881 | err = midend_set_config(fe->me, fe->cfg_which, fe->cfg); | ||
1882 | |||
1883 | if (err) | ||
1884 | error_box(fe->cfgbox, err); | ||
1885 | else { | ||
1886 | fe->cfgret = true; | ||
1887 | gtk_widget_destroy(fe->cfgbox); | ||
1888 | changed_preset(fe); | ||
1889 | } | ||
1890 | } | ||
1891 | |||
1892 | static void config_cancel_button_clicked(GtkButton *button, gpointer data) | ||
1893 | { | ||
1894 | frontend *fe = (frontend *)data; | ||
1895 | |||
1896 | gtk_widget_destroy(fe->cfgbox); | ||
1897 | } | ||
1898 | |||
1899 | static gint editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data) | ||
1900 | { | ||
1901 | /* | ||
1902 | * GtkEntry has a nasty habit of eating the Return key, which | ||
1903 | * is unhelpful since it doesn't actually _do_ anything with it | ||
1904 | * (it calls gtk_widget_activate, but our edit boxes never need | ||
1905 | * activating). So I catch Return before GtkEntry sees it, and | ||
1906 | * pass it straight on to the parent widget. Effect: hitting | ||
1907 | * Return in an edit box will now activate the default button | ||
1908 | * in the dialog just like it will everywhere else. | ||
1909 | */ | ||
1910 | if (event->keyval == GDK_KEY_Return && | ||
1911 | gtk_widget_get_parent(widget) != NULL) { | ||
1912 | gint return_val; | ||
1913 | g_signal_stop_emission_by_name(G_OBJECT(widget), "key_press_event"); | ||
1914 | g_signal_emit_by_name(G_OBJECT(gtk_widget_get_parent(widget)), | ||
1915 | "key_press_event", event, &return_val); | ||
1916 | return return_val; | ||
1917 | } | ||
1918 | return false; | ||
1919 | } | ||
1920 | |||
1921 | static void editbox_changed(GtkEditable *ed, gpointer data) | ||
1922 | { | ||
1923 | config_item *i = (config_item *)data; | ||
1924 | |||
1925 | assert(i->type == C_STRING); | ||
1926 | sfree(i->u.string.sval); | ||
1927 | i->u.string.sval = dupstr(gtk_entry_get_text(GTK_ENTRY(ed))); | ||
1928 | } | ||
1929 | |||
1930 | static void button_toggled(GtkToggleButton *tb, gpointer data) | ||
1931 | { | ||
1932 | config_item *i = (config_item *)data; | ||
1933 | |||
1934 | assert(i->type == C_BOOLEAN); | ||
1935 | i->u.boolean.bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb)); | ||
1936 | } | ||
1937 | |||
1938 | static void droplist_sel(GtkComboBox *combo, gpointer data) | ||
1939 | { | ||
1940 | config_item *i = (config_item *)data; | ||
1941 | |||
1942 | assert(i->type == C_CHOICES); | ||
1943 | i->u.choices.selected = gtk_combo_box_get_active(combo); | ||
1944 | } | ||
1945 | |||
1946 | static bool get_config(frontend *fe, int which) | ||
1947 | { | ||
1948 | GtkWidget *w, *table, *cancel; | ||
1949 | GtkBox *content_box, *button_box; | ||
1950 | char *title; | ||
1951 | config_item *i; | ||
1952 | int y; | ||
1953 | |||
1954 | fe->cfg = midend_get_config(fe->me, which, &title); | ||
1955 | fe->cfg_which = which; | ||
1956 | fe->cfgret = false; | ||
1957 | |||
1958 | #if GTK_CHECK_VERSION(3,0,0) | ||
1959 | /* GtkDialog isn't quite flexible enough */ | ||
1960 | fe->cfgbox = gtk_window_new(GTK_WINDOW_TOPLEVEL); | ||
1961 | content_box = GTK_BOX(gtk_vbox_new(false, 8)); | ||
1962 | g_object_set(G_OBJECT(content_box), "margin", 8, (const char *)NULL); | ||
1963 | gtk_widget_show(GTK_WIDGET(content_box)); | ||
1964 | gtk_container_add(GTK_CONTAINER(fe->cfgbox), GTK_WIDGET(content_box)); | ||
1965 | button_box = GTK_BOX(gtk_hbox_new(false, 8)); | ||
1966 | gtk_widget_show(GTK_WIDGET(button_box)); | ||
1967 | gtk_box_pack_end(content_box, GTK_WIDGET(button_box), false, false, 0); | ||
1968 | { | ||
1969 | GtkWidget *sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); | ||
1970 | gtk_widget_show(sep); | ||
1971 | gtk_box_pack_end(content_box, sep, false, false, 0); | ||
1972 | } | ||
1973 | #else | ||
1974 | fe->cfgbox = gtk_dialog_new(); | ||
1975 | content_box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(fe->cfgbox))); | ||
1976 | button_box = GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(fe->cfgbox))); | ||
1977 | #endif | ||
1978 | gtk_window_set_title(GTK_WINDOW(fe->cfgbox), title); | ||
1979 | sfree(title); | ||
1980 | |||
1981 | w = gtk_button_new_with_our_label(LABEL_CANCEL); | ||
1982 | gtk_box_pack_end(button_box, w, false, false, 0); | ||
1983 | gtk_widget_show(w); | ||
1984 | g_signal_connect(G_OBJECT(w), "clicked", | ||
1985 | G_CALLBACK(config_cancel_button_clicked), fe); | ||
1986 | cancel = w; | ||
1987 | |||
1988 | w = gtk_button_new_with_our_label(LABEL_OK); | ||
1989 | gtk_box_pack_end(button_box, w, false, false, 0); | ||
1990 | gtk_widget_show(w); | ||
1991 | gtk_widget_set_can_default(w, true); | ||
1992 | gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w); | ||
1993 | g_signal_connect(G_OBJECT(w), "clicked", | ||
1994 | G_CALLBACK(config_ok_button_clicked), fe); | ||
1995 | |||
1996 | #if GTK_CHECK_VERSION(3,0,0) | ||
1997 | table = gtk_grid_new(); | ||
1998 | #else | ||
1999 | table = gtk_table_new(1, 2, false); | ||
2000 | #endif | ||
2001 | y = 0; | ||
2002 | gtk_box_pack_start(content_box, table, false, false, 0); | ||
2003 | gtk_widget_show(table); | ||
2004 | |||
2005 | for (i = fe->cfg; i->type != C_END; i++) { | ||
2006 | #if !GTK_CHECK_VERSION(3,0,0) | ||
2007 | gtk_table_resize(GTK_TABLE(table), y+1, 2); | ||
2008 | #endif | ||
2009 | |||
2010 | switch (i->type) { | ||
2011 | case C_STRING: | ||
2012 | /* | ||
2013 | * Edit box with a label beside it. | ||
2014 | */ | ||
2015 | |||
2016 | w = gtk_label_new(i->name); | ||
2017 | align_label(GTK_LABEL(w), 0.0, 0.5); | ||
2018 | #if GTK_CHECK_VERSION(3,0,0) | ||
2019 | gtk_grid_attach(GTK_GRID(table), w, 0, y, 1, 1); | ||
2020 | #else | ||
2021 | gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1, | ||
2022 | GTK_SHRINK | GTK_FILL, | ||
2023 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
2024 | 3, 3); | ||
2025 | #endif | ||
2026 | gtk_widget_show(w); | ||
2027 | |||
2028 | w = gtk_entry_new(); | ||
2029 | #if GTK_CHECK_VERSION(3,0,0) | ||
2030 | gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1); | ||
2031 | g_object_set(G_OBJECT(w), "hexpand", true, (const char *)NULL); | ||
2032 | #else | ||
2033 | gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1, | ||
2034 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
2035 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
2036 | 3, 3); | ||
2037 | #endif | ||
2038 | gtk_entry_set_text(GTK_ENTRY(w), i->u.string.sval); | ||
2039 | g_signal_connect(G_OBJECT(w), "changed", | ||
2040 | G_CALLBACK(editbox_changed), i); | ||
2041 | g_signal_connect(G_OBJECT(w), "key_press_event", | ||
2042 | G_CALLBACK(editbox_key), NULL); | ||
2043 | gtk_widget_show(w); | ||
2044 | |||
2045 | break; | ||
2046 | |||
2047 | case C_BOOLEAN: | ||
2048 | /* | ||
2049 | * Simple checkbox. | ||
2050 | */ | ||
2051 | w = gtk_check_button_new_with_label(i->name); | ||
2052 | g_signal_connect(G_OBJECT(w), "toggled", | ||
2053 | G_CALLBACK(button_toggled), i); | ||
2054 | #if GTK_CHECK_VERSION(3,0,0) | ||
2055 | gtk_grid_attach(GTK_GRID(table), w, 0, y, 2, 1); | ||
2056 | g_object_set(G_OBJECT(w), "hexpand", true, (const char *)NULL); | ||
2057 | #else | ||
2058 | gtk_table_attach(GTK_TABLE(table), w, 0, 2, y, y+1, | ||
2059 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
2060 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
2061 | 3, 3); | ||
2062 | #endif | ||
2063 | gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), | ||
2064 | i->u.boolean.bval); | ||
2065 | gtk_widget_show(w); | ||
2066 | break; | ||
2067 | |||
2068 | case C_CHOICES: | ||
2069 | /* | ||
2070 | * Drop-down list (GtkComboBox). | ||
2071 | */ | ||
2072 | |||
2073 | w = gtk_label_new(i->name); | ||
2074 | align_label(GTK_LABEL(w), 0.0, 0.5); | ||
2075 | #if GTK_CHECK_VERSION(3,0,0) | ||
2076 | gtk_grid_attach(GTK_GRID(table), w, 0, y, 1, 1); | ||
2077 | #else | ||
2078 | gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1, | ||
2079 | GTK_SHRINK | GTK_FILL, | ||
2080 | GTK_EXPAND | GTK_SHRINK | GTK_FILL , | ||
2081 | 3, 3); | ||
2082 | #endif | ||
2083 | gtk_widget_show(w); | ||
2084 | |||
2085 | { | ||
2086 | int c; | ||
2087 | const char *p, *q; | ||
2088 | char *name; | ||
2089 | GtkListStore *model; | ||
2090 | GtkCellRenderer *cr; | ||
2091 | GtkTreeIter iter; | ||
2092 | |||
2093 | model = gtk_list_store_new(1, G_TYPE_STRING); | ||
2094 | |||
2095 | c = *i->u.choices.choicenames; | ||
2096 | p = i->u.choices.choicenames+1; | ||
2097 | |||
2098 | while (*p) { | ||
2099 | q = p; | ||
2100 | while (*q && *q != c) | ||
2101 | q++; | ||
2102 | |||
2103 | name = snewn(q-p+1, char); | ||
2104 | strncpy(name, p, q-p); | ||
2105 | name[q-p] = '\0'; | ||
2106 | |||
2107 | if (*q) q++; /* eat delimiter */ | ||
2108 | |||
2109 | gtk_list_store_append(model, &iter); | ||
2110 | gtk_list_store_set(model, &iter, 0, name, -1); | ||
2111 | |||
2112 | p = q; | ||
2113 | } | ||
2114 | |||
2115 | w = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); | ||
2116 | |||
2117 | gtk_combo_box_set_active(GTK_COMBO_BOX(w), | ||
2118 | i->u.choices.selected); | ||
2119 | |||
2120 | cr = gtk_cell_renderer_text_new(); | ||
2121 | gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(w), cr, true); | ||
2122 | gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(w), cr, | ||
2123 | "text", 0, NULL); | ||
2124 | |||
2125 | g_signal_connect(G_OBJECT(w), "changed", | ||
2126 | G_CALLBACK(droplist_sel), i); | ||
2127 | } | ||
2128 | |||
2129 | #if GTK_CHECK_VERSION(3,0,0) | ||
2130 | gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1); | ||
2131 | g_object_set(G_OBJECT(w), "hexpand", true, (const char *)NULL); | ||
2132 | #else | ||
2133 | gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1, | ||
2134 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
2135 | GTK_EXPAND | GTK_SHRINK | GTK_FILL, | ||
2136 | 3, 3); | ||
2137 | #endif | ||
2138 | gtk_widget_show(w); | ||
2139 | break; | ||
2140 | } | ||
2141 | |||
2142 | y++; | ||
2143 | } | ||
2144 | |||
2145 | g_signal_connect(G_OBJECT(fe->cfgbox), "destroy", | ||
2146 | G_CALLBACK(window_destroy), NULL); | ||
2147 | g_signal_connect(G_OBJECT(fe->cfgbox), "key_press_event", | ||
2148 | G_CALLBACK(win_key_press), cancel); | ||
2149 | gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), true); | ||
2150 | gtk_window_set_transient_for(GTK_WINDOW(fe->cfgbox), | ||
2151 | GTK_WINDOW(fe->window)); | ||
2152 | /* set_transient_window_pos(fe->window, fe->cfgbox); */ | ||
2153 | gtk_widget_show(fe->cfgbox); | ||
2154 | gtk_main(); | ||
2155 | |||
2156 | free_cfg(fe->cfg); | ||
2157 | |||
2158 | return fe->cfgret; | ||
2159 | } | ||
2160 | |||
2161 | static void menu_key_event(GtkMenuItem *menuitem, gpointer data) | ||
2162 | { | ||
2163 | frontend *fe = (frontend *)data; | ||
2164 | int key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), | ||
2165 | "user-data")); | ||
2166 | if (!midend_process_key(fe->me, 0, 0, key)) | ||
2167 | gtk_widget_destroy(fe->window); | ||
2168 | } | ||
2169 | |||
2170 | static void get_size(frontend *fe, int *px, int *py) | ||
2171 | { | ||
2172 | int x, y; | ||
2173 | |||
2174 | /* | ||
2175 | * Currently I don't want to make the GTK port scale large | ||
2176 | * puzzles to fit on the screen. This is because X does permit | ||
2177 | * extremely large windows and many window managers provide a | ||
2178 | * means of navigating round them, and the users I consulted | ||
2179 | * before deciding said that they'd rather have enormous puzzle | ||
2180 | * windows spanning multiple screen pages than have them | ||
2181 | * shrunk. I could change my mind later or introduce | ||
2182 | * configurability; this would be the place to do so, by | ||
2183 | * replacing the initial values of x and y with the screen | ||
2184 | * dimensions. | ||
2185 | */ | ||
2186 | x = INT_MAX; | ||
2187 | y = INT_MAX; | ||
2188 | midend_size(fe->me, &x, &y, false); | ||
2189 | *px = x; | ||
2190 | *py = y; | ||
2191 | } | ||
2192 | |||
2193 | #if !GTK_CHECK_VERSION(2,0,0) | ||
2194 | #define gtk_window_resize(win, x, y) \ | ||
2195 | gdk_window_resize(GTK_WIDGET(win)->window, x, y) | ||
2196 | #endif | ||
2197 | |||
2198 | /* | ||
2199 | * Called when any other code in this file has changed the | ||
2200 | * selected game parameters. | ||
2201 | */ | ||
2202 | static void changed_preset(frontend *fe) | ||
2203 | { | ||
2204 | int n = midend_which_preset(fe->me); | ||
2205 | |||
2206 | fe->preset_threaded = true; | ||
2207 | if (n < 0 && fe->preset_custom) { | ||
2208 | gtk_check_menu_item_set_active( | ||
2209 | GTK_CHECK_MENU_ITEM(fe->preset_custom), | ||
2210 | true); | ||
2211 | } else { | ||
2212 | GSList *gs = fe->preset_radio; | ||
2213 | GSList *found = NULL; | ||
2214 | |||
2215 | for (gs = fe->preset_radio; gs; gs = gs->next) { | ||
2216 | struct preset_menu_entry *entry = | ||
2217 | (struct preset_menu_entry *)g_object_get_data( | ||
2218 | G_OBJECT(gs->data), "user-data"); | ||
2219 | if (!entry || entry->id != n) | ||
2220 | gtk_check_menu_item_set_active( | ||
2221 | GTK_CHECK_MENU_ITEM(gs->data), false); | ||
2222 | else | ||
2223 | found = gs; | ||
2224 | } | ||
2225 | if (found) | ||
2226 | gtk_check_menu_item_set_active( | ||
2227 | GTK_CHECK_MENU_ITEM(found->data), true); | ||
2228 | } | ||
2229 | fe->preset_threaded = false; | ||
2230 | |||
2231 | /* | ||
2232 | * Update the greying on the Copy menu option. | ||
2233 | */ | ||
2234 | if (fe->copy_menu_item) { | ||
2235 | bool enabled = midend_can_format_as_text_now(fe->me); | ||
2236 | gtk_widget_set_sensitive(fe->copy_menu_item, enabled); | ||
2237 | } | ||
2238 | } | ||
2239 | |||
2240 | #if !GTK_CHECK_VERSION(3,0,0) | ||
2241 | static bool not_size_allocated_yet(GtkWidget *w) | ||
2242 | { | ||
2243 | /* | ||
2244 | * This function tests whether a widget has not yet taken up space | ||
2245 | * on the screen which it will occupy in future. (Therefore, it | ||
2246 | * returns true only if the widget does exist but does not have a | ||
2247 | * size allocation. A null widget is already taking up all the | ||
2248 | * space it ever will.) | ||
2249 | */ | ||
2250 | if (!w) | ||
2251 | return false; /* nonexistent widgets aren't a problem */ | ||
2252 | |||
2253 | #if GTK_CHECK_VERSION(2,18,0) /* skip if no gtk_widget_get_allocation */ | ||
2254 | { | ||
2255 | GtkAllocation a; | ||
2256 | gtk_widget_get_allocation(w, &a); | ||
2257 | if (a.height == 0 || a.width == 0) | ||
2258 | return true; /* widget exists but has no size yet */ | ||
2259 | } | ||
2260 | #endif | ||
2261 | |||
2262 | return false; | ||
2263 | } | ||
2264 | |||
2265 | static void try_shrink_drawing_area(frontend *fe) | ||
2266 | { | ||
2267 | if (fe->drawing_area_shrink_pending && | ||
2268 | (!fe->menubar_is_local || !not_size_allocated_yet(fe->menubar)) && | ||
2269 | !not_size_allocated_yet(fe->statusbar)) { | ||
2270 | /* | ||
2271 | * In order to permit the user to resize the window smaller as | ||
2272 | * well as bigger, we call this function after the window size | ||
2273 | * has ended up where we want it. This shouldn't shrink the | ||
2274 | * window immediately; it just arranges that the next time the | ||
2275 | * user tries to shrink it, they can. | ||
2276 | * | ||
2277 | * However, at puzzle creation time, we defer the first of | ||
2278 | * these operations until after the menu bar and status bar | ||
2279 | * are actually visible. On Ubuntu 12.04 I've found that these | ||
2280 | * can take a while to be displayed, and that it's a mistake | ||
2281 | * to reduce the drawing area's size allocation before they've | ||
2282 | * turned up or else the drawing area makes room for them by | ||
2283 | * shrinking to less than the size we intended. | ||
2284 | */ | ||
2285 | gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), 1, 1); | ||
2286 | fe->drawing_area_shrink_pending = false; | ||
2287 | } | ||
2288 | } | ||
2289 | #endif /* !GTK_CHECK_VERSION(3,0,0) */ | ||
2290 | |||
2291 | static gint configure_window(GtkWidget *widget, | ||
2292 | GdkEventConfigure *event, gpointer data) | ||
2293 | { | ||
2294 | #if !GTK_CHECK_VERSION(3,0,0) | ||
2295 | /* | ||
2296 | * When the main puzzle window changes size, it might be because | ||
2297 | * the menu bar or status bar has turned up after starting off | ||
2298 | * absent, in which case we should have another go at enacting a | ||
2299 | * pending shrink of the drawing area. | ||
2300 | */ | ||
2301 | frontend *fe = (frontend *)data; | ||
2302 | try_shrink_drawing_area(fe); | ||
2303 | #endif | ||
2304 | return false; | ||
2305 | } | ||
2306 | |||
2307 | #if GTK_CHECK_VERSION(3,0,0) | ||
2308 | static int window_extra_height(frontend *fe) | ||
2309 | { | ||
2310 | int ret = 0; | ||
2311 | if (fe->menubar) { | ||
2312 | GtkRequisition req; | ||
2313 | gtk_widget_get_preferred_size(fe->menubar, &req, NULL); | ||
2314 | ret += req.height; | ||
2315 | } | ||
2316 | if (fe->statusbar) { | ||
2317 | GtkRequisition req; | ||
2318 | gtk_widget_get_preferred_size(fe->statusbar, &req, NULL); | ||
2319 | ret += req.height; | ||
2320 | } | ||
2321 | return ret; | ||
2322 | } | ||
2323 | #endif | ||
2324 | |||
2325 | static void resize_fe(frontend *fe) | ||
2326 | { | ||
2327 | int x, y; | ||
2328 | |||
2329 | get_size(fe, &x, &y); | ||
2330 | |||
2331 | #if GTK_CHECK_VERSION(3,0,0) | ||
2332 | gtk_window_resize(GTK_WINDOW(fe->window), x, y + window_extra_height(fe)); | ||
2333 | fe->awaiting_resize_ack = true; | ||
2334 | #else | ||
2335 | fe->drawing_area_shrink_pending = false; | ||
2336 | gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y); | ||
2337 | { | ||
2338 | GtkRequisition req; | ||
2339 | gtk_widget_size_request(GTK_WIDGET(fe->window), &req); | ||
2340 | gtk_window_resize(GTK_WINDOW(fe->window), req.width, req.height); | ||
2341 | } | ||
2342 | fe->drawing_area_shrink_pending = true; | ||
2343 | try_shrink_drawing_area(fe); | ||
2344 | #endif | ||
2345 | } | ||
2346 | |||
2347 | static void menu_preset_event(GtkMenuItem *menuitem, gpointer data) | ||
2348 | { | ||
2349 | frontend *fe = (frontend *)data; | ||
2350 | struct preset_menu_entry *entry = | ||
2351 | (struct preset_menu_entry *)g_object_get_data( | ||
2352 | G_OBJECT(menuitem), "user-data"); | ||
2353 | |||
2354 | if (fe->preset_threaded || | ||
2355 | (GTK_IS_CHECK_MENU_ITEM(menuitem) && | ||
2356 | !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)))) | ||
2357 | return; | ||
2358 | midend_set_params(fe->me, entry->params); | ||
2359 | midend_new_game(fe->me); | ||
2360 | changed_preset(fe); | ||
2361 | resize_fe(fe); | ||
2362 | midend_redraw(fe->me); | ||
2363 | } | ||
2364 | |||
2365 | GdkAtom compound_text_atom, utf8_string_atom; | ||
2366 | bool paste_initialised = false; | ||
2367 | |||
2368 | static void set_selection(frontend *fe, GdkAtom selection) | ||
2369 | { | ||
2370 | if (!paste_initialised) { | ||
2371 | compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", false); | ||
2372 | utf8_string_atom = gdk_atom_intern("UTF8_STRING", false); | ||
2373 | paste_initialised = true; | ||
2374 | } | ||
2375 | |||
2376 | /* | ||
2377 | * For this simple application we can safely assume that the | ||
2378 | * data passed to this function is pure ASCII, which means we | ||
2379 | * can return precisely the same stuff for types STRING, | ||
2380 | * COMPOUND_TEXT or UTF8_STRING. | ||
2381 | */ | ||
2382 | |||
2383 | if (gtk_selection_owner_set(fe->area, selection, CurrentTime)) { | ||
2384 | gtk_selection_clear_targets(fe->area, selection); | ||
2385 | gtk_selection_add_target(fe->area, selection, | ||
2386 | GDK_SELECTION_TYPE_STRING, 1); | ||
2387 | gtk_selection_add_target(fe->area, selection, compound_text_atom, 1); | ||
2388 | gtk_selection_add_target(fe->area, selection, utf8_string_atom, 1); | ||
2389 | } | ||
2390 | } | ||
2391 | |||
2392 | void write_clip(frontend *fe, char *data) | ||
2393 | { | ||
2394 | if (fe->paste_data) | ||
2395 | sfree(fe->paste_data); | ||
2396 | |||
2397 | fe->paste_data = data; | ||
2398 | fe->paste_data_len = strlen(data); | ||
2399 | |||
2400 | set_selection(fe, GDK_SELECTION_PRIMARY); | ||
2401 | set_selection(fe, GDK_SELECTION_CLIPBOARD); | ||
2402 | } | ||
2403 | |||
2404 | void selection_get(GtkWidget *widget, GtkSelectionData *seldata, | ||
2405 | guint info, guint time_stamp, gpointer data) | ||
2406 | { | ||
2407 | frontend *fe = (frontend *)data; | ||
2408 | gtk_selection_data_set(seldata, gtk_selection_data_get_target(seldata), 8, | ||
2409 | fe->paste_data, fe->paste_data_len); | ||
2410 | } | ||
2411 | |||
2412 | gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata, | ||
2413 | gpointer data) | ||
2414 | { | ||
2415 | frontend *fe = (frontend *)data; | ||
2416 | |||
2417 | if (fe->paste_data) | ||
2418 | sfree(fe->paste_data); | ||
2419 | fe->paste_data = NULL; | ||
2420 | fe->paste_data_len = 0; | ||
2421 | return true; | ||
2422 | } | ||
2423 | |||
2424 | static void menu_copy_event(GtkMenuItem *menuitem, gpointer data) | ||
2425 | { | ||
2426 | frontend *fe = (frontend *)data; | ||
2427 | char *text; | ||
2428 | |||
2429 | text = midend_text_format(fe->me); | ||
2430 | |||
2431 | if (text) { | ||
2432 | write_clip(fe, text); | ||
2433 | } else { | ||
2434 | gdk_display_beep(gdk_display_get_default()); | ||
2435 | } | ||
2436 | } | ||
2437 | |||
2438 | #ifdef OLD_FILESEL | ||
2439 | |||
2440 | static void filesel_ok(GtkButton *button, gpointer data) | ||
2441 | { | ||
2442 | frontend *fe = (frontend *)data; | ||
2443 | |||
2444 | gpointer filesel = g_object_get_data(G_OBJECT(button), "user-data"); | ||
2445 | |||
2446 | const char *name = | ||
2447 | gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel)); | ||
2448 | |||
2449 | fe->filesel_name = dupstr(name); | ||
2450 | } | ||
2451 | |||
2452 | static char *file_selector(frontend *fe, const char *title, int save) | ||
2453 | { | ||
2454 | GtkWidget *filesel = | ||
2455 | gtk_file_selection_new(title); | ||
2456 | |||
2457 | fe->filesel_name = NULL; | ||
2458 | |||
2459 | gtk_window_set_modal(GTK_WINDOW(filesel), true); | ||
2460 | g_object_set_data | ||
2461 | (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "user-data", | ||
2462 | (gpointer)filesel); | ||
2463 | g_signal_connect | ||
2464 | (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", | ||
2465 | G_CALLBACK(filesel_ok), fe); | ||
2466 | g_signal_connect_swapped | ||
2467 | (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", | ||
2468 | G_CALLBACK(gtk_widget_destroy), (gpointer)filesel); | ||
2469 | g_signal_connect_object | ||
2470 | (G_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button), "clicked", | ||
2471 | G_CALLBACK(gtk_widget_destroy), (gpointer)filesel); | ||
2472 | g_signal_connect(G_OBJECT(filesel), "destroy", | ||
2473 | G_CALLBACK(window_destroy), NULL); | ||
2474 | gtk_widget_show(filesel); | ||
2475 | gtk_window_set_transient_for(GTK_WINDOW(filesel), GTK_WINDOW(fe->window)); | ||
2476 | gtk_main(); | ||
2477 | |||
2478 | return fe->filesel_name; | ||
2479 | } | ||
2480 | |||
2481 | #else | ||
2482 | |||
2483 | static char *file_selector(frontend *fe, const char *title, bool save) | ||
2484 | { | ||
2485 | char *filesel_name = NULL; | ||
2486 | |||
2487 | GtkWidget *filesel = | ||
2488 | gtk_file_chooser_dialog_new(title, | ||
2489 | GTK_WINDOW(fe->window), | ||
2490 | save ? GTK_FILE_CHOOSER_ACTION_SAVE : | ||
2491 | GTK_FILE_CHOOSER_ACTION_OPEN, | ||
2492 | LABEL_CANCEL, GTK_RESPONSE_CANCEL, | ||
2493 | save ? LABEL_SAVE : LABEL_OPEN, | ||
2494 | GTK_RESPONSE_ACCEPT, | ||
2495 | NULL); | ||
2496 | |||
2497 | if (gtk_dialog_run(GTK_DIALOG(filesel)) == GTK_RESPONSE_ACCEPT) { | ||
2498 | char *name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filesel)); | ||
2499 | filesel_name = dupstr(name); | ||
2500 | g_free(name); | ||
2501 | } | ||
2502 | |||
2503 | gtk_widget_destroy(filesel); | ||
2504 | |||
2505 | return filesel_name; | ||
2506 | } | ||
2507 | |||
2508 | #endif | ||
2509 | |||
2510 | #ifdef USE_PRINTING | ||
2511 | GObject *create_print_widget(GtkPrintOperation *print, gpointer data) | ||
2512 | { | ||
2513 | GtkLabel *count_label, *width_label, *height_label, | ||
2514 | *scale_llabel, *scale_rlabel; | ||
2515 | GtkBox *scale_hbox; | ||
2516 | GtkWidget *grid; | ||
2517 | frontend *fe = (frontend *)data; | ||
2518 | |||
2519 | fe->printcount_spin_button = | ||
2520 | GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 999, 1)); | ||
2521 | gtk_spin_button_set_numeric(fe->printcount_spin_button, true); | ||
2522 | gtk_spin_button_set_snap_to_ticks(fe->printcount_spin_button, true); | ||
2523 | fe->printw_spin_button = | ||
2524 | GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 99, 1)); | ||
2525 | gtk_spin_button_set_numeric(fe->printw_spin_button, true); | ||
2526 | gtk_spin_button_set_snap_to_ticks(fe->printw_spin_button, true); | ||
2527 | fe->printh_spin_button = | ||
2528 | GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 99, 1)); | ||
2529 | gtk_spin_button_set_numeric(fe->printh_spin_button, true); | ||
2530 | gtk_spin_button_set_snap_to_ticks(fe->printh_spin_button, true); | ||
2531 | fe->printscale_spin_button = | ||
2532 | GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 1000, 1)); | ||
2533 | gtk_spin_button_set_digits(fe->printscale_spin_button, 1); | ||
2534 | gtk_spin_button_set_numeric(fe->printscale_spin_button, true); | ||
2535 | if (thegame.can_solve) { | ||
2536 | fe->soln_check_button = | ||
2537 | GTK_CHECK_BUTTON( | ||
2538 | gtk_check_button_new_with_label("Print solutions")); | ||
2539 | } | ||
2540 | if (thegame.can_print_in_colour) { | ||
2541 | fe->colour_check_button = | ||
2542 | GTK_CHECK_BUTTON( | ||
2543 | gtk_check_button_new_with_label("Print in color")); | ||
2544 | } | ||
2545 | |||
2546 | /* Set defaults to what was selected last time. */ | ||
2547 | gtk_spin_button_set_value(fe->printcount_spin_button, | ||
2548 | (gdouble)fe->printcount); | ||
2549 | gtk_spin_button_set_value(fe->printw_spin_button, | ||
2550 | (gdouble)fe->printw); | ||
2551 | gtk_spin_button_set_value(fe->printh_spin_button, | ||
2552 | (gdouble)fe->printh); | ||
2553 | gtk_spin_button_set_value(fe->printscale_spin_button, | ||
2554 | (gdouble)fe->printscale); | ||
2555 | if (thegame.can_solve) { | ||
2556 | gtk_toggle_button_set_active( | ||
2557 | GTK_TOGGLE_BUTTON(fe->soln_check_button), fe->printsolns); | ||
2558 | } | ||
2559 | if (thegame.can_print_in_colour) { | ||
2560 | gtk_toggle_button_set_active( | ||
2561 | GTK_TOGGLE_BUTTON(fe->colour_check_button), fe->printcolour); | ||
2562 | } | ||
2563 | |||
2564 | count_label = GTK_LABEL(gtk_label_new("Puzzles to print:")); | ||
2565 | width_label = GTK_LABEL(gtk_label_new("Puzzles across:")); | ||
2566 | height_label = GTK_LABEL(gtk_label_new("Puzzles down:")); | ||
2567 | scale_llabel = GTK_LABEL(gtk_label_new("Puzzle scale:")); | ||
2568 | scale_rlabel = GTK_LABEL(gtk_label_new("%")); | ||
2569 | #if GTK_CHECK_VERSION(3,0,0) | ||
2570 | gtk_widget_set_halign(GTK_WIDGET(count_label), GTK_ALIGN_START); | ||
2571 | gtk_widget_set_halign(GTK_WIDGET(width_label), GTK_ALIGN_START); | ||
2572 | gtk_widget_set_halign(GTK_WIDGET(height_label), GTK_ALIGN_START); | ||
2573 | gtk_widget_set_halign(GTK_WIDGET(scale_llabel), GTK_ALIGN_START); | ||
2574 | #else | ||
2575 | gtk_misc_set_alignment(GTK_MISC(count_label), 0, 0); | ||
2576 | gtk_misc_set_alignment(GTK_MISC(width_label), 0, 0); | ||
2577 | gtk_misc_set_alignment(GTK_MISC(height_label), 0, 0); | ||
2578 | gtk_misc_set_alignment(GTK_MISC(scale_llabel), 0, 0); | ||
2579 | #endif | ||
2580 | |||
2581 | scale_hbox = GTK_BOX(gtk_hbox_new(false, 6)); | ||
2582 | gtk_box_pack_start(scale_hbox, GTK_WIDGET(fe->printscale_spin_button), | ||
2583 | false, false, 0); | ||
2584 | gtk_box_pack_start(scale_hbox, GTK_WIDGET(scale_rlabel), | ||
2585 | false, false, 0); | ||
2586 | |||
2587 | #if GTK_CHECK_VERSION(3,0,0) | ||
2588 | grid = gtk_grid_new(); | ||
2589 | gtk_grid_set_column_spacing(GTK_GRID(grid), 18); | ||
2590 | gtk_grid_set_row_spacing(GTK_GRID(grid), 18); | ||
2591 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(count_label), 0, 0, 1, 1); | ||
2592 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(width_label), 0, 1, 1, 1); | ||
2593 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(height_label), 0, 2, 1, 1); | ||
2594 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(scale_llabel), 0, 3, 1, 1); | ||
2595 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->printcount_spin_button), | ||
2596 | 1, 0, 1, 1); | ||
2597 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->printw_spin_button), | ||
2598 | 1, 1, 1, 1); | ||
2599 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->printh_spin_button), | ||
2600 | 1, 2, 1, 1); | ||
2601 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(scale_hbox), 1, 3, 1, 1); | ||
2602 | if (thegame.can_solve) { | ||
2603 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->soln_check_button), | ||
2604 | 0, 4, 1, 1); | ||
2605 | } | ||
2606 | if (thegame.can_print_in_colour) { | ||
2607 | gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->colour_check_button), | ||
2608 | thegame.can_solve, 4, 1, 1); | ||
2609 | } | ||
2610 | #else | ||
2611 | grid = gtk_table_new((thegame.can_solve || thegame.can_print_in_colour) ? | ||
2612 | 5 : 4, 2, false); | ||
2613 | gtk_table_set_col_spacings(GTK_TABLE(grid), 18); | ||
2614 | gtk_table_set_row_spacings(GTK_TABLE(grid), 18); | ||
2615 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(count_label), 0, 1, 0, 1, | ||
2616 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2617 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(width_label), 0, 1, 1, 2, | ||
2618 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2619 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(height_label), 0, 1, 2, 3, | ||
2620 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2621 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(scale_llabel), 0, 1, 3, 4, | ||
2622 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2623 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->printcount_spin_button), | ||
2624 | 1, 2, 0, 1, | ||
2625 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2626 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->printw_spin_button), | ||
2627 | 1, 2, 1, 2, | ||
2628 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2629 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->printh_spin_button), | ||
2630 | 1, 2, 2, 3, | ||
2631 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2632 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(scale_hbox), 1, 2, 3, 4, | ||
2633 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2634 | if (thegame.can_solve) { | ||
2635 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->soln_check_button), | ||
2636 | 0, 1, 4, 5, | ||
2637 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2638 | } | ||
2639 | if (thegame.can_print_in_colour) { | ||
2640 | gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->colour_check_button), | ||
2641 | thegame.can_solve, thegame.can_solve + 1, 4, 5, | ||
2642 | GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); | ||
2643 | } | ||
2644 | #endif | ||
2645 | gtk_container_set_border_width(GTK_CONTAINER(grid), 12); | ||
2646 | |||
2647 | gtk_widget_show_all(grid); | ||
2648 | |||
2649 | return G_OBJECT(grid); | ||
2650 | } | ||
2651 | |||
2652 | void apply_print_widget(GtkPrintOperation *print, | ||
2653 | GtkWidget *widget, gpointer data) | ||
2654 | { | ||
2655 | frontend *fe = (frontend *)data; | ||
2656 | |||
2657 | /* We ignore `widget' because it is easier and faster to store the | ||
2658 | widgets we need in `fe' then to get the children of `widget'. */ | ||
2659 | fe->printcount = | ||
2660 | gtk_spin_button_get_value_as_int(fe->printcount_spin_button); | ||
2661 | fe->printw = gtk_spin_button_get_value_as_int(fe->printw_spin_button); | ||
2662 | fe->printh = gtk_spin_button_get_value_as_int(fe->printh_spin_button); | ||
2663 | fe->printscale = gtk_spin_button_get_value(fe->printscale_spin_button); | ||
2664 | if (thegame.can_solve) { | ||
2665 | fe->printsolns = | ||
2666 | gtk_toggle_button_get_active( | ||
2667 | GTK_TOGGLE_BUTTON(fe->soln_check_button)); | ||
2668 | } | ||
2669 | if (thegame.can_print_in_colour) { | ||
2670 | fe->printcolour = | ||
2671 | gtk_toggle_button_get_active( | ||
2672 | GTK_TOGGLE_BUTTON(fe->colour_check_button)); | ||
2673 | } | ||
2674 | } | ||
2675 | |||
2676 | void print_begin(GtkPrintOperation *printop, | ||
2677 | GtkPrintContext *context, gpointer data) | ||
2678 | { | ||
2679 | frontend *fe = (frontend *)data; | ||
2680 | midend *nme = NULL; /* non-interactive midend for bulk puzzle generation */ | ||
2681 | int i; | ||
2682 | |||
2683 | fe->printcontext = context; | ||
2684 | fe->cr = gtk_print_context_get_cairo_context(context); | ||
2685 | |||
2686 | /* | ||
2687 | * Create our document structure and fill it up with puzzles. | ||
2688 | */ | ||
2689 | fe->doc = document_new(fe->printw, fe->printh, fe->printscale / 100.0F); | ||
2690 | |||
2691 | for (i = 0; i < fe->printcount; i++) { | ||
2692 | const char *err; | ||
2693 | |||
2694 | if (i == 0) { | ||
2695 | err = midend_print_puzzle(fe->me, fe->doc, fe->printsolns); | ||
2696 | } else { | ||
2697 | if (!nme) { | ||
2698 | game_params *params; | ||
2699 | |||
2700 | nme = midend_new(NULL, &thegame, NULL, NULL); | ||
2701 | |||
2702 | /* | ||
2703 | * Set the non-interactive mid-end to have the same | ||
2704 | * parameters as the standard one. | ||
2705 | */ | ||
2706 | params = midend_get_params(fe->me); | ||
2707 | midend_set_params(nme, params); | ||
2708 | thegame.free_params(params); | ||
2709 | } | ||
2710 | |||
2711 | midend_new_game(nme); | ||
2712 | err = midend_print_puzzle(nme, fe->doc, fe->printsolns); | ||
2713 | } | ||
2714 | |||
2715 | if (err) { | ||
2716 | error_box(fe->window, err); | ||
2717 | return; | ||
2718 | } | ||
2719 | } | ||
2720 | |||
2721 | if (nme) | ||
2722 | midend_free(nme); | ||
2723 | |||
2724 | /* Begin the document. */ | ||
2725 | document_begin(fe->doc, fe->print_dr); | ||
2726 | } | ||
2727 | |||
2728 | void draw_page(GtkPrintOperation *printop, | ||
2729 | GtkPrintContext *context, | ||
2730 | gint page_nr, gpointer data) | ||
2731 | { | ||
2732 | frontend *fe = (frontend *)data; | ||
2733 | document_print_page(fe->doc, fe->print_dr, page_nr); | ||
2734 | } | ||
2735 | |||
2736 | void print_end(GtkPrintOperation *printop, | ||
2737 | GtkPrintContext *context, gpointer data) | ||
2738 | { | ||
2739 | frontend *fe = (frontend *)data; | ||
2740 | |||
2741 | /* End and free the document. */ | ||
2742 | document_end(fe->doc, fe->print_dr); | ||
2743 | document_free(fe->doc); | ||
2744 | fe->doc = NULL; | ||
2745 | } | ||
2746 | |||
2747 | static void print_dialog(frontend *fe) | ||
2748 | { | ||
2749 | GError *error; | ||
2750 | static GtkPrintSettings *settings = NULL; | ||
2751 | static GtkPageSetup *page_setup = NULL; | ||
2752 | #ifndef USE_EMBED_PAGE_SETUP | ||
2753 | GtkPageSetup *new_page_setup; | ||
2754 | #endif | ||
2755 | |||
2756 | fe->printop = gtk_print_operation_new(); | ||
2757 | gtk_print_operation_set_use_full_page(fe->printop, true); | ||
2758 | gtk_print_operation_set_custom_tab_label(fe->printop, "Puzzle Settings"); | ||
2759 | g_signal_connect(fe->printop, "create-custom-widget", | ||
2760 | G_CALLBACK(create_print_widget), fe); | ||
2761 | g_signal_connect(fe->printop, "custom-widget-apply", | ||
2762 | G_CALLBACK(apply_print_widget), fe); | ||
2763 | g_signal_connect(fe->printop, "begin-print", G_CALLBACK(print_begin), fe); | ||
2764 | g_signal_connect(fe->printop, "draw-page", G_CALLBACK(draw_page), fe); | ||
2765 | g_signal_connect(fe->printop, "end-print", G_CALLBACK(print_end), fe); | ||
2766 | #ifdef USE_EMBED_PAGE_SETUP | ||
2767 | gtk_print_operation_set_embed_page_setup(fe->printop, true); | ||
2768 | #else | ||
2769 | if (page_setup == NULL) { | ||
2770 | page_setup = | ||
2771 | g_object_ref( | ||
2772 | gtk_print_operation_get_default_page_setup(fe->printop)); | ||
2773 | } | ||
2774 | if (settings == NULL) { | ||
2775 | settings = | ||
2776 | g_object_ref(gtk_print_operation_get_print_settings(fe->printop)); | ||
2777 | } | ||
2778 | new_page_setup = gtk_print_run_page_setup_dialog(GTK_WINDOW(fe->window), | ||
2779 | page_setup, settings); | ||
2780 | g_object_unref(page_setup); | ||
2781 | page_setup = new_page_setup; | ||
2782 | gtk_print_operation_set_default_page_setup(fe->printop, page_setup); | ||
2783 | #endif | ||
2784 | |||
2785 | if (settings != NULL) | ||
2786 | gtk_print_operation_set_print_settings(fe->printop, settings); | ||
2787 | if (page_setup != NULL) | ||
2788 | gtk_print_operation_set_default_page_setup(fe->printop, page_setup); | ||
2789 | |||
2790 | switch (gtk_print_operation_run(fe->printop, | ||
2791 | GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, | ||
2792 | GTK_WINDOW(fe->window), &error)) { | ||
2793 | case GTK_PRINT_OPERATION_RESULT_ERROR: | ||
2794 | error_box(fe->window, error->message); | ||
2795 | g_error_free(error); | ||
2796 | break; | ||
2797 | case GTK_PRINT_OPERATION_RESULT_APPLY: | ||
2798 | if (settings != NULL) | ||
2799 | g_object_unref(settings); | ||
2800 | settings = | ||
2801 | g_object_ref(gtk_print_operation_get_print_settings(fe->printop)); | ||
2802 | #ifdef USE_EMBED_PAGE_SETUP | ||
2803 | if (page_setup != NULL) | ||
2804 | g_object_unref(page_setup); | ||
2805 | page_setup = | ||
2806 | g_object_ref( | ||
2807 | gtk_print_operation_get_default_page_setup(fe->printop)); | ||
2808 | #endif | ||
2809 | break; | ||
2810 | default: | ||
2811 | /* Don't error out on -Werror=switch. */ | ||
2812 | break; | ||
2813 | } | ||
2814 | |||
2815 | g_object_unref(fe->printop); | ||
2816 | fe->printop = NULL; | ||
2817 | fe->printcontext = NULL; | ||
2818 | } | ||
2819 | #endif /* USE_PRINTING */ | ||
2820 | |||
2821 | struct savefile_write_ctx { | ||
2822 | FILE *fp; | ||
2823 | int error; | ||
2824 | }; | ||
2825 | |||
2826 | static void savefile_write(void *wctx, const void *buf, int len) | ||
2827 | { | ||
2828 | struct savefile_write_ctx *ctx = (struct savefile_write_ctx *)wctx; | ||
2829 | if (fwrite(buf, 1, len, ctx->fp) < len) | ||
2830 | ctx->error = errno; | ||
2831 | } | ||
2832 | |||
2833 | static bool savefile_read(void *wctx, void *buf, int len) | ||
2834 | { | ||
2835 | FILE *fp = (FILE *)wctx; | ||
2836 | int ret; | ||
2837 | |||
2838 | ret = fread(buf, 1, len, fp); | ||
2839 | return (ret == len); | ||
2840 | } | ||
2841 | |||
2842 | static void menu_save_event(GtkMenuItem *menuitem, gpointer data) | ||
2843 | { | ||
2844 | frontend *fe = (frontend *)data; | ||
2845 | char *name; | ||
2846 | |||
2847 | name = file_selector(fe, "Enter name of game file to save", true); | ||
2848 | |||
2849 | if (name) { | ||
2850 | FILE *fp; | ||
2851 | |||
2852 | if ((fp = fopen(name, "r")) != NULL) { | ||
2853 | char buf[256 + FILENAME_MAX]; | ||
2854 | fclose(fp); | ||
2855 | /* file exists */ | ||
2856 | |||
2857 | sprintf(buf, "Are you sure you want to overwrite the" | ||
2858 | " file \"%.*s\"?", | ||
2859 | FILENAME_MAX, name); | ||
2860 | if (!message_box(fe->window, "Question", buf, true, MB_YESNO)) | ||
2861 | goto free_and_return; | ||
2862 | } | ||
2863 | |||
2864 | fp = fopen(name, "w"); | ||
2865 | |||
2866 | if (!fp) { | ||
2867 | error_box(fe->window, "Unable to open save file"); | ||
2868 | goto free_and_return; | ||
2869 | } | ||
2870 | |||
2871 | { | ||
2872 | struct savefile_write_ctx ctx; | ||
2873 | ctx.fp = fp; | ||
2874 | ctx.error = 0; | ||
2875 | midend_serialise(fe->me, savefile_write, &ctx); | ||
2876 | fclose(fp); | ||
2877 | if (ctx.error) { | ||
2878 | char boxmsg[512]; | ||
2879 | sprintf(boxmsg, "Error writing save file: %.400s", | ||
2880 | strerror(ctx.error)); | ||
2881 | error_box(fe->window, boxmsg); | ||
2882 | goto free_and_return; | ||
2883 | } | ||
2884 | } | ||
2885 | free_and_return: | ||
2886 | sfree(name); | ||
2887 | } | ||
2888 | } | ||
2889 | |||
2890 | static void menu_load_event(GtkMenuItem *menuitem, gpointer data) | ||
2891 | { | ||
2892 | frontend *fe = (frontend *)data; | ||
2893 | char *name; | ||
2894 | const char *err; | ||
2895 | |||
2896 | name = file_selector(fe, "Enter name of saved game file to load", false); | ||
2897 | |||
2898 | if (name) { | ||
2899 | FILE *fp = fopen(name, "r"); | ||
2900 | sfree(name); | ||
2901 | |||
2902 | if (!fp) { | ||
2903 | error_box(fe->window, "Unable to open saved game file"); | ||
2904 | return; | ||
2905 | } | ||
2906 | |||
2907 | err = midend_deserialise(fe->me, savefile_read, fp); | ||
2908 | |||
2909 | fclose(fp); | ||
2910 | |||
2911 | if (err) { | ||
2912 | error_box(fe->window, err); | ||
2913 | return; | ||
2914 | } | ||
2915 | |||
2916 | changed_preset(fe); | ||
2917 | resize_fe(fe); | ||
2918 | midend_redraw(fe->me); | ||
2919 | } | ||
2920 | } | ||
2921 | |||
2922 | #ifdef USE_PRINTING | ||
2923 | static void menu_print_event(GtkMenuItem *menuitem, gpointer data) | ||
2924 | { | ||
2925 | frontend *fe = (frontend *)data; | ||
2926 | |||
2927 | print_dialog(fe); | ||
2928 | } | ||
2929 | #endif | ||
2930 | |||
2931 | static void menu_solve_event(GtkMenuItem *menuitem, gpointer data) | ||
2932 | { | ||
2933 | frontend *fe = (frontend *)data; | ||
2934 | const char *msg; | ||
2935 | |||
2936 | msg = midend_solve(fe->me); | ||
2937 | |||
2938 | if (msg) | ||
2939 | error_box(fe->window, msg); | ||
2940 | } | ||
2941 | |||
2942 | static void menu_restart_event(GtkMenuItem *menuitem, gpointer data) | ||
2943 | { | ||
2944 | frontend *fe = (frontend *)data; | ||
2945 | |||
2946 | midend_restart_game(fe->me); | ||
2947 | } | ||
2948 | |||
2949 | static void menu_config_event(GtkMenuItem *menuitem, gpointer data) | ||
2950 | { | ||
2951 | frontend *fe = (frontend *)data; | ||
2952 | int which = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), | ||
2953 | "user-data")); | ||
2954 | |||
2955 | if (fe->preset_threaded || | ||
2956 | (GTK_IS_CHECK_MENU_ITEM(menuitem) && | ||
2957 | !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)))) | ||
2958 | return; | ||
2959 | changed_preset(fe); /* Put the old preset back! */ | ||
2960 | if (!get_config(fe, which)) | ||
2961 | return; | ||
2962 | |||
2963 | midend_new_game(fe->me); | ||
2964 | resize_fe(fe); | ||
2965 | midend_redraw(fe->me); | ||
2966 | } | ||
2967 | |||
2968 | static void menu_about_event(GtkMenuItem *menuitem, gpointer data) | ||
2969 | { | ||
2970 | frontend *fe = (frontend *)data; | ||
2971 | |||
2972 | #if GTK_CHECK_VERSION(3,0,0) | ||
2973 | # define ABOUT_PARAMS \ | ||
2974 | "program-name", thegame.name, \ | ||
2975 | "version", ver, \ | ||
2976 | "comments", "Part of Simon Tatham's Portable Puzzle Collection" | ||
2977 | |||
2978 | extern char *const *const xpm_icons[]; | ||
2979 | extern const int n_xpm_icons; | ||
2980 | |||
2981 | if (n_xpm_icons) { | ||
2982 | GdkPixbuf *icon = gdk_pixbuf_new_from_xpm_data | ||
2983 | ((const gchar **)xpm_icons[n_xpm_icons-1]); | ||
2984 | |||
2985 | gtk_show_about_dialog | ||
2986 | (GTK_WINDOW(fe->window), | ||
2987 | ABOUT_PARAMS, | ||
2988 | "logo", icon, | ||
2989 | (const gchar *)NULL); | ||
2990 | g_object_unref(G_OBJECT(icon)); | ||
2991 | } | ||
2992 | else { | ||
2993 | gtk_show_about_dialog | ||
2994 | (GTK_WINDOW(fe->window), | ||
2995 | ABOUT_PARAMS, | ||
2996 | (const gchar *)NULL); | ||
2997 | } | ||
2998 | #else | ||
2999 | char titlebuf[256]; | ||
3000 | char textbuf[1024]; | ||
3001 | |||
3002 | sprintf(titlebuf, "About %.200s", thegame.name); | ||
3003 | sprintf(textbuf, | ||
3004 | "%.200s\n\n" | ||
3005 | "from Simon Tatham's Portable Puzzle Collection\n\n" | ||
3006 | "%.500s", thegame.name, ver); | ||
3007 | |||
3008 | message_box(fe->window, titlebuf, textbuf, true, MB_OK); | ||
3009 | #endif | ||
3010 | } | ||
3011 | |||
3012 | static GtkWidget *add_menu_ui_item( | ||
3013 | frontend *fe, GtkContainer *cont, const char *text, int action, | ||
3014 | int accel_key, int accel_keyqual) | ||
3015 | { | ||
3016 | GtkWidget *menuitem = gtk_menu_item_new_with_label(text); | ||
3017 | gtk_container_add(cont, menuitem); | ||
3018 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
3019 | GINT_TO_POINTER(action)); | ||
3020 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3021 | G_CALLBACK(menu_key_event), fe); | ||
3022 | |||
3023 | if (accel_key) { | ||
3024 | /* | ||
3025 | * Display a keyboard accelerator alongside this menu item. | ||
3026 | * Actually this won't be processed via the usual GTK | ||
3027 | * accelerator system, because we add it to a dummy | ||
3028 | * accelerator group which is never actually activated on the | ||
3029 | * main window; this permits back ends to override special | ||
3030 | * keys like 'n' and 'r' and 'u' in some UI states. So | ||
3031 | * whatever keystroke we display here will still go to | ||
3032 | * key_event and be handled in the normal way. | ||
3033 | */ | ||
3034 | gtk_widget_add_accelerator(menuitem, | ||
3035 | "activate", fe->dummy_accelgroup, | ||
3036 | accel_key, accel_keyqual, | ||
3037 | GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED); | ||
3038 | } | ||
3039 | |||
3040 | gtk_widget_show(menuitem); | ||
3041 | return menuitem; | ||
3042 | } | ||
3043 | |||
3044 | static void add_menu_separator(GtkContainer *cont) | ||
3045 | { | ||
3046 | GtkWidget *menuitem = gtk_menu_item_new(); | ||
3047 | gtk_container_add(cont, menuitem); | ||
3048 | gtk_widget_show(menuitem); | ||
3049 | } | ||
3050 | |||
3051 | static void populate_gtk_preset_menu(frontend *fe, struct preset_menu *menu, | ||
3052 | GtkWidget *gtkmenu) | ||
3053 | { | ||
3054 | int i; | ||
3055 | |||
3056 | for (i = 0; i < menu->n_entries; i++) { | ||
3057 | struct preset_menu_entry *entry = &menu->entries[i]; | ||
3058 | GtkWidget *menuitem; | ||
3059 | |||
3060 | if (entry->params) { | ||
3061 | menuitem = gtk_radio_menu_item_new_with_label( | ||
3062 | fe->preset_radio, entry->title); | ||
3063 | fe->preset_radio = gtk_radio_menu_item_get_group( | ||
3064 | GTK_RADIO_MENU_ITEM(menuitem)); | ||
3065 | g_object_set_data(G_OBJECT(menuitem), "user-data", entry); | ||
3066 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3067 | G_CALLBACK(menu_preset_event), fe); | ||
3068 | } else { | ||
3069 | GtkWidget *submenu; | ||
3070 | menuitem = gtk_menu_item_new_with_label(entry->title); | ||
3071 | submenu = gtk_menu_new(); | ||
3072 | gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); | ||
3073 | populate_gtk_preset_menu(fe, entry->submenu, submenu); | ||
3074 | } | ||
3075 | |||
3076 | gtk_container_add(GTK_CONTAINER(gtkmenu), menuitem); | ||
3077 | gtk_widget_show(menuitem); | ||
3078 | } | ||
3079 | } | ||
3080 | |||
3081 | enum { ARG_EITHER, ARG_SAVE, ARG_ID }; /* for argtype */ | ||
3082 | |||
3083 | static frontend *new_window( | ||
3084 | char *arg, int argtype, char **error, bool headless) | ||
3085 | { | ||
3086 | frontend *fe; | ||
3087 | #ifdef USE_PRINTING | ||
3088 | frontend *print_fe = NULL; | ||
3089 | #endif | ||
3090 | GtkBox *vbox, *hbox; | ||
3091 | GtkWidget *menu, *menuitem; | ||
3092 | GList *iconlist; | ||
3093 | int x, y, n; | ||
3094 | char errbuf[1024]; | ||
3095 | extern char *const *const xpm_icons[]; | ||
3096 | extern const int n_xpm_icons; | ||
3097 | struct preset_menu *preset_menu; | ||
3098 | |||
3099 | fe = snew(frontend); | ||
3100 | memset(fe, 0, sizeof(frontend)); | ||
3101 | |||
3102 | #ifndef USE_CAIRO | ||
3103 | if (headless) { | ||
3104 | fprintf(stderr, "headless mode not supported for non-Cairo drawing\n"); | ||
3105 | exit(1); | ||
3106 | } | ||
3107 | #else | ||
3108 | fe->headless = headless; | ||
3109 | fe->ps = 1; /* in headless mode, configure_area won't have set this */ | ||
3110 | #endif | ||
3111 | |||
3112 | fe->timer_active = false; | ||
3113 | fe->timer_id = -1; | ||
3114 | |||
3115 | fe->me = midend_new(fe, &thegame, >k_drawing, fe); | ||
3116 | |||
3117 | fe->dr_api = &internal_drawing; | ||
3118 | |||
3119 | #ifdef USE_PRINTING | ||
3120 | if (thegame.can_print) { | ||
3121 | print_fe = snew(frontend); | ||
3122 | memset(print_fe, 0, sizeof(frontend)); | ||
3123 | |||
3124 | /* Defaults */ | ||
3125 | print_fe->printcount = print_fe->printw = print_fe->printh = 1; | ||
3126 | print_fe->printscale = 100; | ||
3127 | print_fe->printsolns = false; | ||
3128 | print_fe->printcolour = thegame.can_print_in_colour; | ||
3129 | |||
3130 | /* | ||
3131 | * We need to use the same midend as the main frontend because | ||
3132 | * we need midend_print_puzzle() to be able to print the | ||
3133 | * current puzzle. | ||
3134 | */ | ||
3135 | print_fe->me = fe->me; | ||
3136 | |||
3137 | print_fe->print_dr = drawing_new(>k_drawing, print_fe->me, print_fe); | ||
3138 | |||
3139 | print_fe->dr_api = &internal_printing; | ||
3140 | } | ||
3141 | #endif | ||
3142 | |||
3143 | if (arg) { | ||
3144 | const char *err; | ||
3145 | FILE *fp; | ||
3146 | |||
3147 | errbuf[0] = '\0'; | ||
3148 | |||
3149 | switch (argtype) { | ||
3150 | case ARG_ID: | ||
3151 | err = midend_game_id(fe->me, arg); | ||
3152 | if (!err) | ||
3153 | midend_new_game(fe->me); | ||
3154 | else | ||
3155 | sprintf(errbuf, "Invalid game ID: %.800s", err); | ||
3156 | break; | ||
3157 | case ARG_SAVE: | ||
3158 | fp = fopen(arg, "r"); | ||
3159 | if (!fp) { | ||
3160 | sprintf(errbuf, "Error opening file: %.800s", strerror(errno)); | ||
3161 | } else { | ||
3162 | err = midend_deserialise(fe->me, savefile_read, fp); | ||
3163 | if (err) | ||
3164 | sprintf(errbuf, "Invalid save file: %.800s", err); | ||
3165 | fclose(fp); | ||
3166 | } | ||
3167 | break; | ||
3168 | default /*case ARG_EITHER*/: | ||
3169 | /* | ||
3170 | * First try treating the argument as a game ID. | ||
3171 | */ | ||
3172 | err = midend_game_id(fe->me, arg); | ||
3173 | if (!err) { | ||
3174 | /* | ||
3175 | * It's a valid game ID. | ||
3176 | */ | ||
3177 | midend_new_game(fe->me); | ||
3178 | } else { | ||
3179 | FILE *fp = fopen(arg, "r"); | ||
3180 | if (!fp) { | ||
3181 | sprintf(errbuf, "Supplied argument is neither a game ID (%.400s)" | ||
3182 | " nor a save file (%.400s)", err, strerror(errno)); | ||
3183 | } else { | ||
3184 | err = midend_deserialise(fe->me, savefile_read, fp); | ||
3185 | if (err) | ||
3186 | sprintf(errbuf, "%.800s", err); | ||
3187 | fclose(fp); | ||
3188 | } | ||
3189 | } | ||
3190 | break; | ||
3191 | } | ||
3192 | if (*errbuf) { | ||
3193 | *error = dupstr(errbuf); | ||
3194 | midend_free(fe->me); | ||
3195 | sfree(fe); | ||
3196 | #ifdef USE_PRINTING | ||
3197 | if (thegame.can_print) { | ||
3198 | drawing_free(print_fe->print_dr); | ||
3199 | sfree(print_fe); | ||
3200 | } | ||
3201 | #endif | ||
3202 | return NULL; | ||
3203 | } | ||
3204 | |||
3205 | } else { | ||
3206 | midend_new_game(fe->me); | ||
3207 | } | ||
3208 | |||
3209 | if (headless) { | ||
3210 | snaffle_colours(fe); | ||
3211 | get_size(fe, &fe->pw, &fe->ph); | ||
3212 | setup_backing_store(fe); | ||
3213 | return fe; | ||
3214 | } | ||
3215 | |||
3216 | #if !GTK_CHECK_VERSION(3,0,0) | ||
3217 | { | ||
3218 | /* | ||
3219 | * try_shrink_drawing_area() will do some fiddling with the | ||
3220 | * window size request (see comment in that function) after | ||
3221 | * all the bits and pieces such as the menu bar and status bar | ||
3222 | * have appeared in the puzzle window. | ||
3223 | * | ||
3224 | * However, on Unity systems, the menu bar _doesn't_ appear in | ||
3225 | * the puzzle window, because the Unity shell hijacks it into | ||
3226 | * the menu bar at the very top of the screen. We therefore | ||
3227 | * try to detect that situation here, so that we don't sit | ||
3228 | * here forever waiting for a menu bar. | ||
3229 | */ | ||
3230 | const char prop[] = "gtk-shell-shows-menubar"; | ||
3231 | GtkSettings *settings = gtk_settings_get_default(); | ||
3232 | if (!g_object_class_find_property(G_OBJECT_GET_CLASS(settings), | ||
3233 | prop)) { | ||
3234 | fe->menubar_is_local = true; | ||
3235 | } else { | ||
3236 | int unity_mode; | ||
3237 | g_object_get(gtk_settings_get_default(), | ||
3238 | prop, &unity_mode, | ||
3239 | (const gchar *)NULL); | ||
3240 | fe->menubar_is_local = !unity_mode; | ||
3241 | } | ||
3242 | } | ||
3243 | #endif | ||
3244 | |||
3245 | #if GTK_CHECK_VERSION(3,0,0) | ||
3246 | fe->awaiting_resize_ack = false; | ||
3247 | #endif | ||
3248 | |||
3249 | fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); | ||
3250 | gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name); | ||
3251 | |||
3252 | vbox = GTK_BOX(gtk_vbox_new(false, 0)); | ||
3253 | gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox)); | ||
3254 | gtk_widget_show(GTK_WIDGET(vbox)); | ||
3255 | |||
3256 | fe->dummy_accelgroup = gtk_accel_group_new(); | ||
3257 | /* | ||
3258 | * Intentionally _not_ added to the window via | ||
3259 | * gtk_window_add_accel_group; see menu_key_event | ||
3260 | */ | ||
3261 | |||
3262 | hbox = GTK_BOX(gtk_hbox_new(false, 0)); | ||
3263 | gtk_box_pack_start(vbox, GTK_WIDGET(hbox), false, false, 0); | ||
3264 | gtk_widget_show(GTK_WIDGET(hbox)); | ||
3265 | |||
3266 | fe->menubar = gtk_menu_bar_new(); | ||
3267 | gtk_box_pack_start(hbox, fe->menubar, true, true, 0); | ||
3268 | gtk_widget_show(fe->menubar); | ||
3269 | |||
3270 | menuitem = gtk_menu_item_new_with_mnemonic("_Game"); | ||
3271 | gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); | ||
3272 | gtk_widget_show(menuitem); | ||
3273 | |||
3274 | menu = gtk_menu_new(); | ||
3275 | gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu); | ||
3276 | |||
3277 | add_menu_ui_item(fe, GTK_CONTAINER(menu), "New", UI_NEWGAME, 'n', 0); | ||
3278 | |||
3279 | menuitem = gtk_menu_item_new_with_label("Restart"); | ||
3280 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3281 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3282 | G_CALLBACK(menu_restart_event), fe); | ||
3283 | gtk_widget_show(menuitem); | ||
3284 | |||
3285 | menuitem = gtk_menu_item_new_with_label("Specific..."); | ||
3286 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
3287 | GINT_TO_POINTER(CFG_DESC)); | ||
3288 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3289 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3290 | G_CALLBACK(menu_config_event), fe); | ||
3291 | gtk_widget_show(menuitem); | ||
3292 | |||
3293 | menuitem = gtk_menu_item_new_with_label("Random Seed..."); | ||
3294 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
3295 | GINT_TO_POINTER(CFG_SEED)); | ||
3296 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3297 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3298 | G_CALLBACK(menu_config_event), fe); | ||
3299 | gtk_widget_show(menuitem); | ||
3300 | |||
3301 | fe->preset_radio = NULL; | ||
3302 | fe->preset_custom = NULL; | ||
3303 | fe->preset_threaded = false; | ||
3304 | |||
3305 | preset_menu = midend_get_presets(fe->me, NULL); | ||
3306 | if (preset_menu->n_entries > 0 || thegame.can_configure) { | ||
3307 | GtkWidget *submenu; | ||
3308 | |||
3309 | menuitem = gtk_menu_item_new_with_mnemonic("_Type"); | ||
3310 | gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); | ||
3311 | gtk_widget_show(menuitem); | ||
3312 | |||
3313 | submenu = gtk_menu_new(); | ||
3314 | gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); | ||
3315 | |||
3316 | populate_gtk_preset_menu(fe, preset_menu, submenu); | ||
3317 | |||
3318 | if (thegame.can_configure) { | ||
3319 | menuitem = fe->preset_custom = | ||
3320 | gtk_radio_menu_item_new_with_label(fe->preset_radio, | ||
3321 | "Custom..."); | ||
3322 | fe->preset_radio = | ||
3323 | gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); | ||
3324 | gtk_container_add(GTK_CONTAINER(submenu), menuitem); | ||
3325 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
3326 | GINT_TO_POINTER(CFG_SETTINGS)); | ||
3327 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3328 | G_CALLBACK(menu_config_event), fe); | ||
3329 | gtk_widget_show(menuitem); | ||
3330 | } | ||
3331 | |||
3332 | } | ||
3333 | |||
3334 | add_menu_separator(GTK_CONTAINER(menu)); | ||
3335 | menuitem = gtk_menu_item_new_with_label("Load..."); | ||
3336 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3337 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3338 | G_CALLBACK(menu_load_event), fe); | ||
3339 | gtk_widget_show(menuitem); | ||
3340 | menuitem = gtk_menu_item_new_with_label("Save..."); | ||
3341 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3342 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3343 | G_CALLBACK(menu_save_event), fe); | ||
3344 | gtk_widget_show(menuitem); | ||
3345 | #ifdef USE_PRINTING | ||
3346 | if (thegame.can_print) { | ||
3347 | add_menu_separator(GTK_CONTAINER(menu)); | ||
3348 | menuitem = gtk_menu_item_new_with_label("Print..."); | ||
3349 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3350 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3351 | G_CALLBACK(menu_print_event), print_fe); | ||
3352 | gtk_widget_show(menuitem); | ||
3353 | } | ||
3354 | #endif | ||
3355 | #ifndef STYLUS_BASED | ||
3356 | add_menu_separator(GTK_CONTAINER(menu)); | ||
3357 | add_menu_ui_item(fe, GTK_CONTAINER(menu), "Undo", UI_UNDO, 'u', 0); | ||
3358 | add_menu_ui_item(fe, GTK_CONTAINER(menu), "Redo", UI_REDO, 'r', 0); | ||
3359 | #endif | ||
3360 | if (thegame.can_format_as_text_ever) { | ||
3361 | add_menu_separator(GTK_CONTAINER(menu)); | ||
3362 | menuitem = gtk_menu_item_new_with_label("Copy"); | ||
3363 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3364 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3365 | G_CALLBACK(menu_copy_event), fe); | ||
3366 | gtk_widget_show(menuitem); | ||
3367 | fe->copy_menu_item = menuitem; | ||
3368 | } else { | ||
3369 | fe->copy_menu_item = NULL; | ||
3370 | } | ||
3371 | if (thegame.can_solve) { | ||
3372 | add_menu_separator(GTK_CONTAINER(menu)); | ||
3373 | menuitem = gtk_menu_item_new_with_label("Solve"); | ||
3374 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3375 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3376 | G_CALLBACK(menu_solve_event), fe); | ||
3377 | gtk_widget_show(menuitem); | ||
3378 | } | ||
3379 | add_menu_separator(GTK_CONTAINER(menu)); | ||
3380 | add_menu_ui_item(fe, GTK_CONTAINER(menu), "Exit", UI_QUIT, 'q', 0); | ||
3381 | |||
3382 | menuitem = gtk_menu_item_new_with_mnemonic("_Help"); | ||
3383 | gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); | ||
3384 | gtk_widget_show(menuitem); | ||
3385 | |||
3386 | menu = gtk_menu_new(); | ||
3387 | gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu); | ||
3388 | |||
3389 | menuitem = gtk_menu_item_new_with_label("About"); | ||
3390 | gtk_container_add(GTK_CONTAINER(menu), menuitem); | ||
3391 | g_signal_connect(G_OBJECT(menuitem), "activate", | ||
3392 | G_CALLBACK(menu_about_event), fe); | ||
3393 | gtk_widget_show(menuitem); | ||
3394 | |||
3395 | #ifdef STYLUS_BASED | ||
3396 | menuitem=gtk_button_new_with_mnemonic("_Redo"); | ||
3397 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
3398 | GINT_TO_POINTER(UI_REDO)); | ||
3399 | g_signal_connect(G_OBJECT(menuitem), "clicked", | ||
3400 | G_CALLBACK(menu_key_event), fe); | ||
3401 | gtk_box_pack_end(hbox, menuitem, false, false, 0); | ||
3402 | gtk_widget_show(menuitem); | ||
3403 | |||
3404 | menuitem=gtk_button_new_with_mnemonic("_Undo"); | ||
3405 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
3406 | GINT_TO_POINTER(UI_UNDO)); | ||
3407 | g_signal_connect(G_OBJECT(menuitem), "clicked", | ||
3408 | G_CALLBACK(menu_key_event), fe); | ||
3409 | gtk_box_pack_end(hbox, menuitem, false, false, 0); | ||
3410 | gtk_widget_show(menuitem); | ||
3411 | |||
3412 | if (thegame.flags & REQUIRE_NUMPAD) { | ||
3413 | hbox = GTK_BOX(gtk_hbox_new(false, 0)); | ||
3414 | gtk_box_pack_start(vbox, GTK_WIDGET(hbox), false, false, 0); | ||
3415 | gtk_widget_show(GTK_WIDGET(hbox)); | ||
3416 | |||
3417 | *((int*)errbuf)=0; | ||
3418 | errbuf[1]='\0'; | ||
3419 | for(errbuf[0]='0';errbuf[0]<='9';errbuf[0]++) { | ||
3420 | menuitem=gtk_button_new_with_label(errbuf); | ||
3421 | g_object_set_data(G_OBJECT(menuitem), "user-data", | ||
3422 | GINT_TO_POINTER((int)(errbuf[0]))); | ||
3423 | g_signal_connect(G_OBJECT(menuitem), "clicked", | ||
3424 | G_CALLBACK(menu_key_event), fe); | ||
3425 | gtk_box_pack_start(hbox, menuitem, true, true, 0); | ||
3426 | gtk_widget_show(menuitem); | ||
3427 | } | ||
3428 | } | ||
3429 | #endif /* STYLUS_BASED */ | ||
3430 | |||
3431 | changed_preset(fe); | ||
3432 | |||
3433 | snaffle_colours(fe); | ||
3434 | |||
3435 | if (midend_wants_statusbar(fe->me)) { | ||
3436 | GtkWidget *viewport; | ||
3437 | GtkRequisition req; | ||
3438 | |||
3439 | viewport = gtk_viewport_new(NULL, NULL); | ||
3440 | gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE); | ||
3441 | fe->statusbar = gtk_statusbar_new(); | ||
3442 | gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar); | ||
3443 | gtk_widget_show(viewport); | ||
3444 | gtk_box_pack_end(vbox, viewport, false, false, 0); | ||
3445 | gtk_widget_show(fe->statusbar); | ||
3446 | fe->statusctx = gtk_statusbar_get_context_id | ||
3447 | (GTK_STATUSBAR(fe->statusbar), "game"); | ||
3448 | gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, | ||
3449 | DEFAULT_STATUSBAR_TEXT); | ||
3450 | #if GTK_CHECK_VERSION(3,0,0) | ||
3451 | gtk_widget_get_preferred_size(fe->statusbar, &req, NULL); | ||
3452 | #else | ||
3453 | gtk_widget_size_request(fe->statusbar, &req); | ||
3454 | #endif | ||
3455 | gtk_widget_set_size_request(viewport, -1, req.height); | ||
3456 | } else | ||
3457 | fe->statusbar = NULL; | ||
3458 | |||
3459 | fe->area = gtk_drawing_area_new(); | ||
3460 | #if GTK_CHECK_VERSION(2,0,0) && !GTK_CHECK_VERSION(3,0,0) | ||
3461 | gtk_widget_set_double_buffered(fe->area, false); | ||
3462 | #endif | ||
3463 | { | ||
3464 | GdkGeometry geom; | ||
3465 | geom.base_width = 0; | ||
3466 | #if GTK_CHECK_VERSION(3,0,0) | ||
3467 | geom.base_height = window_extra_height(fe); | ||
3468 | gtk_window_set_geometry_hints(GTK_WINDOW(fe->window), NULL, | ||
3469 | &geom, GDK_HINT_BASE_SIZE); | ||
3470 | #else | ||
3471 | geom.base_height = 0; | ||
3472 | gtk_window_set_geometry_hints(GTK_WINDOW(fe->window), fe->area, | ||
3473 | &geom, GDK_HINT_BASE_SIZE); | ||
3474 | #endif | ||
3475 | } | ||
3476 | fe->w = -1; | ||
3477 | fe->h = -1; | ||
3478 | get_size(fe, &x, &y); | ||
3479 | #if GTK_CHECK_VERSION(3,0,0) | ||
3480 | gtk_window_set_default_size(GTK_WINDOW(fe->window), | ||
3481 | x, y + window_extra_height(fe)); | ||
3482 | #else | ||
3483 | fe->drawing_area_shrink_pending = false; | ||
3484 | gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y); | ||
3485 | #endif | ||
3486 | |||
3487 | gtk_box_pack_end(vbox, fe->area, true, true, 0); | ||
3488 | |||
3489 | clear_backing_store(fe); | ||
3490 | fe->fonts = NULL; | ||
3491 | fe->nfonts = fe->fontsize = 0; | ||
3492 | |||
3493 | fe->paste_data = NULL; | ||
3494 | fe->paste_data_len = 0; | ||
3495 | |||
3496 | g_signal_connect(G_OBJECT(fe->window), "destroy", | ||
3497 | G_CALLBACK(destroy), fe); | ||
3498 | g_signal_connect(G_OBJECT(fe->window), "key_press_event", | ||
3499 | G_CALLBACK(key_event), fe); | ||
3500 | g_signal_connect(G_OBJECT(fe->area), "button_press_event", | ||
3501 | G_CALLBACK(button_event), fe); | ||
3502 | g_signal_connect(G_OBJECT(fe->area), "button_release_event", | ||
3503 | G_CALLBACK(button_event), fe); | ||
3504 | g_signal_connect(G_OBJECT(fe->area), "motion_notify_event", | ||
3505 | G_CALLBACK(motion_event), fe); | ||
3506 | g_signal_connect(G_OBJECT(fe->area), "selection_get", | ||
3507 | G_CALLBACK(selection_get), fe); | ||
3508 | g_signal_connect(G_OBJECT(fe->area), "selection_clear_event", | ||
3509 | G_CALLBACK(selection_clear), fe); | ||
3510 | #if GTK_CHECK_VERSION(3,0,0) | ||
3511 | g_signal_connect(G_OBJECT(fe->area), "draw", | ||
3512 | G_CALLBACK(draw_area), fe); | ||
3513 | #else | ||
3514 | g_signal_connect(G_OBJECT(fe->area), "expose_event", | ||
3515 | G_CALLBACK(expose_area), fe); | ||
3516 | #endif | ||
3517 | g_signal_connect(G_OBJECT(fe->window), "map_event", | ||
3518 | G_CALLBACK(map_window), fe); | ||
3519 | g_signal_connect(G_OBJECT(fe->area), "configure_event", | ||
3520 | G_CALLBACK(configure_area), fe); | ||
3521 | g_signal_connect(G_OBJECT(fe->window), "configure_event", | ||
3522 | G_CALLBACK(configure_window), fe); | ||
3523 | #if GTK_CHECK_VERSION(3,0,0) | ||
3524 | g_signal_connect(G_OBJECT(fe->window), "size_allocate", | ||
3525 | G_CALLBACK(window_size_alloc), fe); | ||
3526 | #endif | ||
3527 | |||
3528 | gtk_widget_add_events(GTK_WIDGET(fe->area), | ||
3529 | GDK_BUTTON_PRESS_MASK | | ||
3530 | GDK_BUTTON_RELEASE_MASK | | ||
3531 | GDK_BUTTON_MOTION_MASK | | ||
3532 | GDK_POINTER_MOTION_HINT_MASK); | ||
3533 | |||
3534 | if (n_xpm_icons) { | ||
3535 | gtk_window_set_icon(GTK_WINDOW(fe->window), | ||
3536 | gdk_pixbuf_new_from_xpm_data | ||
3537 | ((const gchar **)xpm_icons[0])); | ||
3538 | |||
3539 | iconlist = NULL; | ||
3540 | for (n = 0; n < n_xpm_icons; n++) { | ||
3541 | iconlist = | ||
3542 | g_list_append(iconlist, | ||
3543 | gdk_pixbuf_new_from_xpm_data((const gchar **) | ||
3544 | xpm_icons[n])); | ||
3545 | } | ||
3546 | gtk_window_set_icon_list(GTK_WINDOW(fe->window), iconlist); | ||
3547 | } | ||
3548 | |||
3549 | gtk_widget_show(fe->area); | ||
3550 | gtk_widget_show(fe->window); | ||
3551 | |||
3552 | #if !GTK_CHECK_VERSION(3,0,0) | ||
3553 | fe->drawing_area_shrink_pending = true; | ||
3554 | try_shrink_drawing_area(fe); | ||
3555 | #endif | ||
3556 | |||
3557 | set_window_background(fe, 0); | ||
3558 | |||
3559 | return fe; | ||
3560 | } | ||
3561 | |||
3562 | static void list_presets_from_menu(struct preset_menu *menu) | ||
3563 | { | ||
3564 | int i; | ||
3565 | |||
3566 | for (i = 0; i < menu->n_entries; i++) { | ||
3567 | if (menu->entries[i].params) { | ||
3568 | char *paramstr = thegame.encode_params( | ||
3569 | menu->entries[i].params, true); | ||
3570 | printf("%s %s\n", paramstr, menu->entries[i].title); | ||
3571 | sfree(paramstr); | ||
3572 | } else { | ||
3573 | list_presets_from_menu(menu->entries[i].submenu); | ||
3574 | } | ||
3575 | } | ||
3576 | } | ||
3577 | |||
3578 | int main(int argc, char **argv) | ||
3579 | { | ||
3580 | char *pname = argv[0]; | ||
3581 | char *error; | ||
3582 | int ngenerate = 0, px = 1, py = 1; | ||
3583 | bool print = false; | ||
3584 | bool time_generation = false, test_solve = false, list_presets = false; | ||
3585 | bool soln = false, colour = false; | ||
3586 | float scale = 1.0F; | ||
3587 | float redo_proportion = 0.0F; | ||
3588 | const char *savefile = NULL, *savesuffix = NULL; | ||
3589 | char *arg = NULL; | ||
3590 | int argtype = ARG_EITHER; | ||
3591 | char *screenshot_file = NULL; | ||
3592 | bool doing_opts = true; | ||
3593 | int ac = argc; | ||
3594 | char **av = argv; | ||
3595 | char errbuf[500]; | ||
3596 | |||
3597 | /* | ||
3598 | * Command line parsing in this function is rather fiddly, | ||
3599 | * because GTK wants to have a go at argc/argv _first_ - and | ||
3600 | * yet we can't let it, because gtk_init() will bomb out if it | ||
3601 | * can't open an X display, whereas in fact we want to permit | ||
3602 | * our --generate and --print modes to run without an X | ||
3603 | * display. | ||
3604 | * | ||
3605 | * So what we do is: | ||
3606 | * - we parse the command line ourselves, without modifying | ||
3607 | * argc/argv | ||
3608 | * - if we encounter an error which might plausibly be the | ||
3609 | * result of a GTK command line (i.e. not detailed errors in | ||
3610 | * particular options of ours) we store the error message | ||
3611 | * and terminate parsing. | ||
3612 | * - if we got enough out of the command line to know it | ||
3613 | * specifies a non-X mode of operation, we either display | ||
3614 | * the stored error and return failure, or if there is no | ||
3615 | * stored error we do the non-X operation and return | ||
3616 | * success. | ||
3617 | * - otherwise, we go straight to gtk_init(). | ||
3618 | */ | ||
3619 | |||
3620 | errbuf[0] = '\0'; | ||
3621 | while (--ac > 0) { | ||
3622 | char *p = *++av; | ||
3623 | if (doing_opts && !strcmp(p, "--version")) { | ||
3624 | printf("%s, from Simon Tatham's Portable Puzzle Collection\n%s\n", | ||
3625 | thegame.name, ver); | ||
3626 | return 0; | ||
3627 | } else if (doing_opts && !strcmp(p, "--generate")) { | ||
3628 | if (--ac > 0) { | ||
3629 | ngenerate = atoi(*++av); | ||
3630 | if (!ngenerate) { | ||
3631 | fprintf(stderr, "%s: '--generate' expected a number\n", | ||
3632 | pname); | ||
3633 | return 1; | ||
3634 | } | ||
3635 | } else | ||
3636 | ngenerate = 1; | ||
3637 | } else if (doing_opts && !strcmp(p, "--time-generation")) { | ||
3638 | time_generation = true; | ||
3639 | } else if (doing_opts && !strcmp(p, "--test-solve")) { | ||
3640 | test_solve = true; | ||
3641 | } else if (doing_opts && !strcmp(p, "--list-presets")) { | ||
3642 | list_presets = true; | ||
3643 | } else if (doing_opts && !strcmp(p, "--save")) { | ||
3644 | if (--ac > 0) { | ||
3645 | savefile = *++av; | ||
3646 | } else { | ||
3647 | fprintf(stderr, "%s: '--save' expected a filename\n", | ||
3648 | pname); | ||
3649 | return 1; | ||
3650 | } | ||
3651 | } else if (doing_opts && (!strcmp(p, "--save-suffix") || | ||
3652 | !strcmp(p, "--savesuffix"))) { | ||
3653 | if (--ac > 0) { | ||
3654 | savesuffix = *++av; | ||
3655 | } else { | ||
3656 | fprintf(stderr, "%s: '--save-suffix' expected a filename\n", | ||
3657 | pname); | ||
3658 | return 1; | ||
3659 | } | ||
3660 | } else if (doing_opts && !strcmp(p, "--print")) { | ||
3661 | if (!thegame.can_print) { | ||
3662 | fprintf(stderr, "%s: this game does not support printing\n", | ||
3663 | pname); | ||
3664 | return 1; | ||
3665 | } | ||
3666 | print = true; | ||
3667 | if (--ac > 0) { | ||
3668 | char *dim = *++av; | ||
3669 | if (sscanf(dim, "%dx%d", &px, &py) != 2) { | ||
3670 | fprintf(stderr, "%s: unable to parse argument '%s' to " | ||
3671 | "'--print'\n", pname, dim); | ||
3672 | return 1; | ||
3673 | } | ||
3674 | } else { | ||
3675 | px = py = 1; | ||
3676 | } | ||
3677 | } else if (doing_opts && !strcmp(p, "--scale")) { | ||
3678 | if (--ac > 0) { | ||
3679 | scale = atof(*++av); | ||
3680 | } else { | ||
3681 | fprintf(stderr, "%s: no argument supplied to '--scale'\n", | ||
3682 | pname); | ||
3683 | return 1; | ||
3684 | } | ||
3685 | } else if (doing_opts && !strcmp(p, "--redo")) { | ||
3686 | /* | ||
3687 | * This is an internal option which I don't expect | ||
3688 | * users to have any particular use for. The effect of | ||
3689 | * --redo is that once the game has been loaded and | ||
3690 | * initialised, the next move in the redo chain is | ||
3691 | * replayed, and the game screen is redrawn part way | ||
3692 | * through the making of the move. This is only | ||
3693 | * meaningful if there _is_ a next move in the redo | ||
3694 | * chain, which means in turn that this option is only | ||
3695 | * useful if you're also passing a save file on the | ||
3696 | * command line. | ||
3697 | * | ||
3698 | * This option is used by the script which generates | ||
3699 | * the puzzle icons and website screenshots, and I | ||
3700 | * don't imagine it's useful for anything else. | ||
3701 | * (Unless, I suppose, users don't like my screenshots | ||
3702 | * and want to generate their own in the same way for | ||
3703 | * some repackaged version of the puzzles.) | ||
3704 | */ | ||
3705 | if (--ac > 0) { | ||
3706 | redo_proportion = atof(*++av); | ||
3707 | } else { | ||
3708 | fprintf(stderr, "%s: no argument supplied to '--redo'\n", | ||
3709 | pname); | ||
3710 | return 1; | ||
3711 | } | ||
3712 | } else if (doing_opts && !strcmp(p, "--screenshot")) { | ||
3713 | /* | ||
3714 | * Another internal option for the icon building | ||
3715 | * script. This causes a screenshot of the central | ||
3716 | * drawing area (i.e. not including the menu bar or | ||
3717 | * status bar) to be saved to a PNG file once the | ||
3718 | * window has been drawn, and then the application | ||
3719 | * quits immediately. | ||
3720 | */ | ||
3721 | if (--ac > 0) { | ||
3722 | screenshot_file = *++av; | ||
3723 | } else { | ||
3724 | fprintf(stderr, "%s: no argument supplied to '--screenshot'\n", | ||
3725 | pname); | ||
3726 | return 1; | ||
3727 | } | ||
3728 | } else if (doing_opts && (!strcmp(p, "--with-solutions") || | ||
3729 | !strcmp(p, "--with-solution") || | ||
3730 | !strcmp(p, "--with-solns") || | ||
3731 | !strcmp(p, "--with-soln") || | ||
3732 | !strcmp(p, "--solutions") || | ||
3733 | !strcmp(p, "--solution") || | ||
3734 | !strcmp(p, "--solns") || | ||
3735 | !strcmp(p, "--soln"))) { | ||
3736 | soln = true; | ||
3737 | } else if (doing_opts && !strcmp(p, "--colour")) { | ||
3738 | if (!thegame.can_print_in_colour) { | ||
3739 | fprintf(stderr, "%s: this game does not support colour" | ||
3740 | " printing\n", pname); | ||
3741 | return 1; | ||
3742 | } | ||
3743 | colour = true; | ||
3744 | } else if (doing_opts && !strcmp(p, "--load")) { | ||
3745 | argtype = ARG_SAVE; | ||
3746 | } else if (doing_opts && !strcmp(p, "--game")) { | ||
3747 | argtype = ARG_ID; | ||
3748 | } else if (doing_opts && !strcmp(p, "--")) { | ||
3749 | doing_opts = false; | ||
3750 | } else if (!doing_opts || p[0] != '-') { | ||
3751 | if (arg) { | ||
3752 | fprintf(stderr, "%s: more than one argument supplied\n", | ||
3753 | pname); | ||
3754 | return 1; | ||
3755 | } | ||
3756 | arg = p; | ||
3757 | } else { | ||
3758 | sprintf(errbuf, "%.100s: unrecognised option '%.100s'\n", | ||
3759 | pname, p); | ||
3760 | break; | ||
3761 | } | ||
3762 | } | ||
3763 | |||
3764 | /* | ||
3765 | * Special standalone mode for generating puzzle IDs on the | ||
3766 | * command line. Useful for generating puzzles to be printed | ||
3767 | * out and solved offline (for puzzles where that even makes | ||
3768 | * sense - Solo, for example, is a lot more pencil-and-paper | ||
3769 | * friendly than Twiddle!) | ||
3770 | * | ||
3771 | * Usage: | ||
3772 | * | ||
3773 | * <puzzle-name> --generate [<n> [<params>]] | ||
3774 | * | ||
3775 | * <n>, if present, is the number of puzzle IDs to generate. | ||
3776 | * <params>, if present, is the same type of parameter string | ||
3777 | * you would pass to the puzzle when running it in GUI mode, | ||
3778 | * including optional extras such as the expansion factor in | ||
3779 | * Rectangles and the difficulty level in Solo. | ||
3780 | * | ||
3781 | * If you specify <params>, you must also specify <n> (although | ||
3782 | * you may specify it to be 1). Sorry; that was the | ||
3783 | * simplest-to-parse command-line syntax I came up with. | ||
3784 | */ | ||
3785 | if (ngenerate > 0 || print || savefile || savesuffix) { | ||
3786 | int i, n = 1; | ||
3787 | midend *me; | ||
3788 | char *id; | ||
3789 | document *doc = NULL; | ||
3790 | |||
3791 | /* | ||
3792 | * If we're in this branch, we should display any pending | ||
3793 | * error message from the command line, since GTK isn't going | ||
3794 | * to take another crack at making sense of it. | ||
3795 | */ | ||
3796 | if (*errbuf) { | ||
3797 | fputs(errbuf, stderr); | ||
3798 | return 1; | ||
3799 | } | ||
3800 | |||
3801 | n = ngenerate; | ||
3802 | |||
3803 | me = midend_new(NULL, &thegame, NULL, NULL); | ||
3804 | i = 0; | ||
3805 | |||
3806 | if (savefile && !savesuffix) | ||
3807 | savesuffix = ""; | ||
3808 | if (!savefile && savesuffix) | ||
3809 | savefile = ""; | ||
3810 | |||
3811 | if (print) | ||
3812 | doc = document_new(px, py, scale); | ||
3813 | |||
3814 | /* | ||
3815 | * In this loop, we either generate a game ID or read one | ||
3816 | * from stdin depending on whether we're in generate mode; | ||
3817 | * then we either write it to stdout or print it, depending | ||
3818 | * on whether we're in print mode. Thus, this loop handles | ||
3819 | * generate-to-stdout, print-from-stdin and generate-and- | ||
3820 | * immediately-print modes. | ||
3821 | * | ||
3822 | * (It could also handle a copy-stdin-to-stdout mode, | ||
3823 | * although there's currently no combination of options | ||
3824 | * which will cause this loop to be activated in that mode. | ||
3825 | * It wouldn't be _entirely_ pointless, though, because | ||
3826 | * stdin could contain bare params strings or random-seed | ||
3827 | * IDs, and stdout would contain nothing but fully | ||
3828 | * generated descriptive game IDs.) | ||
3829 | */ | ||
3830 | while (ngenerate == 0 || i < n) { | ||
3831 | char *pstr, *seed; | ||
3832 | const char *err; | ||
3833 | struct rusage before, after; | ||
3834 | |||
3835 | if (ngenerate == 0) { | ||
3836 | pstr = fgetline(stdin); | ||
3837 | if (!pstr) | ||
3838 | break; | ||
3839 | pstr[strcspn(pstr, "\r\n")] = '\0'; | ||
3840 | } else { | ||
3841 | if (arg) { | ||
3842 | pstr = snewn(strlen(arg) + 40, char); | ||
3843 | |||
3844 | strcpy(pstr, arg); | ||
3845 | if (i > 0 && strchr(arg, '#')) | ||
3846 | sprintf(pstr + strlen(pstr), "-%d", i); | ||
3847 | } else | ||
3848 | pstr = NULL; | ||
3849 | } | ||
3850 | |||
3851 | if (pstr) { | ||
3852 | err = midend_game_id(me, pstr); | ||
3853 | if (err) { | ||
3854 | fprintf(stderr, "%s: error parsing '%s': %s\n", | ||
3855 | pname, pstr, err); | ||
3856 | return 1; | ||
3857 | } | ||
3858 | } | ||
3859 | |||
3860 | if (time_generation) | ||
3861 | getrusage(RUSAGE_SELF, &before); | ||
3862 | |||
3863 | midend_new_game(me); | ||
3864 | |||
3865 | seed = midend_get_random_seed(me); | ||
3866 | |||
3867 | if (time_generation) { | ||
3868 | double elapsed; | ||
3869 | |||
3870 | getrusage(RUSAGE_SELF, &after); | ||
3871 | |||
3872 | elapsed = (after.ru_utime.tv_sec - | ||
3873 | before.ru_utime.tv_sec); | ||
3874 | elapsed += (after.ru_utime.tv_usec - | ||
3875 | before.ru_utime.tv_usec) / 1000000.0; | ||
3876 | |||
3877 | printf("%s %s: %.6f\n", thegame.name, seed, elapsed); | ||
3878 | } | ||
3879 | |||
3880 | if (test_solve && thegame.can_solve) { | ||
3881 | /* | ||
3882 | * Now destroy the aux_info in the midend, by means of | ||
3883 | * re-entering the same game id, and then try to solve | ||
3884 | * it. | ||
3885 | */ | ||
3886 | char *game_id; | ||
3887 | |||
3888 | game_id = midend_get_game_id(me); | ||
3889 | err = midend_game_id(me, game_id); | ||
3890 | if (err) { | ||
3891 | fprintf(stderr, "%s %s: game id re-entry error: %s\n", | ||
3892 | thegame.name, seed, err); | ||
3893 | return 1; | ||
3894 | } | ||
3895 | midend_new_game(me); | ||
3896 | sfree(game_id); | ||
3897 | |||
3898 | err = midend_solve(me); | ||
3899 | /* | ||
3900 | * If the solve operation returned the error "Solution | ||
3901 | * not known for this puzzle", that's OK, because that | ||
3902 | * just means it's a puzzle for which we don't have an | ||
3903 | * algorithmic solver and hence can't solve it without | ||
3904 | * the aux_info, e.g. Netslide. Any other error is a | ||
3905 | * problem, though. | ||
3906 | */ | ||
3907 | if (err && strcmp(err, "Solution not known for this puzzle")) { | ||
3908 | fprintf(stderr, "%s %s: solve error: %s\n", | ||
3909 | thegame.name, seed, err); | ||
3910 | return 1; | ||
3911 | } | ||
3912 | } | ||
3913 | |||
3914 | sfree(pstr); | ||
3915 | sfree(seed); | ||
3916 | |||
3917 | if (doc) { | ||
3918 | err = midend_print_puzzle(me, doc, soln); | ||
3919 | if (err) { | ||
3920 | fprintf(stderr, "%s: error in printing: %s\n", pname, err); | ||
3921 | return 1; | ||
3922 | } | ||
3923 | } | ||
3924 | if (savefile) { | ||
3925 | struct savefile_write_ctx ctx; | ||
3926 | char *realname = snewn(40 + strlen(savefile) + | ||
3927 | strlen(savesuffix), char); | ||
3928 | sprintf(realname, "%s%d%s", savefile, i, savesuffix); | ||
3929 | |||
3930 | if (soln) { | ||
3931 | const char *err = midend_solve(me); | ||
3932 | if (err) { | ||
3933 | fprintf(stderr, "%s: unable to show solution: %s\n", | ||
3934 | realname, err); | ||
3935 | return 1; | ||
3936 | } | ||
3937 | } | ||
3938 | |||
3939 | ctx.fp = fopen(realname, "w"); | ||
3940 | if (!ctx.fp) { | ||
3941 | fprintf(stderr, "%s: open: %s\n", realname, | ||
3942 | strerror(errno)); | ||
3943 | return 1; | ||
3944 | } | ||
3945 | ctx.error = 0; | ||
3946 | midend_serialise(me, savefile_write, &ctx); | ||
3947 | if (ctx.error) { | ||
3948 | fprintf(stderr, "%s: write: %s\n", realname, | ||
3949 | strerror(ctx.error)); | ||
3950 | return 1; | ||
3951 | } | ||
3952 | if (fclose(ctx.fp)) { | ||
3953 | fprintf(stderr, "%s: close: %s\n", realname, | ||
3954 | strerror(errno)); | ||
3955 | return 1; | ||
3956 | } | ||
3957 | sfree(realname); | ||
3958 | } | ||
3959 | if (!doc && !savefile && !time_generation) { | ||
3960 | id = midend_get_game_id(me); | ||
3961 | puts(id); | ||
3962 | sfree(id); | ||
3963 | } | ||
3964 | |||
3965 | i++; | ||
3966 | } | ||
3967 | |||
3968 | if (doc) { | ||
3969 | psdata *ps = ps_init(stdout, colour); | ||
3970 | document_print(doc, ps_drawing_api(ps)); | ||
3971 | document_free(doc); | ||
3972 | ps_free(ps); | ||
3973 | } | ||
3974 | |||
3975 | midend_free(me); | ||
3976 | |||
3977 | return 0; | ||
3978 | } else if (list_presets) { | ||
3979 | /* | ||
3980 | * Another specialist mode which causes the puzzle to list the | ||
3981 | * game_params strings for all its preset configurations. | ||
3982 | */ | ||
3983 | midend *me; | ||
3984 | struct preset_menu *menu; | ||
3985 | |||
3986 | me = midend_new(NULL, &thegame, NULL, NULL); | ||
3987 | menu = midend_get_presets(me, NULL); | ||
3988 | list_presets_from_menu(menu); | ||
3989 | midend_free(me); | ||
3990 | return 0; | ||
3991 | } else { | ||
3992 | frontend *fe; | ||
3993 | bool headless = screenshot_file != NULL; | ||
3994 | |||
3995 | if (!headless) | ||
3996 | gtk_init(&argc, &argv); | ||
3997 | |||
3998 | fe = new_window(arg, argtype, &error, headless); | ||
3999 | |||
4000 | if (!fe) { | ||
4001 | fprintf(stderr, "%s: %s\n", pname, error); | ||
4002 | return 1; | ||
4003 | } | ||
4004 | |||
4005 | if (screenshot_file) { | ||
4006 | /* | ||
4007 | * Some puzzles will not redraw their entire area if | ||
4008 | * given a partially completed animation, which means | ||
4009 | * we must redraw now and _then_ redraw again after | ||
4010 | * freezing the move timer. | ||
4011 | */ | ||
4012 | midend_force_redraw(fe->me); | ||
4013 | } | ||
4014 | |||
4015 | if (redo_proportion) { | ||
4016 | /* Start a redo. */ | ||
4017 | midend_process_key(fe->me, 0, 0, 'r'); | ||
4018 | /* And freeze the timer at the specified position. */ | ||
4019 | midend_freeze_timer(fe->me, redo_proportion); | ||
4020 | } | ||
4021 | |||
4022 | if (screenshot_file) { | ||
4023 | save_screenshot_png(fe, screenshot_file); | ||
4024 | exit(0); | ||
4025 | } | ||
4026 | |||
4027 | gtk_main(); | ||
4028 | } | ||
4029 | |||
4030 | return 0; | ||
4031 | } | ||