Add debugging support.
[sgt/puzzles] / gtk.c
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
12 #include <sys/time.h>
13
14 #include <gtk/gtk.h>
15 #include <gdk/gdkkeysyms.h>
16
17 #include <gdk/gdkx.h>
18 #include <X11/Xlib.h>
19 #include <X11/Xutil.h>
20 #include <X11/Xatom.h>
21
22 #include "puzzles.h"
23
24 #if GTK_CHECK_VERSION(2,0,0)
25 #define USE_PANGO
26 #endif
27
28 #ifdef DEBUGGING
29 static FILE *debug_fp = NULL;
30
31 void dputs(char *buf)
32 {
33 if (!debug_fp) {
34 debug_fp = fopen("debug.log", "w");
35 }
36
37 fputs(buf, stderr);
38
39 if (debug_fp) {
40 fputs(buf, debug_fp);
41 fflush(debug_fp);
42 }
43 }
44
45 void debug_printf(char *fmt, ...)
46 {
47 char buf[4096];
48 va_list ap;
49
50 va_start(ap, fmt);
51 vsprintf(buf, fmt, ap);
52 dputs(buf);
53 va_end(ap);
54 }
55 #endif
56
57 /* ----------------------------------------------------------------------
58 * Error reporting functions used elsewhere.
59 */
60
61 void fatal(char *fmt, ...)
62 {
63 va_list ap;
64
65 fprintf(stderr, "fatal error: ");
66
67 va_start(ap, fmt);
68 vfprintf(stderr, fmt, ap);
69 va_end(ap);
70
71 fprintf(stderr, "\n");
72 exit(1);
73 }
74
75 /* ----------------------------------------------------------------------
76 * GTK front end to puzzles.
77 */
78
79 struct font {
80 #ifdef USE_PANGO
81 PangoFontDescription *desc;
82 #else
83 GdkFont *font;
84 #endif
85 int type;
86 int size;
87 };
88
89 /*
90 * This structure holds all the data relevant to a single window.
91 * In principle this would allow us to open multiple independent
92 * puzzle windows, although I can't currently see any real point in
93 * doing so. I'm just coding cleanly because there's no
94 * particularly good reason not to.
95 */
96 struct frontend {
97 GtkWidget *window;
98 GtkWidget *area;
99 GtkWidget *statusbar;
100 guint statusctx;
101 GdkPixmap *pixmap;
102 GdkColor *colours;
103 int ncolours;
104 GdkColormap *colmap;
105 int w, h;
106 midend_data *me;
107 GdkGC *gc;
108 int bbox_l, bbox_r, bbox_u, bbox_d;
109 int timer_active, timer_id;
110 struct timeval last_time;
111 struct font *fonts;
112 int nfonts, fontsize;
113 config_item *cfg;
114 int cfg_which, cfgret;
115 GtkWidget *cfgbox;
116 void *paste_data;
117 int paste_data_len;
118 char *laststatus;
119 int pw, ph; /* pixmap size (w, h are area size) */
120 int ox, oy; /* offset of pixmap in drawing area */
121 };
122
123 void get_random_seed(void **randseed, int *randseedsize)
124 {
125 struct timeval *tvp = snew(struct timeval);
126 gettimeofday(tvp, NULL);
127 *randseed = (void *)tvp;
128 *randseedsize = sizeof(struct timeval);
129 }
130
131 void frontend_default_colour(frontend *fe, float *output)
132 {
133 GdkColor col = fe->window->style->bg[GTK_STATE_NORMAL];
134 output[0] = col.red / 65535.0;
135 output[1] = col.green / 65535.0;
136 output[2] = col.blue / 65535.0;
137 }
138
139 void status_bar(frontend *fe, char *text)
140 {
141 char *rewritten;
142
143 assert(fe->statusbar);
144
145 rewritten = midend_rewrite_statusbar(fe->me, text);
146 if (!fe->laststatus || strcmp(rewritten, fe->laststatus)) {
147 gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx);
148 gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, rewritten);
149 sfree(fe->laststatus);
150 fe->laststatus = rewritten;
151 } else {
152 sfree(rewritten);
153 }
154 }
155
156 void start_draw(frontend *fe)
157 {
158 fe->gc = gdk_gc_new(fe->area->window);
159 fe->bbox_l = fe->w;
160 fe->bbox_r = 0;
161 fe->bbox_u = fe->h;
162 fe->bbox_d = 0;
163 }
164
165 void clip(frontend *fe, int x, int y, int w, int h)
166 {
167 GdkRectangle rect;
168
169 rect.x = x;
170 rect.y = y;
171 rect.width = w;
172 rect.height = h;
173
174 gdk_gc_set_clip_rectangle(fe->gc, &rect);
175 }
176
177 void unclip(frontend *fe)
178 {
179 GdkRectangle rect;
180
181 rect.x = 0;
182 rect.y = 0;
183 rect.width = fe->w;
184 rect.height = fe->h;
185
186 gdk_gc_set_clip_rectangle(fe->gc, &rect);
187 }
188
189 void draw_text(frontend *fe, int x, int y, int fonttype, int fontsize,
190 int align, int colour, char *text)
191 {
192 int i;
193
194 /*
195 * Find or create the font.
196 */
197 for (i = 0; i < fe->nfonts; i++)
198 if (fe->fonts[i].type == fonttype && fe->fonts[i].size == fontsize)
199 break;
200
201 if (i == fe->nfonts) {
202 if (fe->fontsize <= fe->nfonts) {
203 fe->fontsize = fe->nfonts + 10;
204 fe->fonts = sresize(fe->fonts, fe->fontsize, struct font);
205 }
206
207 fe->nfonts++;
208
209 fe->fonts[i].type = fonttype;
210 fe->fonts[i].size = fontsize;
211
212 #ifdef USE_PANGO
213 /*
214 * Use Pango to find the closest match to the requested
215 * font.
216 */
217 {
218 PangoFontDescription *fd;
219
220 fd = pango_font_description_new();
221 /* `Monospace' and `Sans' are meta-families guaranteed to exist */
222 pango_font_description_set_family(fd, fonttype == FONT_FIXED ?
223 "Monospace" : "Sans");
224 pango_font_description_set_weight(fd, PANGO_WEIGHT_BOLD);
225 /*
226 * I found some online Pango documentation which
227 * described a function called
228 * pango_font_description_set_absolute_size(), which is
229 * _exactly_ what I want here. Unfortunately, none of
230 * my local Pango installations have it (presumably
231 * they're too old), so I'm going to have to hack round
232 * it by figuring out the point size myself. This
233 * limits me to X and probably also breaks in later
234 * Pango installations, so ideally I should add another
235 * CHECK_VERSION type ifdef and use set_absolute_size
236 * where available. All very annoying.
237 */
238 #ifdef HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION
239 pango_font_description_set_absolute_size(fd, PANGO_SCALE*fontsize);
240 #else
241 {
242 Display *d = GDK_DISPLAY();
243 int s = DefaultScreen(d);
244 double resolution =
245 (PANGO_SCALE * 72.27 / 25.4) *
246 ((double) DisplayWidthMM(d, s) / DisplayWidth (d, s));
247 pango_font_description_set_size(fd, resolution * fontsize);
248 }
249 #endif
250 fe->fonts[i].desc = fd;
251 }
252
253 #else
254 /*
255 * In GTK 1.2, I don't know of any plausible way to
256 * pick a suitable font, so I'm just going to be
257 * tedious.
258 */
259 fe->fonts[i].font = gdk_font_load(fonttype == FONT_FIXED ?
260 "fixed" : "variable");
261 #endif
262
263 }
264
265 /*
266 * Set the colour.
267 */
268 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
269
270 #ifdef USE_PANGO
271
272 {
273 PangoLayout *layout;
274 PangoRectangle rect;
275
276 /*
277 * Create a layout.
278 */
279 layout = pango_layout_new(gtk_widget_get_pango_context(fe->area));
280 pango_layout_set_font_description(layout, fe->fonts[i].desc);
281 pango_layout_set_text(layout, text, strlen(text));
282 pango_layout_get_pixel_extents(layout, NULL, &rect);
283
284 if (align & ALIGN_VCENTRE)
285 rect.y -= rect.height / 2;
286
287 if (align & ALIGN_HCENTRE)
288 rect.x -= rect.width / 2;
289 else if (align & ALIGN_HRIGHT)
290 rect.x -= rect.width;
291
292 gdk_draw_layout(fe->pixmap, fe->gc, rect.x + x, rect.y + y, layout);
293
294 g_object_unref(layout);
295 }
296
297 #else
298 /*
299 * Find string dimensions and process alignment.
300 */
301 {
302 int lb, rb, wid, asc, desc;
303
304 /*
305 * Measure vertical string extents with respect to the same
306 * string always...
307 */
308 gdk_string_extents(fe->fonts[i].font,
309 "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
310 &lb, &rb, &wid, &asc, &desc);
311 if (align & ALIGN_VCENTRE)
312 y += asc - (asc+desc)/2;
313
314 /*
315 * ... but horizontal extents with respect to the provided
316 * string. This means that multiple pieces of text centred
317 * on the same y-coordinate don't have different baselines.
318 */
319 gdk_string_extents(fe->fonts[i].font, text,
320 &lb, &rb, &wid, &asc, &desc);
321
322 if (align & ALIGN_HCENTRE)
323 x -= wid / 2;
324 else if (align & ALIGN_HRIGHT)
325 x -= wid;
326
327 }
328
329 /*
330 * Actually draw the text.
331 */
332 gdk_draw_string(fe->pixmap, fe->fonts[i].font, fe->gc, x, y, text);
333 #endif
334
335 }
336
337 void draw_rect(frontend *fe, int x, int y, int w, int h, int colour)
338 {
339 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
340 gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h);
341 }
342
343 void draw_line(frontend *fe, int x1, int y1, int x2, int y2, int colour)
344 {
345 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
346 gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2);
347 }
348
349 void draw_polygon(frontend *fe, int *coords, int npoints,
350 int fill, int colour)
351 {
352 GdkPoint *points = snewn(npoints, GdkPoint);
353 int i;
354
355 for (i = 0; i < npoints; i++) {
356 points[i].x = coords[i*2];
357 points[i].y = coords[i*2+1];
358 }
359
360 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
361 gdk_draw_polygon(fe->pixmap, fe->gc, fill, points, npoints);
362
363 sfree(points);
364 }
365
366 void draw_circle(frontend *fe, int cx, int cy, int radius,
367 int fill, int colour)
368 {
369 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
370 gdk_draw_arc(fe->pixmap, fe->gc, fill,
371 cx - radius, cy - radius,
372 2 * radius, 2 * radius, 0, 360 * 64);
373 }
374
375 struct blitter {
376 GdkPixmap *pixmap;
377 int w, h, x, y;
378 };
379
380 blitter *blitter_new(int w, int h)
381 {
382 /*
383 * We can't create the pixmap right now, because fe->window
384 * might not yet exist. So we just cache w and h and create it
385 * during the firs call to blitter_save.
386 */
387 blitter *bl = snew(blitter);
388 bl->pixmap = NULL;
389 bl->w = w;
390 bl->h = h;
391 return bl;
392 }
393
394 void blitter_free(blitter *bl)
395 {
396 if (bl->pixmap)
397 gdk_pixmap_unref(bl->pixmap);
398 sfree(bl);
399 }
400
401 void blitter_save(frontend *fe, blitter *bl, int x, int y)
402 {
403 if (!bl->pixmap)
404 bl->pixmap = gdk_pixmap_new(fe->area->window, bl->w, bl->h, -1);
405 bl->x = x;
406 bl->y = y;
407 gdk_draw_pixmap(bl->pixmap,
408 fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)],
409 fe->pixmap,
410 x, y, 0, 0, bl->w, bl->h);
411 }
412
413 void blitter_load(frontend *fe, blitter *bl, int x, int y)
414 {
415 assert(bl->pixmap);
416 if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) {
417 x = bl->x;
418 y = bl->y;
419 }
420 gdk_draw_pixmap(fe->pixmap,
421 fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)],
422 bl->pixmap,
423 0, 0, x, y, bl->w, bl->h);
424 }
425
426 void draw_update(frontend *fe, int x, int y, int w, int h)
427 {
428 if (fe->bbox_l > x ) fe->bbox_l = x ;
429 if (fe->bbox_r < x+w) fe->bbox_r = x+w;
430 if (fe->bbox_u > y ) fe->bbox_u = y ;
431 if (fe->bbox_d < y+h) fe->bbox_d = y+h;
432 }
433
434 void end_draw(frontend *fe)
435 {
436 gdk_gc_unref(fe->gc);
437 fe->gc = NULL;
438
439 if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d) {
440 gdk_draw_pixmap(fe->area->window,
441 fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)],
442 fe->pixmap,
443 fe->bbox_l, fe->bbox_u,
444 fe->ox + fe->bbox_l, fe->oy + fe->bbox_u,
445 fe->bbox_r - fe->bbox_l, fe->bbox_d - fe->bbox_u);
446 }
447 }
448
449 static void destroy(GtkWidget *widget, gpointer data)
450 {
451 frontend *fe = (frontend *)data;
452 deactivate_timer(fe);
453 gtk_main_quit();
454 }
455
456 static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
457 {
458 frontend *fe = (frontend *)data;
459 int keyval;
460 int shift = (event->state & GDK_SHIFT_MASK) ? MOD_SHFT : 0;
461 int ctrl = (event->state & GDK_CONTROL_MASK) ? MOD_CTRL : 0;
462
463 if (!fe->pixmap)
464 return TRUE;
465
466 if (event->keyval == GDK_Up)
467 keyval = shift | ctrl | CURSOR_UP;
468 else if (event->keyval == GDK_KP_Up || event->keyval == GDK_KP_8)
469 keyval = MOD_NUM_KEYPAD | '8';
470 else if (event->keyval == GDK_Down)
471 keyval = shift | ctrl | CURSOR_DOWN;
472 else if (event->keyval == GDK_KP_Down || event->keyval == GDK_KP_2)
473 keyval = MOD_NUM_KEYPAD | '2';
474 else if (event->keyval == GDK_Left)
475 keyval = shift | ctrl | CURSOR_LEFT;
476 else if (event->keyval == GDK_KP_Left || event->keyval == GDK_KP_4)
477 keyval = MOD_NUM_KEYPAD | '4';
478 else if (event->keyval == GDK_Right)
479 keyval = shift | ctrl | CURSOR_RIGHT;
480 else if (event->keyval == GDK_KP_Right || event->keyval == GDK_KP_6)
481 keyval = MOD_NUM_KEYPAD | '6';
482 else if (event->keyval == GDK_KP_Home || event->keyval == GDK_KP_7)
483 keyval = MOD_NUM_KEYPAD | '7';
484 else if (event->keyval == GDK_KP_End || event->keyval == GDK_KP_1)
485 keyval = MOD_NUM_KEYPAD | '1';
486 else if (event->keyval == GDK_KP_Page_Up || event->keyval == GDK_KP_9)
487 keyval = MOD_NUM_KEYPAD | '9';
488 else if (event->keyval == GDK_KP_Page_Down || event->keyval == GDK_KP_3)
489 keyval = MOD_NUM_KEYPAD | '3';
490 else if (event->keyval == GDK_KP_Insert || event->keyval == GDK_KP_0)
491 keyval = MOD_NUM_KEYPAD | '0';
492 else if (event->keyval == GDK_KP_Begin || event->keyval == GDK_KP_5)
493 keyval = MOD_NUM_KEYPAD | '5';
494 else if (event->string[0] && !event->string[1])
495 keyval = (unsigned char)event->string[0];
496 else
497 keyval = -1;
498
499 if (keyval >= 0 &&
500 !midend_process_key(fe->me, 0, 0, keyval))
501 gtk_widget_destroy(fe->window);
502
503 return TRUE;
504 }
505
506 static gint button_event(GtkWidget *widget, GdkEventButton *event,
507 gpointer data)
508 {
509 frontend *fe = (frontend *)data;
510 int button;
511
512 if (!fe->pixmap)
513 return TRUE;
514
515 if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE)
516 return TRUE;
517
518 if (event->button == 2 || (event->state & GDK_SHIFT_MASK))
519 button = MIDDLE_BUTTON;
520 else if (event->button == 3 || (event->state & GDK_MOD1_MASK))
521 button = RIGHT_BUTTON;
522 else if (event->button == 1)
523 button = LEFT_BUTTON;
524 else
525 return FALSE; /* don't even know what button! */
526
527 if (event->type == GDK_BUTTON_RELEASE)
528 button += LEFT_RELEASE - LEFT_BUTTON;
529
530 if (!midend_process_key(fe->me, event->x - fe->ox,
531 event->y - fe->oy, button))
532 gtk_widget_destroy(fe->window);
533
534 return TRUE;
535 }
536
537 static gint motion_event(GtkWidget *widget, GdkEventMotion *event,
538 gpointer data)
539 {
540 frontend *fe = (frontend *)data;
541 int button;
542
543 if (!fe->pixmap)
544 return TRUE;
545
546 if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK))
547 button = MIDDLE_DRAG;
548 else if (event->state & GDK_BUTTON1_MASK)
549 button = LEFT_DRAG;
550 else if (event->state & GDK_BUTTON3_MASK)
551 button = RIGHT_DRAG;
552 else
553 return FALSE; /* don't even know what button! */
554
555 if (!midend_process_key(fe->me, event->x - fe->ox,
556 event->y - fe->oy, button))
557 gtk_widget_destroy(fe->window);
558
559 return TRUE;
560 }
561
562 static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
563 gpointer data)
564 {
565 frontend *fe = (frontend *)data;
566
567 if (fe->pixmap) {
568 gdk_draw_pixmap(widget->window,
569 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
570 fe->pixmap,
571 event->area.x - fe->ox, event->area.y - fe->oy,
572 event->area.x, event->area.y,
573 event->area.width, event->area.height);
574 }
575 return TRUE;
576 }
577
578 static gint map_window(GtkWidget *widget, GdkEvent *event,
579 gpointer data)
580 {
581 frontend *fe = (frontend *)data;
582
583 /*
584 * Apparently we need to do this because otherwise the status
585 * bar will fail to update immediately. Annoying, but there we
586 * go.
587 */
588 gtk_widget_queue_draw(fe->window);
589
590 return TRUE;
591 }
592
593 static gint configure_area(GtkWidget *widget,
594 GdkEventConfigure *event, gpointer data)
595 {
596 frontend *fe = (frontend *)data;
597 GdkGC *gc;
598 int x, y;
599
600 if (fe->pixmap)
601 gdk_pixmap_unref(fe->pixmap);
602
603 x = fe->w = event->width;
604 y = fe->h = event->height;
605 midend_size(fe->me, &x, &y, TRUE);
606 fe->pw = x;
607 fe->ph = y;
608 fe->ox = (fe->w - fe->pw) / 2;
609 fe->oy = (fe->h - fe->ph) / 2;
610
611 fe->pixmap = gdk_pixmap_new(widget->window, fe->pw, fe->ph, -1);
612
613 gc = gdk_gc_new(fe->area->window);
614 gdk_gc_set_foreground(gc, &fe->colours[0]);
615 gdk_draw_rectangle(fe->pixmap, gc, 1, 0, 0, fe->pw, fe->ph);
616 gdk_gc_unref(gc);
617
618 midend_force_redraw(fe->me);
619
620 return TRUE;
621 }
622
623 static gint timer_func(gpointer data)
624 {
625 frontend *fe = (frontend *)data;
626
627 if (fe->timer_active) {
628 struct timeval now;
629 float elapsed;
630 gettimeofday(&now, NULL);
631 elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F +
632 (now.tv_sec - fe->last_time.tv_sec));
633 midend_timer(fe->me, elapsed); /* may clear timer_active */
634 fe->last_time = now;
635 }
636
637 return fe->timer_active;
638 }
639
640 void deactivate_timer(frontend *fe)
641 {
642 if (fe->timer_active)
643 gtk_timeout_remove(fe->timer_id);
644 fe->timer_active = FALSE;
645 }
646
647 void activate_timer(frontend *fe)
648 {
649 if (!fe->timer_active) {
650 fe->timer_id = gtk_timeout_add(20, timer_func, fe);
651 gettimeofday(&fe->last_time, NULL);
652 }
653 fe->timer_active = TRUE;
654 }
655
656 static void window_destroy(GtkWidget *widget, gpointer data)
657 {
658 gtk_main_quit();
659 }
660
661 static void errmsg_button_clicked(GtkButton *button, gpointer data)
662 {
663 gtk_widget_destroy(GTK_WIDGET(data));
664 }
665
666 static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
667 {
668 GtkObject *cancelbutton = GTK_OBJECT(data);
669
670 /*
671 * `Escape' effectively clicks the cancel button
672 */
673 if (event->keyval == GDK_Escape) {
674 gtk_signal_emit_by_name(GTK_OBJECT(cancelbutton), "clicked");
675 return TRUE;
676 }
677
678 return FALSE;
679 }
680
681 void message_box(GtkWidget *parent, char *title, char *msg, int centre)
682 {
683 GtkWidget *window, *hbox, *text, *ok;
684
685 window = gtk_dialog_new();
686 text = gtk_label_new(msg);
687 gtk_misc_set_alignment(GTK_MISC(text), 0.0, 0.0);
688 hbox = gtk_hbox_new(FALSE, 0);
689 gtk_box_pack_start(GTK_BOX(hbox), text, FALSE, FALSE, 20);
690 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox),
691 hbox, FALSE, FALSE, 20);
692 gtk_widget_show(text);
693 gtk_widget_show(hbox);
694 gtk_window_set_title(GTK_WINDOW(window), title);
695 gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
696 ok = gtk_button_new_with_label("OK");
697 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(window)->action_area),
698 ok, FALSE, FALSE, 0);
699 gtk_widget_show(ok);
700 GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
701 gtk_window_set_default(GTK_WINDOW(window), ok);
702 gtk_signal_connect(GTK_OBJECT(ok), "clicked",
703 GTK_SIGNAL_FUNC(errmsg_button_clicked), window);
704 gtk_signal_connect(GTK_OBJECT(window), "destroy",
705 GTK_SIGNAL_FUNC(window_destroy), NULL);
706 gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
707 GTK_SIGNAL_FUNC(win_key_press), ok);
708 gtk_window_set_modal(GTK_WINDOW(window), TRUE);
709 gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(parent));
710 /* set_transient_window_pos(parent, window); */
711 gtk_widget_show(window);
712 gtk_main();
713 }
714
715 void error_box(GtkWidget *parent, char *msg)
716 {
717 message_box(parent, "Error", msg, FALSE);
718 }
719
720 static void config_ok_button_clicked(GtkButton *button, gpointer data)
721 {
722 frontend *fe = (frontend *)data;
723 char *err;
724
725 err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
726
727 if (err)
728 error_box(fe->cfgbox, err);
729 else {
730 fe->cfgret = TRUE;
731 gtk_widget_destroy(fe->cfgbox);
732 }
733 }
734
735 static void config_cancel_button_clicked(GtkButton *button, gpointer data)
736 {
737 frontend *fe = (frontend *)data;
738
739 gtk_widget_destroy(fe->cfgbox);
740 }
741
742 static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data)
743 {
744 /*
745 * GtkEntry has a nasty habit of eating the Return key, which
746 * is unhelpful since it doesn't actually _do_ anything with it
747 * (it calls gtk_widget_activate, but our edit boxes never need
748 * activating). So I catch Return before GtkEntry sees it, and
749 * pass it straight on to the parent widget. Effect: hitting
750 * Return in an edit box will now activate the default button
751 * in the dialog just like it will everywhere else.
752 */
753 if (event->keyval == GDK_Return && widget->parent != NULL) {
754 gint return_val;
755 gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key_press_event");
756 gtk_signal_emit_by_name(GTK_OBJECT(widget->parent), "key_press_event",
757 event, &return_val);
758 return return_val;
759 }
760 return FALSE;
761 }
762
763 static void editbox_changed(GtkEditable *ed, gpointer data)
764 {
765 config_item *i = (config_item *)data;
766
767 sfree(i->sval);
768 i->sval = dupstr(gtk_entry_get_text(GTK_ENTRY(ed)));
769 }
770
771 static void button_toggled(GtkToggleButton *tb, gpointer data)
772 {
773 config_item *i = (config_item *)data;
774
775 i->ival = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb));
776 }
777
778 static void droplist_sel(GtkMenuItem *item, gpointer data)
779 {
780 config_item *i = (config_item *)data;
781
782 i->ival = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),
783 "user-data"));
784 }
785
786 static int get_config(frontend *fe, int which)
787 {
788 GtkWidget *w, *table, *cancel;
789 char *title;
790 config_item *i;
791 int y;
792
793 fe->cfg = midend_get_config(fe->me, which, &title);
794 fe->cfg_which = which;
795 fe->cfgret = FALSE;
796
797 fe->cfgbox = gtk_dialog_new();
798 gtk_window_set_title(GTK_WINDOW(fe->cfgbox), title);
799 sfree(title);
800
801 w = gtk_button_new_with_label("OK");
802 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area),
803 w, FALSE, FALSE, 0);
804 gtk_widget_show(w);
805 GTK_WIDGET_SET_FLAGS(w, GTK_CAN_DEFAULT);
806 gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w);
807 gtk_signal_connect(GTK_OBJECT(w), "clicked",
808 GTK_SIGNAL_FUNC(config_ok_button_clicked), fe);
809
810 w = gtk_button_new_with_label("Cancel");
811 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area),
812 w, FALSE, FALSE, 0);
813 gtk_widget_show(w);
814 gtk_signal_connect(GTK_OBJECT(w), "clicked",
815 GTK_SIGNAL_FUNC(config_cancel_button_clicked), fe);
816 cancel = w;
817
818 table = gtk_table_new(1, 2, FALSE);
819 y = 0;
820 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->vbox),
821 table, FALSE, FALSE, 0);
822 gtk_widget_show(table);
823
824 for (i = fe->cfg; i->type != C_END; i++) {
825 gtk_table_resize(GTK_TABLE(table), y+1, 2);
826
827 switch (i->type) {
828 case C_STRING:
829 /*
830 * Edit box with a label beside it.
831 */
832
833 w = gtk_label_new(i->name);
834 gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
835 gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
836 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
837 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
838 3, 3);
839 gtk_widget_show(w);
840
841 w = gtk_entry_new();
842 gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
843 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
844 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
845 3, 3);
846 gtk_entry_set_text(GTK_ENTRY(w), i->sval);
847 gtk_signal_connect(GTK_OBJECT(w), "changed",
848 GTK_SIGNAL_FUNC(editbox_changed), i);
849 gtk_signal_connect(GTK_OBJECT(w), "key_press_event",
850 GTK_SIGNAL_FUNC(editbox_key), NULL);
851 gtk_widget_show(w);
852
853 break;
854
855 case C_BOOLEAN:
856 /*
857 * Simple checkbox.
858 */
859 w = gtk_check_button_new_with_label(i->name);
860 gtk_signal_connect(GTK_OBJECT(w), "toggled",
861 GTK_SIGNAL_FUNC(button_toggled), i);
862 gtk_table_attach(GTK_TABLE(table), w, 0, 2, y, y+1,
863 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
864 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
865 3, 3);
866 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), i->ival);
867 gtk_widget_show(w);
868 break;
869
870 case C_CHOICES:
871 /*
872 * Drop-down list (GtkOptionMenu).
873 */
874
875 w = gtk_label_new(i->name);
876 gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
877 gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
878 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
879 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
880 3, 3);
881 gtk_widget_show(w);
882
883 w = gtk_option_menu_new();
884 gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
885 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
886 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
887 3, 3);
888 gtk_widget_show(w);
889
890 {
891 int c, val;
892 char *p, *q, *name;
893 GtkWidget *menuitem;
894 GtkWidget *menu = gtk_menu_new();
895
896 gtk_option_menu_set_menu(GTK_OPTION_MENU(w), menu);
897
898 c = *i->sval;
899 p = i->sval+1;
900 val = 0;
901
902 while (*p) {
903 q = p;
904 while (*q && *q != c)
905 q++;
906
907 name = snewn(q-p+1, char);
908 strncpy(name, p, q-p);
909 name[q-p] = '\0';
910
911 if (*q) q++; /* eat delimiter */
912
913 menuitem = gtk_menu_item_new_with_label(name);
914 gtk_container_add(GTK_CONTAINER(menu), menuitem);
915 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
916 GINT_TO_POINTER(val));
917 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
918 GTK_SIGNAL_FUNC(droplist_sel), i);
919 gtk_widget_show(menuitem);
920
921 val++;
922
923 p = q;
924 }
925
926 gtk_option_menu_set_history(GTK_OPTION_MENU(w), i->ival);
927 }
928
929 break;
930 }
931
932 y++;
933 }
934
935 gtk_signal_connect(GTK_OBJECT(fe->cfgbox), "destroy",
936 GTK_SIGNAL_FUNC(window_destroy), NULL);
937 gtk_signal_connect(GTK_OBJECT(fe->cfgbox), "key_press_event",
938 GTK_SIGNAL_FUNC(win_key_press), cancel);
939 gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), TRUE);
940 gtk_window_set_transient_for(GTK_WINDOW(fe->cfgbox),
941 GTK_WINDOW(fe->window));
942 /* set_transient_window_pos(fe->window, fe->cfgbox); */
943 gtk_widget_show(fe->cfgbox);
944 gtk_main();
945
946 free_cfg(fe->cfg);
947
948 return fe->cfgret;
949 }
950
951 static void menu_key_event(GtkMenuItem *menuitem, gpointer data)
952 {
953 frontend *fe = (frontend *)data;
954 int key = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
955 "user-data"));
956 if (!midend_process_key(fe->me, 0, 0, key))
957 gtk_widget_destroy(fe->window);
958 }
959
960 static void get_size(frontend *fe, int *px, int *py)
961 {
962 int x, y;
963
964 /*
965 * Currently I don't want to make the GTK port scale large
966 * puzzles to fit on the screen. This is because X does permit
967 * extremely large windows and many window managers provide a
968 * means of navigating round them, and the users I consulted
969 * before deciding said that they'd rather have enormous puzzle
970 * windows spanning multiple screen pages than have them
971 * shrunk. I could change my mind later or introduce
972 * configurability; this would be the place to do so, by
973 * replacing the initial values of x and y with the screen
974 * dimensions.
975 */
976 x = INT_MAX;
977 y = INT_MAX;
978 midend_size(fe->me, &x, &y, FALSE);
979 *px = x;
980 *py = y;
981 }
982
983 #if !GTK_CHECK_VERSION(2,0,0)
984 #define gtk_window_resize(win, x, y) \
985 gdk_window_resize(GTK_WIDGET(win)->window, x, y)
986 #endif
987
988 static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
989 {
990 frontend *fe = (frontend *)data;
991 game_params *params =
992 (game_params *)gtk_object_get_data(GTK_OBJECT(menuitem), "user-data");
993 int x, y;
994
995 midend_set_params(fe->me, params);
996 midend_new_game(fe->me);
997 get_size(fe, &x, &y);
998 fe->w = x;
999 fe->h = y;
1000 gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
1001 gtk_window_resize(GTK_WINDOW(fe->window), 1, 1);
1002 }
1003
1004 GdkAtom compound_text_atom, utf8_string_atom;
1005 int paste_initialised = FALSE;
1006
1007 void init_paste()
1008 {
1009 unsigned char empty[] = { 0 };
1010
1011 if (paste_initialised)
1012 return;
1013
1014 if (!compound_text_atom)
1015 compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE);
1016 if (!utf8_string_atom)
1017 utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE);
1018
1019 /*
1020 * Ensure that all the cut buffers exist - according to the
1021 * ICCCM, we must do this before we start using cut buffers.
1022 */
1023 XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
1024 XA_CUT_BUFFER0, XA_STRING, 8, PropModeAppend, empty, 0);
1025 XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
1026 XA_CUT_BUFFER1, XA_STRING, 8, PropModeAppend, empty, 0);
1027 XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
1028 XA_CUT_BUFFER2, XA_STRING, 8, PropModeAppend, empty, 0);
1029 XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
1030 XA_CUT_BUFFER3, XA_STRING, 8, PropModeAppend, empty, 0);
1031 XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
1032 XA_CUT_BUFFER4, XA_STRING, 8, PropModeAppend, empty, 0);
1033 XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
1034 XA_CUT_BUFFER5, XA_STRING, 8, PropModeAppend, empty, 0);
1035 XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
1036 XA_CUT_BUFFER6, XA_STRING, 8, PropModeAppend, empty, 0);
1037 XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
1038 XA_CUT_BUFFER7, XA_STRING, 8, PropModeAppend, empty, 0);
1039 }
1040
1041 /* Store data in a cut-buffer. */
1042 void store_cutbuffer(char *ptr, int len)
1043 {
1044 /* ICCCM says we must rotate the buffers before storing to buffer 0. */
1045 XRotateBuffers(GDK_DISPLAY(), 1);
1046 XStoreBytes(GDK_DISPLAY(), ptr, len);
1047 }
1048
1049 void write_clip(frontend *fe, char *data)
1050 {
1051 init_paste();
1052
1053 if (fe->paste_data)
1054 sfree(fe->paste_data);
1055
1056 /*
1057 * For this simple application we can safely assume that the
1058 * data passed to this function is pure ASCII, which means we
1059 * can return precisely the same stuff for types STRING,
1060 * COMPOUND_TEXT or UTF8_STRING.
1061 */
1062
1063 fe->paste_data = data;
1064 fe->paste_data_len = strlen(data);
1065
1066 store_cutbuffer(fe->paste_data, fe->paste_data_len);
1067
1068 if (gtk_selection_owner_set(fe->area, GDK_SELECTION_PRIMARY,
1069 CurrentTime)) {
1070 gtk_selection_add_target(fe->area, GDK_SELECTION_PRIMARY,
1071 GDK_SELECTION_TYPE_STRING, 1);
1072 gtk_selection_add_target(fe->area, GDK_SELECTION_PRIMARY,
1073 compound_text_atom, 1);
1074 gtk_selection_add_target(fe->area, GDK_SELECTION_PRIMARY,
1075 utf8_string_atom, 1);
1076 }
1077 }
1078
1079 void selection_get(GtkWidget *widget, GtkSelectionData *seldata,
1080 guint info, guint time_stamp, gpointer data)
1081 {
1082 frontend *fe = (frontend *)data;
1083 gtk_selection_data_set(seldata, seldata->target, 8,
1084 fe->paste_data, fe->paste_data_len);
1085 }
1086
1087 gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
1088 gpointer data)
1089 {
1090 frontend *fe = (frontend *)data;
1091
1092 if (fe->paste_data)
1093 sfree(fe->paste_data);
1094 fe->paste_data = NULL;
1095 fe->paste_data_len = 0;
1096 return TRUE;
1097 }
1098
1099 static void menu_copy_event(GtkMenuItem *menuitem, gpointer data)
1100 {
1101 frontend *fe = (frontend *)data;
1102 char *text;
1103
1104 text = midend_text_format(fe->me);
1105
1106 if (text) {
1107 write_clip(fe, text);
1108 } else {
1109 gdk_beep();
1110 }
1111 }
1112
1113 static void menu_solve_event(GtkMenuItem *menuitem, gpointer data)
1114 {
1115 frontend *fe = (frontend *)data;
1116 char *msg;
1117
1118 msg = midend_solve(fe->me);
1119
1120 if (msg)
1121 error_box(fe->window, msg);
1122 }
1123
1124 static void menu_restart_event(GtkMenuItem *menuitem, gpointer data)
1125 {
1126 frontend *fe = (frontend *)data;
1127
1128 midend_restart_game(fe->me);
1129 }
1130
1131 static void menu_config_event(GtkMenuItem *menuitem, gpointer data)
1132 {
1133 frontend *fe = (frontend *)data;
1134 int which = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
1135 "user-data"));
1136 int x, y;
1137
1138 if (!get_config(fe, which))
1139 return;
1140
1141 midend_new_game(fe->me);
1142 get_size(fe, &x, &y);
1143 fe->w = x;
1144 fe->h = y;
1145 gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
1146 gtk_window_resize(GTK_WINDOW(fe->window), 1, 1);
1147 }
1148
1149 static void menu_about_event(GtkMenuItem *menuitem, gpointer data)
1150 {
1151 frontend *fe = (frontend *)data;
1152 char titlebuf[256];
1153 char textbuf[1024];
1154
1155 sprintf(titlebuf, "About %.200s", thegame.name);
1156 sprintf(textbuf,
1157 "%.200s\n\n"
1158 "from Simon Tatham's Portable Puzzle Collection\n\n"
1159 "%.500s", thegame.name, ver);
1160
1161 message_box(fe->window, titlebuf, textbuf, TRUE);
1162 }
1163
1164 static GtkWidget *add_menu_item_with_key(frontend *fe, GtkContainer *cont,
1165 char *text, int key)
1166 {
1167 GtkWidget *menuitem = gtk_menu_item_new_with_label(text);
1168 gtk_container_add(cont, menuitem);
1169 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
1170 GINT_TO_POINTER(key));
1171 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1172 GTK_SIGNAL_FUNC(menu_key_event), fe);
1173 gtk_widget_show(menuitem);
1174 return menuitem;
1175 }
1176
1177 static void add_menu_separator(GtkContainer *cont)
1178 {
1179 GtkWidget *menuitem = gtk_menu_item_new();
1180 gtk_container_add(cont, menuitem);
1181 gtk_widget_show(menuitem);
1182 }
1183
1184 static frontend *new_window(char *game_id, char **error)
1185 {
1186 frontend *fe;
1187 GtkBox *vbox;
1188 GtkWidget *menubar, *menu, *menuitem;
1189 int x, y, n;
1190
1191 fe = snew(frontend);
1192
1193 fe->timer_active = FALSE;
1194 fe->timer_id = -1;
1195
1196 fe->me = midend_new(fe, &thegame);
1197
1198 if (game_id) {
1199 *error = midend_game_id(fe->me, game_id);
1200 if (*error) {
1201 midend_free(fe->me);
1202 sfree(fe);
1203 return NULL;
1204 }
1205 }
1206 midend_new_game(fe->me);
1207
1208 fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1209 gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name);
1210 #if 0
1211 gtk_window_set_resizable(GTK_WINDOW(fe->window), FALSE);
1212 #else
1213 gtk_window_set_policy(GTK_WINDOW(fe->window), FALSE, FALSE, TRUE);
1214 #endif
1215 vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
1216 gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
1217 gtk_widget_show(GTK_WIDGET(vbox));
1218
1219 menubar = gtk_menu_bar_new();
1220 gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
1221 gtk_widget_show(menubar);
1222
1223 menuitem = gtk_menu_item_new_with_label("Game");
1224 gtk_container_add(GTK_CONTAINER(menubar), menuitem);
1225 gtk_widget_show(menuitem);
1226
1227 menu = gtk_menu_new();
1228 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
1229
1230 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "New", 'n');
1231
1232 menuitem = gtk_menu_item_new_with_label("Restart");
1233 gtk_container_add(GTK_CONTAINER(menu), menuitem);
1234 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1235 GTK_SIGNAL_FUNC(menu_restart_event), fe);
1236 gtk_widget_show(menuitem);
1237
1238 menuitem = gtk_menu_item_new_with_label("Specific...");
1239 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
1240 GINT_TO_POINTER(CFG_DESC));
1241 gtk_container_add(GTK_CONTAINER(menu), menuitem);
1242 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1243 GTK_SIGNAL_FUNC(menu_config_event), fe);
1244 gtk_widget_show(menuitem);
1245
1246 menuitem = gtk_menu_item_new_with_label("Random Seed...");
1247 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
1248 GINT_TO_POINTER(CFG_SEED));
1249 gtk_container_add(GTK_CONTAINER(menu), menuitem);
1250 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1251 GTK_SIGNAL_FUNC(menu_config_event), fe);
1252 gtk_widget_show(menuitem);
1253
1254 if ((n = midend_num_presets(fe->me)) > 0 || thegame.can_configure) {
1255 GtkWidget *submenu;
1256 int i;
1257
1258 menuitem = gtk_menu_item_new_with_label("Type");
1259 gtk_container_add(GTK_CONTAINER(menubar), menuitem);
1260 gtk_widget_show(menuitem);
1261
1262 submenu = gtk_menu_new();
1263 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
1264
1265 for (i = 0; i < n; i++) {
1266 char *name;
1267 game_params *params;
1268
1269 midend_fetch_preset(fe->me, i, &name, &params);
1270
1271 menuitem = gtk_menu_item_new_with_label(name);
1272 gtk_container_add(GTK_CONTAINER(submenu), menuitem);
1273 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data", params);
1274 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1275 GTK_SIGNAL_FUNC(menu_preset_event), fe);
1276 gtk_widget_show(menuitem);
1277 }
1278
1279 if (thegame.can_configure) {
1280 menuitem = gtk_menu_item_new_with_label("Custom...");
1281 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
1282 GPOINTER_TO_INT(CFG_SETTINGS));
1283 gtk_container_add(GTK_CONTAINER(submenu), menuitem);
1284 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1285 GTK_SIGNAL_FUNC(menu_config_event), fe);
1286 gtk_widget_show(menuitem);
1287 }
1288 }
1289
1290 add_menu_separator(GTK_CONTAINER(menu));
1291 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Undo", 'u');
1292 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Redo", '\x12');
1293 if (thegame.can_format_as_text) {
1294 add_menu_separator(GTK_CONTAINER(menu));
1295 menuitem = gtk_menu_item_new_with_label("Copy");
1296 gtk_container_add(GTK_CONTAINER(menu), menuitem);
1297 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1298 GTK_SIGNAL_FUNC(menu_copy_event), fe);
1299 gtk_widget_show(menuitem);
1300 }
1301 if (thegame.can_solve) {
1302 add_menu_separator(GTK_CONTAINER(menu));
1303 menuitem = gtk_menu_item_new_with_label("Solve");
1304 gtk_container_add(GTK_CONTAINER(menu), menuitem);
1305 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1306 GTK_SIGNAL_FUNC(menu_solve_event), fe);
1307 gtk_widget_show(menuitem);
1308 }
1309 add_menu_separator(GTK_CONTAINER(menu));
1310 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Exit", 'q');
1311
1312 menuitem = gtk_menu_item_new_with_label("Help");
1313 gtk_container_add(GTK_CONTAINER(menubar), menuitem);
1314 gtk_widget_show(menuitem);
1315
1316 menu = gtk_menu_new();
1317 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
1318
1319 menuitem = gtk_menu_item_new_with_label("About");
1320 gtk_container_add(GTK_CONTAINER(menu), menuitem);
1321 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
1322 GTK_SIGNAL_FUNC(menu_about_event), fe);
1323 gtk_widget_show(menuitem);
1324
1325 {
1326 int i, ncolours;
1327 float *colours;
1328 gboolean *success;
1329
1330 fe->colmap = gdk_colormap_get_system();
1331 colours = midend_colours(fe->me, &ncolours);
1332 fe->ncolours = ncolours;
1333 fe->colours = snewn(ncolours, GdkColor);
1334 for (i = 0; i < ncolours; i++) {
1335 fe->colours[i].red = colours[i*3] * 0xFFFF;
1336 fe->colours[i].green = colours[i*3+1] * 0xFFFF;
1337 fe->colours[i].blue = colours[i*3+2] * 0xFFFF;
1338 }
1339 success = snewn(ncolours, gboolean);
1340 gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours,
1341 FALSE, FALSE, success);
1342 for (i = 0; i < ncolours; i++) {
1343 if (!success[i])
1344 g_error("couldn't allocate colour %d (#%02x%02x%02x)\n",
1345 i, fe->colours[i].red >> 8,
1346 fe->colours[i].green >> 8,
1347 fe->colours[i].blue >> 8);
1348 }
1349 }
1350
1351 if (midend_wants_statusbar(fe->me)) {
1352 GtkWidget *viewport;
1353 GtkRequisition req;
1354
1355 viewport = gtk_viewport_new(NULL, NULL);
1356 gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
1357 fe->statusbar = gtk_statusbar_new();
1358 gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar);
1359 gtk_widget_show(viewport);
1360 gtk_box_pack_end(vbox, viewport, FALSE, FALSE, 0);
1361 gtk_widget_show(fe->statusbar);
1362 fe->statusctx = gtk_statusbar_get_context_id
1363 (GTK_STATUSBAR(fe->statusbar), "game");
1364 gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx,
1365 "test");
1366 gtk_widget_size_request(fe->statusbar, &req);
1367 #if 0
1368 /* For GTK 2.0, should we be using gtk_widget_set_size_request? */
1369 #endif
1370 gtk_widget_set_usize(viewport, -1, req.height);
1371 } else
1372 fe->statusbar = NULL;
1373
1374 fe->area = gtk_drawing_area_new();
1375 get_size(fe, &x, &y);
1376 gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
1377 fe->w = x;
1378 fe->h = y;
1379
1380 gtk_box_pack_end(vbox, fe->area, TRUE, TRUE, 0);
1381
1382 fe->pixmap = NULL;
1383 fe->fonts = NULL;
1384 fe->nfonts = fe->fontsize = 0;
1385
1386 fe->laststatus = NULL;
1387
1388 fe->paste_data = NULL;
1389 fe->paste_data_len = 0;
1390
1391 gtk_signal_connect(GTK_OBJECT(fe->window), "destroy",
1392 GTK_SIGNAL_FUNC(destroy), fe);
1393 gtk_signal_connect(GTK_OBJECT(fe->window), "key_press_event",
1394 GTK_SIGNAL_FUNC(key_event), fe);
1395 gtk_signal_connect(GTK_OBJECT(fe->area), "button_press_event",
1396 GTK_SIGNAL_FUNC(button_event), fe);
1397 gtk_signal_connect(GTK_OBJECT(fe->area), "button_release_event",
1398 GTK_SIGNAL_FUNC(button_event), fe);
1399 gtk_signal_connect(GTK_OBJECT(fe->area), "motion_notify_event",
1400 GTK_SIGNAL_FUNC(motion_event), fe);
1401 gtk_signal_connect(GTK_OBJECT(fe->area), "selection_get",
1402 GTK_SIGNAL_FUNC(selection_get), fe);
1403 gtk_signal_connect(GTK_OBJECT(fe->area), "selection_clear_event",
1404 GTK_SIGNAL_FUNC(selection_clear), fe);
1405 gtk_signal_connect(GTK_OBJECT(fe->area), "expose_event",
1406 GTK_SIGNAL_FUNC(expose_area), fe);
1407 gtk_signal_connect(GTK_OBJECT(fe->window), "map_event",
1408 GTK_SIGNAL_FUNC(map_window), fe);
1409 gtk_signal_connect(GTK_OBJECT(fe->area), "configure_event",
1410 GTK_SIGNAL_FUNC(configure_area), fe);
1411
1412 gtk_widget_add_events(GTK_WIDGET(fe->area),
1413 GDK_BUTTON_PRESS_MASK |
1414 GDK_BUTTON_RELEASE_MASK |
1415 GDK_BUTTON_MOTION_MASK);
1416
1417 gtk_widget_show(fe->area);
1418 gtk_widget_show(fe->window);
1419
1420 gdk_window_set_background(fe->area->window, &fe->colours[0]);
1421 gdk_window_set_background(fe->window->window, &fe->colours[0]);
1422
1423 return fe;
1424 }
1425
1426 int main(int argc, char **argv)
1427 {
1428 char *pname = argv[0];
1429 char *error;
1430
1431 if (argc > 1 && !strcmp(argv[1], "--version")) {
1432 printf("%s, from Simon Tatham's Portable Puzzle Collection\n%s\n",
1433 thegame.name, ver);
1434 return 0;
1435 }
1436
1437 /*
1438 * Special standalone mode for generating puzzle IDs on the
1439 * command line. Useful for generating puzzles to be printed
1440 * out and solved offline (for puzzles where that even makes
1441 * sense - Solo, for example, is a lot more pencil-and-paper
1442 * friendly than Net!)
1443 *
1444 * Usage:
1445 *
1446 * <puzzle-name> --generate [<n> [<params>]]
1447 *
1448 * <n>, if present, is the number of puzzle IDs to generate.
1449 * <params>, if present, is the same type of parameter string
1450 * you would pass to the puzzle when running it in GUI mode,
1451 * including optional extras such as the expansion factor in
1452 * Rectangles and the difficulty level in Solo.
1453 *
1454 * If you specify <params>, you must also specify <n> (although
1455 * you may specify it to be 1). Sorry; that was the
1456 * simplest-to-parse command-line syntax I came up with.
1457 */
1458 if (argc > 1 && !strcmp(argv[1], "--generate")) {
1459 int n = 1;
1460 char *params = NULL, *seed = NULL;
1461 game_params *par;
1462 random_state *rs;
1463 char *parstr;
1464
1465 if (argc > 2)
1466 n = atoi(argv[2]);
1467 if (argc > 3)
1468 params = argv[3];
1469
1470 par = thegame.default_params();
1471 if (params) {
1472 if ( (seed = strchr(params, '#')) != NULL )
1473 *seed++ = '\0';
1474 thegame.decode_params(par, params);
1475 }
1476 if ((error = thegame.validate_params(par)) != NULL) {
1477 fprintf(stderr, "%s: %s\n", pname, error);
1478 return 1;
1479 }
1480 parstr = thegame.encode_params(par, FALSE);
1481
1482 {
1483 void *seeddata;
1484 int seedlen;
1485 if (seed) {
1486 seeddata = seed;
1487 seedlen = strlen(seed);
1488 } else {
1489 get_random_seed(&seeddata, &seedlen);
1490 }
1491 rs = random_init(seeddata, seedlen);
1492 }
1493
1494 while (n-- > 0) {
1495 game_aux_info *aux = NULL;
1496 char *desc = thegame.new_desc(par, rs, &aux, FALSE);
1497 printf("%s:%s\n", parstr, desc);
1498 sfree(desc);
1499 if (aux)
1500 thegame.free_aux_info(aux);
1501 }
1502
1503 return 0;
1504 } else {
1505
1506 gtk_init(&argc, &argv);
1507
1508 if (!new_window(argc > 1 ? argv[1] : NULL, &error)) {
1509 fprintf(stderr, "%s: %s\n", pname, error);
1510 return 1;
1511 }
1512
1513 gtk_main();
1514 }
1515
1516 return 0;
1517 }