~mdw / sgt / puzzles / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Make Return and Escape work reliably in GTK dialog boxes.
[sgt/puzzles] / gtk.c
CommitLineData
720a8fb7 1/*
2 * gtk.c: GTK front end for my puzzle collection.
3 */
4
5#include <stdio.h>
fd1a1a2b 6#include <assert.h>
720a8fb7 7#include <stdlib.h>
2ef96bd6 8#include <time.h>
720a8fb7 9#include <stdarg.h>
c8230524 10#include <string.h>
720a8fb7 11
83680571 12#include <gtk/gtk.h>
1482ee76 13#include <gdk/gdkkeysyms.h>
83680571 14
720a8fb7 15#include "puzzles.h"
16
83680571 17/* ----------------------------------------------------------------------
18 * Error reporting functions used elsewhere.
19 */
20
720a8fb7 21void fatal(char *fmt, ...)
22{
23 va_list ap;
24
25 fprintf(stderr, "fatal error: ");
26
27 va_start(ap, fmt);
28 vfprintf(stderr, fmt, ap);
29 va_end(ap);
30
31 fprintf(stderr, "\n");
32 exit(1);
33}
83680571 34
35/* ----------------------------------------------------------------------
36 * GTK front end to puzzles.
37 */
38
4efb3868 39struct font {
40 GdkFont *font;
41 int type;
42 int size;
43};
44
83680571 45/*
46 * This structure holds all the data relevant to a single window.
47 * In principle this would allow us to open multiple independent
48 * puzzle windows, although I can't currently see any real point in
49 * doing so. I'm just coding cleanly because there's no
50 * particularly good reason not to.
51 */
2ef96bd6 52struct frontend {
83680571 53 GtkWidget *window;
7f77ea24 54 GtkWidget *area;
fd1a1a2b 55 GtkWidget *statusbar;
56 guint statusctx;
2ef96bd6 57 GdkPixmap *pixmap;
58 GdkColor *colours;
59 int ncolours;
60 GdkColormap *colmap;
61 int w, h;
7f77ea24 62 midend_data *me;
2ef96bd6 63 GdkGC *gc;
64 int bbox_l, bbox_r, bbox_u, bbox_d;
20ee89e3 65 int timer_active, timer_id;
4efb3868 66 struct font *fonts;
67 int nfonts, fontsize;
c8230524 68 config_item *cfg;
5928817c 69 int cfg_which, cfgret;
c8230524 70 GtkWidget *cfgbox;
83680571 71};
72
2ef96bd6 73void frontend_default_colour(frontend *fe, float *output)
74{
75 GdkColor col = fe->window->style->bg[GTK_STATE_NORMAL];
76 output[0] = col.red / 65535.0;
77 output[1] = col.green / 65535.0;
78 output[2] = col.blue / 65535.0;
79}
80
fd1a1a2b 81void status_bar(frontend *fe, char *text)
82{
83 assert(fe->statusbar);
84
85 gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx);
86 gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, text);
87}
88
2ef96bd6 89void start_draw(frontend *fe)
90{
91 fe->gc = gdk_gc_new(fe->area->window);
92 fe->bbox_l = fe->w;
93 fe->bbox_r = 0;
94 fe->bbox_u = fe->h;
95 fe->bbox_d = 0;
96}
97
4efb3868 98void clip(frontend *fe, int x, int y, int w, int h)
99{
100 GdkRectangle rect;
101
102 rect.x = x;
103 rect.y = y;
104 rect.width = w;
105 rect.height = h;
106
107 gdk_gc_set_clip_rectangle(fe->gc, &rect);
108}
109
110void unclip(frontend *fe)
111{
112 GdkRectangle rect;
113
114 rect.x = 0;
115 rect.y = 0;
116 rect.width = fe->w;
117 rect.height = fe->h;
118
119 gdk_gc_set_clip_rectangle(fe->gc, &rect);
120}
121
122void draw_text(frontend *fe, int x, int y, int fonttype, int fontsize,
123 int align, int colour, char *text)
124{
125 int i;
126
127 /*
128 * Find or create the font.
129 */
130 for (i = 0; i < fe->nfonts; i++)
131 if (fe->fonts[i].type == fonttype && fe->fonts[i].size == fontsize)
132 break;
133
134 if (i == fe->nfonts) {
135 if (fe->fontsize <= fe->nfonts) {
136 fe->fontsize = fe->nfonts + 10;
137 fe->fonts = sresize(fe->fonts, fe->fontsize, struct font);
138 }
139
140 fe->nfonts++;
141
142 fe->fonts[i].type = fonttype;
143 fe->fonts[i].size = fontsize;
144
145 /*
146 * FIXME: Really I should make at least _some_ effort to
147 * pick the correct font.
148 */
149 fe->fonts[i].font = gdk_font_load("variable");
150 }
151
152 /*
153 * Find string dimensions and process alignment.
154 */
155 {
156 int lb, rb, wid, asc, desc;
157
158 gdk_string_extents(fe->fonts[i].font, text,
159 &lb, &rb, &wid, &asc, &desc);
160 if (align & ALIGN_VCENTRE)
161 y += asc - (asc+desc)/2;
162
163 if (align & ALIGN_HCENTRE)
164 x -= wid / 2;
165 else if (align & ALIGN_HRIGHT)
166 x -= wid;
167
168 }
169
170 /*
171 * Set colour and actually draw text.
172 */
173 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
174 gdk_draw_string(fe->pixmap, fe->fonts[i].font, fe->gc, x, y, text);
175}
176
2ef96bd6 177void draw_rect(frontend *fe, int x, int y, int w, int h, int colour)
178{
179 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
180 gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h);
181}
182
183void draw_line(frontend *fe, int x1, int y1, int x2, int y2, int colour)
184{
185 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
186 gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2);
187}
188
189void draw_polygon(frontend *fe, int *coords, int npoints,
190 int fill, int colour)
191{
192 GdkPoint *points = snewn(npoints, GdkPoint);
193 int i;
194
195 for (i = 0; i < npoints; i++) {
196 points[i].x = coords[i*2];
197 points[i].y = coords[i*2+1];
198 }
199
200 gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
201 gdk_draw_polygon(fe->pixmap, fe->gc, fill, points, npoints);
202
203 sfree(points);
204}
205
206void draw_update(frontend *fe, int x, int y, int w, int h)
207{
208 if (fe->bbox_l > x ) fe->bbox_l = x ;
209 if (fe->bbox_r < x+w) fe->bbox_r = x+w;
210 if (fe->bbox_u > y ) fe->bbox_u = y ;
211 if (fe->bbox_d < y+h) fe->bbox_d = y+h;
212}
213
214void end_draw(frontend *fe)
215{
216 gdk_gc_unref(fe->gc);
217 fe->gc = NULL;
218
219 if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d) {
220 gdk_draw_pixmap(fe->area->window,
221 fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)],
222 fe->pixmap,
223 fe->bbox_l, fe->bbox_u,
224 fe->bbox_l, fe->bbox_u,
225 fe->bbox_r - fe->bbox_l, fe->bbox_d - fe->bbox_u);
226 }
227}
228
83680571 229static void destroy(GtkWidget *widget, gpointer data)
230{
231 gtk_main_quit();
232}
233
2ef96bd6 234static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
7f77ea24 235{
2ef96bd6 236 frontend *fe = (frontend *)data;
1482ee76 237 int keyval;
7f77ea24 238
2ef96bd6 239 if (!fe->pixmap)
240 return TRUE;
7f77ea24 241
1482ee76 242 if (event->string[0] && !event->string[1])
243 keyval = (unsigned char)event->string[0];
c71454c0 244 else if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up ||
245 event->keyval == GDK_KP_8)
1482ee76 246 keyval = CURSOR_UP;
c71454c0 247 else if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down ||
248 event->keyval == GDK_KP_2)
1482ee76 249 keyval = CURSOR_DOWN;
c71454c0 250 else if (event->keyval == GDK_Left || event->keyval == GDK_KP_Left ||
251 event->keyval == GDK_KP_4)
1482ee76 252 keyval = CURSOR_LEFT;
c71454c0 253 else if (event->keyval == GDK_Right || event->keyval == GDK_KP_Right ||
254 event->keyval == GDK_KP_6)
1482ee76 255 keyval = CURSOR_RIGHT;
c71454c0 256 else if (event->keyval == GDK_KP_Home || event->keyval == GDK_KP_7)
257 keyval = CURSOR_UP_LEFT;
258 else if (event->keyval == GDK_KP_End || event->keyval == GDK_KP_1)
259 keyval = CURSOR_DOWN_LEFT;
260 else if (event->keyval == GDK_KP_Page_Up || event->keyval == GDK_KP_9)
261 keyval = CURSOR_UP_RIGHT;
262 else if (event->keyval == GDK_KP_Page_Down || event->keyval == GDK_KP_3)
263 keyval = CURSOR_DOWN_RIGHT;
1482ee76 264 else
265 keyval = -1;
266
267 if (keyval >= 0 &&
268 !midend_process_key(fe->me, 0, 0, keyval))
2ef96bd6 269 gtk_widget_destroy(fe->window);
7f77ea24 270
271 return TRUE;
272}
273
2ef96bd6 274static gint button_event(GtkWidget *widget, GdkEventButton *event,
275 gpointer data)
7f77ea24 276{
2ef96bd6 277 frontend *fe = (frontend *)data;
278 int button;
279
280 if (!fe->pixmap)
281 return TRUE;
282
283 if (event->type != GDK_BUTTON_PRESS)
284 return TRUE;
7f77ea24 285
b0f06719 286 if (event->button == 2 || (event->state & GDK_SHIFT_MASK))
2ef96bd6 287 button = MIDDLE_BUTTON;
b0f06719 288 else if (event->button == 1)
289 button = LEFT_BUTTON;
2ef96bd6 290 else if (event->button == 3)
291 button = RIGHT_BUTTON;
292 else
293 return FALSE; /* don't even know what button! */
294
295 if (!midend_process_key(fe->me, event->x, event->y, button))
296 gtk_widget_destroy(fe->window);
7f77ea24 297
298 return TRUE;
299}
300
2ef96bd6 301static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
302 gpointer data)
83680571 303{
2ef96bd6 304 frontend *fe = (frontend *)data;
305
306 if (fe->pixmap) {
307 gdk_draw_pixmap(widget->window,
308 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
309 fe->pixmap,
310 event->area.x, event->area.y,
311 event->area.x, event->area.y,
312 event->area.width, event->area.height);
313 }
314 return TRUE;
315}
316
fd1a1a2b 317static gint map_window(GtkWidget *widget, GdkEvent *event,
318 gpointer data)
319{
320 frontend *fe = (frontend *)data;
321
322 /*
323 * Apparently we need to do this because otherwise the status
324 * bar will fail to update immediately. Annoying, but there we
325 * go.
326 */
327 gtk_widget_queue_draw(fe->window);
328
329 return TRUE;
330}
331
2ef96bd6 332static gint configure_area(GtkWidget *widget,
333 GdkEventConfigure *event, gpointer data)
334{
335 frontend *fe = (frontend *)data;
336 GdkGC *gc;
337
eb2ad6f1 338 if (fe->pixmap)
339 gdk_pixmap_unref(fe->pixmap);
340
2ef96bd6 341 fe->pixmap = gdk_pixmap_new(widget->window, fe->w, fe->h, -1);
342
343 gc = gdk_gc_new(fe->area->window);
344 gdk_gc_set_foreground(gc, &fe->colours[0]);
345 gdk_draw_rectangle(fe->pixmap, gc, 1, 0, 0, fe->w, fe->h);
346 gdk_gc_unref(gc);
347
348 midend_redraw(fe->me);
349
350 return TRUE;
351}
352
353static gint timer_func(gpointer data)
354{
355 frontend *fe = (frontend *)data;
356
357 if (fe->timer_active)
358 midend_timer(fe->me, 0.02); /* may clear timer_active */
359
360 return fe->timer_active;
361}
362
363void deactivate_timer(frontend *fe)
364{
20ee89e3 365 if (fe->timer_active)
366 gtk_timeout_remove(fe->timer_id);
2ef96bd6 367 fe->timer_active = FALSE;
368}
369
370void activate_timer(frontend *fe)
371{
20ee89e3 372 if (!fe->timer_active)
373 fe->timer_id = gtk_timeout_add(20, timer_func, fe);
2ef96bd6 374 fe->timer_active = TRUE;
375}
376
c8230524 377static void window_destroy(GtkWidget *widget, gpointer data)
378{
379 gtk_main_quit();
380}
381
382static void errmsg_button_clicked(GtkButton *button, gpointer data)
383{
384 gtk_widget_destroy(GTK_WIDGET(data));
385}
386
a163b7c2 387static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
388{
389 GtkObject *cancelbutton = GTK_OBJECT(data);
390
391 /*
392 * `Escape' effectively clicks the cancel button
393 */
394 if (event->keyval == GDK_Escape) {
395 gtk_signal_emit_by_name(GTK_OBJECT(cancelbutton), "clicked");
396 return TRUE;
397 }
398
399 return FALSE;
400}
401
c8230524 402void error_box(GtkWidget *parent, char *msg)
403{
404 GtkWidget *window, *hbox, *text, *ok;
405
406 window = gtk_dialog_new();
407 text = gtk_label_new(msg);
408 gtk_misc_set_alignment(GTK_MISC(text), 0.0, 0.0);
409 hbox = gtk_hbox_new(FALSE, 0);
410 gtk_box_pack_start(GTK_BOX(hbox), text, FALSE, FALSE, 20);
411 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox),
412 hbox, FALSE, FALSE, 20);
413 gtk_widget_show(text);
414 gtk_widget_show(hbox);
415 gtk_window_set_title(GTK_WINDOW(window), "Error");
416 gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
417 ok = gtk_button_new_with_label("OK");
418 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(window)->action_area),
419 ok, FALSE, FALSE, 0);
420 gtk_widget_show(ok);
421 GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
422 gtk_window_set_default(GTK_WINDOW(window), ok);
423 gtk_signal_connect(GTK_OBJECT(ok), "clicked",
424 GTK_SIGNAL_FUNC(errmsg_button_clicked), window);
a163b7c2 425 gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
426 GTK_SIGNAL_FUNC(win_key_press), ok);
c8230524 427 gtk_window_set_modal(GTK_WINDOW(window), TRUE);
428 gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(parent));
429 //set_transient_window_pos(parent, window);
430 gtk_widget_show(window);
431 gtk_main();
432}
433
434static void config_ok_button_clicked(GtkButton *button, gpointer data)
435{
436 frontend *fe = (frontend *)data;
437 char *err;
438
5928817c 439 err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
c8230524 440
441 if (err)
442 error_box(fe->cfgbox, err);
443 else {
444 fe->cfgret = TRUE;
445 gtk_widget_destroy(fe->cfgbox);
446 }
447}
448
449static void config_cancel_button_clicked(GtkButton *button, gpointer data)
450{
451 frontend *fe = (frontend *)data;
452
453 gtk_widget_destroy(fe->cfgbox);
454}
455
a163b7c2 456static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data)
457{
458 /*
459 * GtkEntry has a nasty habit of eating the Return key, which
460 * is unhelpful since it doesn't actually _do_ anything with it
461 * (it calls gtk_widget_activate, but our edit boxes never need
462 * activating). So I catch Return before GtkEntry sees it, and
463 * pass it straight on to the parent widget. Effect: hitting
464 * Return in an edit box will now activate the default button
465 * in the dialog just like it will everywhere else.
466 */
467 if (event->keyval == GDK_Return && widget->parent != NULL) {
468 gint return_val;
469 gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key_press_event");
470 gtk_signal_emit_by_name(GTK_OBJECT(widget->parent), "key_press_event",
471 event, &return_val);
472 return return_val;
473 }
474 return FALSE;
475}
476
c8230524 477static void editbox_changed(GtkEditable *ed, gpointer data)
478{
479 config_item *i = (config_item *)data;
480
481 sfree(i->sval);
482 i->sval = dupstr(gtk_entry_get_text(GTK_ENTRY(ed)));
483}
484
485static void button_toggled(GtkToggleButton *tb, gpointer data)
486{
487 config_item *i = (config_item *)data;
488
489 i->ival = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb));
490}
491
492static void droplist_sel(GtkMenuItem *item, gpointer data)
493{
494 config_item *i = (config_item *)data;
495
496 i->ival = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),
497 "user-data"));
498}
499
5928817c 500static int get_config(frontend *fe, int which)
c8230524 501{
a163b7c2 502 GtkWidget *w, *table, *cancel;
5928817c 503 char *title;
c8230524 504 config_item *i;
505 int y;
506
5928817c 507 fe->cfg = midend_get_config(fe->me, which, &title);
508 fe->cfg_which = which;
c8230524 509 fe->cfgret = FALSE;
510
511 fe->cfgbox = gtk_dialog_new();
5928817c 512 gtk_window_set_title(GTK_WINDOW(fe->cfgbox), title);
513 sfree(title);
c8230524 514
515 w = gtk_button_new_with_label("OK");
516 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area),
517 w, FALSE, FALSE, 0);
518 gtk_widget_show(w);
519 GTK_WIDGET_SET_FLAGS(w, GTK_CAN_DEFAULT);
520 gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w);
521 gtk_signal_connect(GTK_OBJECT(w), "clicked",
522 GTK_SIGNAL_FUNC(config_ok_button_clicked), fe);
523
524 w = gtk_button_new_with_label("Cancel");
525 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area),
526 w, FALSE, FALSE, 0);
527 gtk_widget_show(w);
528 gtk_signal_connect(GTK_OBJECT(w), "clicked",
529 GTK_SIGNAL_FUNC(config_cancel_button_clicked), fe);
a163b7c2 530 cancel = w;
c8230524 531
532 table = gtk_table_new(1, 2, FALSE);
533 y = 0;
534 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->vbox),
535 table, FALSE, FALSE, 0);
536 gtk_widget_show(table);
537
95709966 538 for (i = fe->cfg; i->type != C_END; i++) {
c8230524 539 gtk_table_resize(GTK_TABLE(table), y+1, 2);
540
541 switch (i->type) {
95709966 542 case C_STRING:
c8230524 543 /*
544 * Edit box with a label beside it.
545 */
546
547 w = gtk_label_new(i->name);
548 gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
549 gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
550 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
551 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
552 3, 3);
553 gtk_widget_show(w);
554
555 w = gtk_entry_new();
556 gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
557 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
558 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
559 3, 3);
560 gtk_entry_set_text(GTK_ENTRY(w), i->sval);
561 gtk_signal_connect(GTK_OBJECT(w), "changed",
562 GTK_SIGNAL_FUNC(editbox_changed), i);
a163b7c2 563 gtk_signal_connect(GTK_OBJECT(w), "key_press_event",
564 GTK_SIGNAL_FUNC(editbox_key), NULL);
c8230524 565 gtk_widget_show(w);
566
567 break;
568
95709966 569 case C_BOOLEAN:
c8230524 570 /*
571 * Simple checkbox.
572 */
573 w = gtk_check_button_new_with_label(i->name);
574 gtk_signal_connect(GTK_OBJECT(w), "toggled",
575 GTK_SIGNAL_FUNC(button_toggled), i);
576 gtk_table_attach(GTK_TABLE(table), w, 0, 2, y, y+1,
577 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
578 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
579 3, 3);
580 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), i->ival);
581 gtk_widget_show(w);
582 break;
583
95709966 584 case C_CHOICES:
c8230524 585 /*
586 * Drop-down list (GtkOptionMenu).
587 */
588
589 w = gtk_label_new(i->name);
590 gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
591 gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
592 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
593 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
594 3, 3);
595 gtk_widget_show(w);
596
597 w = gtk_option_menu_new();
598 gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
599 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
600 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
601 3, 3);
602 gtk_widget_show(w);
603
604 {
605 int c, val;
606 char *p, *q, *name;
607 GtkWidget *menuitem;
608 GtkWidget *menu = gtk_menu_new();
609
610 gtk_option_menu_set_menu(GTK_OPTION_MENU(w), menu);
611
612 c = *i->sval;
613 p = i->sval+1;
614 val = 0;
615
616 while (*p) {
617 q = p;
618 while (*q && *q != c)
619 q++;
620
621 name = snewn(q-p+1, char);
622 strncpy(name, p, q-p);
623 name[q-p] = '\0';
624
625 if (*q) q++; /* eat delimiter */
626
627 menuitem = gtk_menu_item_new_with_label(name);
628 gtk_container_add(GTK_CONTAINER(menu), menuitem);
629 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
630 GINT_TO_POINTER(val));
631 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
632 GTK_SIGNAL_FUNC(droplist_sel), i);
633 gtk_widget_show(menuitem);
634
635 val++;
636
637 p = q;
638 }
639
640 gtk_option_menu_set_history(GTK_OPTION_MENU(w), i->ival);
641 }
642
643 break;
644 }
645
646 y++;
647 }
648
649 gtk_signal_connect(GTK_OBJECT(fe->cfgbox), "destroy",
650 GTK_SIGNAL_FUNC(window_destroy), NULL);
a163b7c2 651 gtk_signal_connect(GTK_OBJECT(fe->cfgbox), "key_press_event",
652 GTK_SIGNAL_FUNC(win_key_press), cancel);
c8230524 653 gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), TRUE);
654 gtk_window_set_transient_for(GTK_WINDOW(fe->cfgbox),
655 GTK_WINDOW(fe->window));
656 //set_transient_window_pos(fe->window, fe->cfgbox);
657 gtk_widget_show(fe->cfgbox);
658 gtk_main();
659
077f3cbe 660 free_cfg(fe->cfg);
c8230524 661
662 return fe->cfgret;
663}
664
eb2ad6f1 665static void menu_key_event(GtkMenuItem *menuitem, gpointer data)
666{
667 frontend *fe = (frontend *)data;
668 int key = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
669 "user-data"));
670 if (!midend_process_key(fe->me, 0, 0, key))
671 gtk_widget_destroy(fe->window);
672}
673
674static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
675{
676 frontend *fe = (frontend *)data;
677 game_params *params =
678 (game_params *)gtk_object_get_data(GTK_OBJECT(menuitem), "user-data");
679 int x, y;
680
681 midend_set_params(fe->me, params);
5928817c 682 midend_new_game(fe->me);
eb2ad6f1 683 midend_size(fe->me, &x, &y);
684 gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
685 fe->w = x;
686 fe->h = y;
687}
688
c8230524 689static void menu_config_event(GtkMenuItem *menuitem, gpointer data)
690{
691 frontend *fe = (frontend *)data;
5928817c 692 int which = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
693 "user-data"));
c8230524 694 int x, y;
695
5928817c 696 if (!get_config(fe, which))
c8230524 697 return;
698
5928817c 699 midend_new_game(fe->me);
c8230524 700 midend_size(fe->me, &x, &y);
701 gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
702 fe->w = x;
703 fe->h = y;
704}
705
eb2ad6f1 706static GtkWidget *add_menu_item_with_key(frontend *fe, GtkContainer *cont,
707 char *text, int key)
708{
709 GtkWidget *menuitem = gtk_menu_item_new_with_label(text);
710 gtk_container_add(cont, menuitem);
711 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
712 GINT_TO_POINTER(key));
713 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
714 GTK_SIGNAL_FUNC(menu_key_event), fe);
715 gtk_widget_show(menuitem);
716 return menuitem;
717}
718
719static void add_menu_separator(GtkContainer *cont)
720{
721 GtkWidget *menuitem = gtk_menu_item_new();
722 gtk_container_add(cont, menuitem);
723 gtk_widget_show(menuitem);
724}
725
2ef96bd6 726static frontend *new_window(void)
727{
728 frontend *fe;
eb2ad6f1 729 GtkBox *vbox;
730 GtkWidget *menubar, *menu, *menuitem;
731 int x, y, n;
48d70ca9 732 time_t t;
83680571 733
2ef96bd6 734 fe = snew(frontend);
83680571 735
48d70ca9 736 time(&t);
737 fe->me = midend_new(fe, &t, sizeof(t));
5928817c 738 midend_new_game(fe->me);
7f77ea24 739
2ef96bd6 740 fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
0c490335 741 gtk_window_set_title(GTK_WINDOW(fe->window), game_name);
ff2f787b 742#if 0
743 gtk_window_set_resizable(GTK_WINDOW(fe->window), FALSE);
744#else
745 gtk_window_set_policy(GTK_WINDOW(fe->window), FALSE, FALSE, TRUE);
746#endif
eb2ad6f1 747 vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
748 gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
749 gtk_widget_show(GTK_WIDGET(vbox));
750
751 menubar = gtk_menu_bar_new();
752 gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
753 gtk_widget_show(menubar);
754
755 menuitem = gtk_menu_item_new_with_label("Game");
756 gtk_container_add(GTK_CONTAINER(menubar), menuitem);
757 gtk_widget_show(menuitem);
758
759 menu = gtk_menu_new();
760 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
761
762 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "New", 'n');
763 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Restart", 'r');
764
5928817c 765 menuitem = gtk_menu_item_new_with_label("Specific...");
766 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
767 GINT_TO_POINTER(CFG_SEED));
768 gtk_container_add(GTK_CONTAINER(menu), menuitem);
769 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
770 GTK_SIGNAL_FUNC(menu_config_event), fe);
771 gtk_widget_show(menuitem);
772
c8230524 773 if ((n = midend_num_presets(fe->me)) > 0 || game_can_configure) {
eb2ad6f1 774 GtkWidget *submenu;
775 int i;
776
777 menuitem = gtk_menu_item_new_with_label("Type");
c8230524 778 gtk_container_add(GTK_CONTAINER(menubar), menuitem);
eb2ad6f1 779 gtk_widget_show(menuitem);
780
781 submenu = gtk_menu_new();
782 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
783
784 for (i = 0; i < n; i++) {
785 char *name;
786 game_params *params;
787
788 midend_fetch_preset(fe->me, i, &name, &params);
789
790 menuitem = gtk_menu_item_new_with_label(name);
791 gtk_container_add(GTK_CONTAINER(submenu), menuitem);
792 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data", params);
793 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
794 GTK_SIGNAL_FUNC(menu_preset_event), fe);
795 gtk_widget_show(menuitem);
796 }
c8230524 797
798 if (game_can_configure) {
799 menuitem = gtk_menu_item_new_with_label("Custom...");
5928817c 800 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
801 GPOINTER_TO_INT(CFG_SETTINGS));
c8230524 802 gtk_container_add(GTK_CONTAINER(submenu), menuitem);
803 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
804 GTK_SIGNAL_FUNC(menu_config_event), fe);
805 gtk_widget_show(menuitem);
806 }
eb2ad6f1 807 }
808
809 add_menu_separator(GTK_CONTAINER(menu));
810 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Undo", 'u');
811 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Redo", '\x12');
812 add_menu_separator(GTK_CONTAINER(menu));
813 add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Exit", 'q');
7f77ea24 814
2ef96bd6 815 {
816 int i, ncolours;
817 float *colours;
818 gboolean *success;
7f77ea24 819
2ef96bd6 820 fe->colmap = gdk_colormap_get_system();
821 colours = midend_colours(fe->me, &ncolours);
822 fe->ncolours = ncolours;
823 fe->colours = snewn(ncolours, GdkColor);
824 for (i = 0; i < ncolours; i++) {
825 fe->colours[i].red = colours[i*3] * 0xFFFF;
826 fe->colours[i].green = colours[i*3+1] * 0xFFFF;
827 fe->colours[i].blue = colours[i*3+2] * 0xFFFF;
828 }
829 success = snewn(ncolours, gboolean);
830 gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours,
831 FALSE, FALSE, success);
832 for (i = 0; i < ncolours; i++) {
833 if (!success[i])
834 g_error("couldn't allocate colour %d (#%02x%02x%02x)\n",
835 i, fe->colours[i].red >> 8,
836 fe->colours[i].green >> 8,
837 fe->colours[i].blue >> 8);
838 }
839 }
7f77ea24 840
fd1a1a2b 841 if (midend_wants_statusbar(fe->me)) {
5725d728 842 GtkWidget *viewport;
843 GtkRequisition req;
844
845 viewport = gtk_viewport_new(NULL, NULL);
846 gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
fd1a1a2b 847 fe->statusbar = gtk_statusbar_new();
5725d728 848 gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar);
849 gtk_widget_show(viewport);
850 gtk_box_pack_end(vbox, viewport, FALSE, FALSE, 0);
fd1a1a2b 851 gtk_widget_show(fe->statusbar);
852 fe->statusctx = gtk_statusbar_get_context_id
853 (GTK_STATUSBAR(fe->statusbar), "game");
854 gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx,
5725d728 855 "test");
856 gtk_widget_size_request(fe->statusbar, &req);
857#if 0
858 /* For GTK 2.0, should we be using gtk_widget_set_size_request? */
859#endif
860 gtk_widget_set_usize(viewport, x, req.height);
fd1a1a2b 861 } else
862 fe->statusbar = NULL;
863
2ef96bd6 864 fe->area = gtk_drawing_area_new();
865 midend_size(fe->me, &x, &y);
866 gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
867 fe->w = x;
868 fe->h = y;
869
eb2ad6f1 870 gtk_box_pack_end(vbox, fe->area, FALSE, FALSE, 0);
2ef96bd6 871
872 fe->pixmap = NULL;
4efb3868 873 fe->fonts = NULL;
874 fe->nfonts = fe->fontsize = 0;
2ef96bd6 875
20ee89e3 876 fe->timer_active = FALSE;
877
2ef96bd6 878 gtk_signal_connect(GTK_OBJECT(fe->window), "destroy",
879 GTK_SIGNAL_FUNC(destroy), fe);
880 gtk_signal_connect(GTK_OBJECT(fe->window), "key_press_event",
881 GTK_SIGNAL_FUNC(key_event), fe);
882 gtk_signal_connect(GTK_OBJECT(fe->area), "button_press_event",
883 GTK_SIGNAL_FUNC(button_event), fe);
884 gtk_signal_connect(GTK_OBJECT(fe->area), "expose_event",
885 GTK_SIGNAL_FUNC(expose_area), fe);
fd1a1a2b 886 gtk_signal_connect(GTK_OBJECT(fe->window), "map_event",
887 GTK_SIGNAL_FUNC(map_window), fe);
2ef96bd6 888 gtk_signal_connect(GTK_OBJECT(fe->area), "configure_event",
889 GTK_SIGNAL_FUNC(configure_area), fe);
890
891 gtk_widget_add_events(GTK_WIDGET(fe->area), GDK_BUTTON_PRESS_MASK);
892
893 gtk_widget_show(fe->area);
894 gtk_widget_show(fe->window);
895
896 return fe;
83680571 897}
898
899int main(int argc, char **argv)
900{
901 gtk_init(&argc, &argv);
902 (void) new_window();
903 gtk_main();
904
905 return 0;
906}
Simon Tatham's portable puzzles collection; import of svn://svn.tartarus.org/sgt/puzzles