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 <gtk/gtk.h>
  13 #include <gdk/gdkkeysyms.h>
  14
  15 #include "puzzles.h"
  16
  17 /* ----------------------------------------------------------------------
  18  * Error reporting functions used elsewhere.
  19  */
  20
  21 void 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 }
  34
  35 /* ----------------------------------------------------------------------
  36  * GTK front end to puzzles.
  37  */
  38
  39 struct font {
  40     GdkFont *font;
  41     int type;
  42     int size;
  43 };
  44
  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  */
  52 struct frontend {
  53     GtkWidget *window;
  54     GtkWidget *area;
  55     GtkWidget *statusbar;
  56     guint statusctx;
  57     GdkPixmap *pixmap;
  58     GdkColor *colours;
  59     int ncolours;
  60     GdkColormap *colmap;
  61     int w, h;
  62     midend_data *me;
  63     GdkGC *gc;
  64     int bbox_l, bbox_r, bbox_u, bbox_d;
  65     int timer_active, timer_id;
  66     struct font *fonts;
  67     int nfonts, fontsize;
  68     config_item *cfg;
  69     int cfg_which, cfgret;
  70     GtkWidget *cfgbox;
  71 };
  72
  73 void 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
  81 void 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
  89 void 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
  98 void 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
 110 void 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
 122 void 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
 177 void 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
 183 void 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
 189 void 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
 206 void 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
 214 void 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
 229 static void destroy(GtkWidget *widget, gpointer data)
 230 {
 231     gtk_main_quit();
 232 }
 233
 234 static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 235 {
 236     frontend *fe = (frontend *)data;
 237     int keyval;
 238
 239     if (!fe->pixmap)
 240         return TRUE;
 241
 242     if (event->string[0] && !event->string[1])
 243         keyval = (unsigned char)event->string[0];
 244     else if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up ||
 245              event->keyval == GDK_KP_8)
 246         keyval = CURSOR_UP;
 247     else if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down ||
 248              event->keyval == GDK_KP_2)
 249         keyval = CURSOR_DOWN;
 250     else if (event->keyval == GDK_Left || event->keyval == GDK_KP_Left ||
 251              event->keyval == GDK_KP_4)
 252         keyval = CURSOR_LEFT;
 253     else if (event->keyval == GDK_Right || event->keyval == GDK_KP_Right ||
 254              event->keyval == GDK_KP_6)
 255         keyval = CURSOR_RIGHT;
 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;
 264     else
 265         keyval = -1;
 266
 267     if (keyval >= 0 &&
 268         !midend_process_key(fe->me, 0, 0, keyval))
 269         gtk_widget_destroy(fe->window);
 270
 271     return TRUE;
 272 }
 273
 274 static gint button_event(GtkWidget *widget, GdkEventButton *event,
 275                          gpointer data)
 276 {
 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;
 285
 286     if (event->button == 2 || (event->state & GDK_SHIFT_MASK))
 287         button = MIDDLE_BUTTON;
 288     else if (event->button == 1)
 289         button = LEFT_BUTTON;
 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);
 297
 298     return TRUE;
 299 }
 300
 301 static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
 302                         gpointer data)
 303 {
 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
 317 static 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
 332 static gint configure_area(GtkWidget *widget,
 333                            GdkEventConfigure *event, gpointer data)
 334 {
 335     frontend *fe = (frontend *)data;
 336     GdkGC *gc;
 337
 338     if (fe->pixmap)
 339         gdk_pixmap_unref(fe->pixmap);
 340
 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
 353 static 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
 363 void deactivate_timer(frontend *fe)
 364 {
 365     if (fe->timer_active)
 366         gtk_timeout_remove(fe->timer_id);
 367     fe->timer_active = FALSE;
 368 }
 369
 370 void activate_timer(frontend *fe)
 371 {
 372     if (!fe->timer_active)
 373         fe->timer_id = gtk_timeout_add(20, timer_func, fe);
 374     fe->timer_active = TRUE;
 375 }
 376
 377 static void window_destroy(GtkWidget *widget, gpointer data)
 378 {
 379     gtk_main_quit();
 380 }
 381
 382 static void errmsg_button_clicked(GtkButton *button, gpointer data)
 383 {
 384     gtk_widget_destroy(GTK_WIDGET(data));
 385 }
 386
 387 void error_box(GtkWidget *parent, char *msg)
 388 {
 389     GtkWidget *window, *hbox, *text, *ok;
 390
 391     window = gtk_dialog_new();
 392     text = gtk_label_new(msg);
 393     gtk_misc_set_alignment(GTK_MISC(text), 0.0, 0.0);
 394     hbox = gtk_hbox_new(FALSE, 0);
 395     gtk_box_pack_start(GTK_BOX(hbox), text, FALSE, FALSE, 20);
 396     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox),
 397                        hbox, FALSE, FALSE, 20);
 398     gtk_widget_show(text);
 399     gtk_widget_show(hbox);
 400     gtk_window_set_title(GTK_WINDOW(window), "Error");
 401     gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
 402     ok = gtk_button_new_with_label("OK");
 403     gtk_box_pack_end(GTK_BOX(GTK_DIALOG(window)->action_area),
 404                      ok, FALSE, FALSE, 0);
 405     gtk_widget_show(ok);
 406     GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
 407     gtk_window_set_default(GTK_WINDOW(window), ok);
 408     gtk_signal_connect(GTK_OBJECT(ok), "clicked",
 409                        GTK_SIGNAL_FUNC(errmsg_button_clicked), window);
 410     gtk_signal_connect(GTK_OBJECT(window), "destroy",
 411                        GTK_SIGNAL_FUNC(window_destroy), NULL);
 412     gtk_window_set_modal(GTK_WINDOW(window), TRUE);
 413     gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(parent));
 414     //set_transient_window_pos(parent, window);
 415     gtk_widget_show(window);
 416     gtk_main();
 417 }
 418
 419 static void config_ok_button_clicked(GtkButton *button, gpointer data)
 420 {
 421     frontend *fe = (frontend *)data;
 422     char *err;
 423
 424     err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
 425
 426     if (err)
 427         error_box(fe->cfgbox, err);
 428     else {
 429         fe->cfgret = TRUE;
 430         gtk_widget_destroy(fe->cfgbox);
 431     }
 432 }
 433
 434 static void config_cancel_button_clicked(GtkButton *button, gpointer data)
 435 {
 436     frontend *fe = (frontend *)data;
 437
 438     gtk_widget_destroy(fe->cfgbox);
 439 }
 440
 441 static void editbox_changed(GtkEditable *ed, gpointer data)
 442 {
 443     config_item *i = (config_item *)data;
 444
 445     sfree(i->sval);
 446     i->sval = dupstr(gtk_entry_get_text(GTK_ENTRY(ed)));
 447 }
 448
 449 static void button_toggled(GtkToggleButton *tb, gpointer data)
 450 {
 451     config_item *i = (config_item *)data;
 452
 453     i->ival = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb));
 454 }
 455
 456 static void droplist_sel(GtkMenuItem *item, gpointer data)
 457 {
 458     config_item *i = (config_item *)data;
 459
 460     i->ival = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),
 461                                                   "user-data"));
 462 }
 463
 464 static int get_config(frontend *fe, int which)
 465 {
 466     GtkWidget *w, *table;
 467     char *title;
 468     config_item *i;
 469     int y;
 470
 471     fe->cfg = midend_get_config(fe->me, which, &title);
 472     fe->cfg_which = which;
 473     fe->cfgret = FALSE;
 474
 475     fe->cfgbox = gtk_dialog_new();
 476     gtk_window_set_title(GTK_WINDOW(fe->cfgbox), title);
 477     sfree(title);
 478
 479     w = gtk_button_new_with_label("OK");
 480     gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area),
 481                      w, FALSE, FALSE, 0);
 482     gtk_widget_show(w);
 483     GTK_WIDGET_SET_FLAGS(w, GTK_CAN_DEFAULT);
 484     gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w);
 485     gtk_signal_connect(GTK_OBJECT(w), "clicked",
 486                        GTK_SIGNAL_FUNC(config_ok_button_clicked), fe);
 487
 488     w = gtk_button_new_with_label("Cancel");
 489     gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area),
 490                      w, FALSE, FALSE, 0);
 491     gtk_widget_show(w);
 492     gtk_signal_connect(GTK_OBJECT(w), "clicked",
 493                        GTK_SIGNAL_FUNC(config_cancel_button_clicked), fe);
 494
 495     table = gtk_table_new(1, 2, FALSE);
 496     y = 0;
 497     gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->vbox),
 498                      table, FALSE, FALSE, 0);
 499     gtk_widget_show(table);
 500
 501     for (i = fe->cfg; i->type != C_END; i++) {
 502         gtk_table_resize(GTK_TABLE(table), y+1, 2);
 503
 504         switch (i->type) {
 505           case C_STRING:
 506             /*
 507              * Edit box with a label beside it.
 508              */
 509
 510             w = gtk_label_new(i->name);
 511             gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
 512             gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
 513                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 514                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 515                              3, 3);
 516             gtk_widget_show(w);
 517
 518             w = gtk_entry_new();
 519             gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
 520                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 521                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 522                              3, 3);
 523             gtk_entry_set_text(GTK_ENTRY(w), i->sval);
 524             gtk_signal_connect(GTK_OBJECT(w), "changed",
 525                                GTK_SIGNAL_FUNC(editbox_changed), i);
 526             gtk_widget_show(w);
 527
 528             break;
 529
 530           case C_BOOLEAN:
 531             /*
 532              * Simple checkbox.
 533              */
 534             w = gtk_check_button_new_with_label(i->name);
 535             gtk_signal_connect(GTK_OBJECT(w), "toggled",
 536                                GTK_SIGNAL_FUNC(button_toggled), i);
 537             gtk_table_attach(GTK_TABLE(table), w, 0, 2, y, y+1,
 538                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 539                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 540                              3, 3);
 541             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), i->ival);
 542             gtk_widget_show(w);
 543             break;
 544
 545           case C_CHOICES:
 546             /*
 547              * Drop-down list (GtkOptionMenu).
 548              */
 549
 550             w = gtk_label_new(i->name);
 551             gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
 552             gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
 553                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 554                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 555                              3, 3);
 556             gtk_widget_show(w);
 557
 558             w = gtk_option_menu_new();
 559             gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
 560                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 561                              GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 562                              3, 3);
 563             gtk_widget_show(w);
 564
 565             {
 566                 int c, val;
 567                 char *p, *q, *name;
 568                 GtkWidget *menuitem;
 569                 GtkWidget *menu = gtk_menu_new();
 570
 571                 gtk_option_menu_set_menu(GTK_OPTION_MENU(w), menu);
 572
 573                 c = *i->sval;
 574                 p = i->sval+1;
 575                 val = 0;
 576
 577                 while (*p) {
 578                     q = p;
 579                     while (*q && *q != c)
 580                         q++;
 581
 582                     name = snewn(q-p+1, char);
 583                     strncpy(name, p, q-p);
 584                     name[q-p] = '\0';
 585
 586                     if (*q) q++;       /* eat delimiter */
 587
 588                     menuitem = gtk_menu_item_new_with_label(name);
 589                     gtk_container_add(GTK_CONTAINER(menu), menuitem);
 590                     gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
 591                                         GINT_TO_POINTER(val));
 592                     gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
 593                                        GTK_SIGNAL_FUNC(droplist_sel), i);
 594                     gtk_widget_show(menuitem);
 595
 596                     val++;
 597
 598                     p = q;
 599                 }
 600
 601                 gtk_option_menu_set_history(GTK_OPTION_MENU(w), i->ival);
 602             }
 603
 604             break;
 605         }
 606
 607         y++;
 608     }
 609
 610     gtk_signal_connect(GTK_OBJECT(fe->cfgbox), "destroy",
 611                        GTK_SIGNAL_FUNC(window_destroy), NULL);
 612     gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), TRUE);
 613     gtk_window_set_transient_for(GTK_WINDOW(fe->cfgbox),
 614                                  GTK_WINDOW(fe->window));
 615     //set_transient_window_pos(fe->window, fe->cfgbox);
 616     gtk_widget_show(fe->cfgbox);
 617     gtk_main();
 618
 619     free_cfg(fe->cfg);
 620
 621     return fe->cfgret;
 622 }
 623
 624 static void menu_key_event(GtkMenuItem *menuitem, gpointer data)
 625 {
 626     frontend *fe = (frontend *)data;
 627     int key = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
 628                                                   "user-data"));
 629     if (!midend_process_key(fe->me, 0, 0, key))
 630         gtk_widget_destroy(fe->window);
 631 }
 632
 633 static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
 634 {
 635     frontend *fe = (frontend *)data;
 636     game_params *params =
 637         (game_params *)gtk_object_get_data(GTK_OBJECT(menuitem), "user-data");
 638     int x, y;
 639
 640     midend_set_params(fe->me, params);
 641     midend_new_game(fe->me);
 642     midend_size(fe->me, &x, &y);
 643     gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
 644     fe->w = x;
 645     fe->h = y;
 646 }
 647
 648 static void menu_config_event(GtkMenuItem *menuitem, gpointer data)
 649 {
 650     frontend *fe = (frontend *)data;
 651     int which = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
 652                                                     "user-data"));
 653     int x, y;
 654
 655     if (!get_config(fe, which))
 656         return;
 657
 658     midend_new_game(fe->me);
 659     midend_size(fe->me, &x, &y);
 660     gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
 661     fe->w = x;
 662     fe->h = y;
 663 }
 664
 665 static GtkWidget *add_menu_item_with_key(frontend *fe, GtkContainer *cont,
 666                                          char *text, int key)
 667 {
 668     GtkWidget *menuitem = gtk_menu_item_new_with_label(text);
 669     gtk_container_add(cont, menuitem);
 670     gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
 671                         GINT_TO_POINTER(key));
 672     gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
 673                        GTK_SIGNAL_FUNC(menu_key_event), fe);
 674     gtk_widget_show(menuitem);
 675     return menuitem;
 676 }
 677
 678 static void add_menu_separator(GtkContainer *cont)
 679 {
 680     GtkWidget *menuitem = gtk_menu_item_new();
 681     gtk_container_add(cont, menuitem);
 682     gtk_widget_show(menuitem);
 683 }
 684
 685 static frontend *new_window(void)
 686 {
 687     frontend *fe;
 688     GtkBox *vbox;
 689     GtkWidget *menubar, *menu, *menuitem;
 690     int x, y, n;
 691
 692     fe = snew(frontend);
 693
 694     fe->me = midend_new(fe);
 695     midend_new_game(fe->me);
 696
 697     fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 698     gtk_window_set_title(GTK_WINDOW(fe->window), game_name);
 699 #if 0
 700     gtk_window_set_resizable(GTK_WINDOW(fe->window), FALSE);
 701 #else
 702     gtk_window_set_policy(GTK_WINDOW(fe->window), FALSE, FALSE, TRUE);
 703 #endif
 704     vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
 705     gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
 706     gtk_widget_show(GTK_WIDGET(vbox));
 707
 708     menubar = gtk_menu_bar_new();
 709     gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
 710     gtk_widget_show(menubar);
 711
 712     menuitem = gtk_menu_item_new_with_label("Game");
 713     gtk_container_add(GTK_CONTAINER(menubar), menuitem);
 714     gtk_widget_show(menuitem);
 715
 716     menu = gtk_menu_new();
 717     gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
 718
 719     add_menu_item_with_key(fe, GTK_CONTAINER(menu), "New", 'n');
 720     add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Restart", 'r');
 721
 722     menuitem = gtk_menu_item_new_with_label("Specific...");
 723     gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
 724                         GINT_TO_POINTER(CFG_SEED));
 725     gtk_container_add(GTK_CONTAINER(menu), menuitem);
 726     gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
 727                        GTK_SIGNAL_FUNC(menu_config_event), fe);
 728     gtk_widget_show(menuitem);
 729
 730     if ((n = midend_num_presets(fe->me)) > 0 || game_can_configure) {
 731         GtkWidget *submenu;
 732         int i;
 733
 734         menuitem = gtk_menu_item_new_with_label("Type");
 735         gtk_container_add(GTK_CONTAINER(menubar), menuitem);
 736         gtk_widget_show(menuitem);
 737
 738         submenu = gtk_menu_new();
 739         gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
 740
 741         for (i = 0; i < n; i++) {
 742             char *name;
 743             game_params *params;
 744
 745             midend_fetch_preset(fe->me, i, &name, &params);
 746
 747             menuitem = gtk_menu_item_new_with_label(name);
 748             gtk_container_add(GTK_CONTAINER(submenu), menuitem);
 749             gtk_object_set_data(GTK_OBJECT(menuitem), "user-data", params);
 750             gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
 751                                GTK_SIGNAL_FUNC(menu_preset_event), fe);
 752             gtk_widget_show(menuitem);
 753         }
 754
 755         if (game_can_configure) {
 756             menuitem = gtk_menu_item_new_with_label("Custom...");
 757             gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
 758                                 GPOINTER_TO_INT(CFG_SETTINGS));
 759             gtk_container_add(GTK_CONTAINER(submenu), menuitem);
 760             gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
 761                                GTK_SIGNAL_FUNC(menu_config_event), fe);
 762             gtk_widget_show(menuitem);
 763         }
 764     }
 765
 766     add_menu_separator(GTK_CONTAINER(menu));
 767     add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Undo", 'u');
 768     add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Redo", '\x12');
 769     add_menu_separator(GTK_CONTAINER(menu));
 770     add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Exit", 'q');
 771
 772     {
 773         int i, ncolours;
 774         float *colours;
 775         gboolean *success;
 776
 777         fe->colmap = gdk_colormap_get_system();
 778         colours = midend_colours(fe->me, &ncolours);
 779         fe->ncolours = ncolours;
 780         fe->colours = snewn(ncolours, GdkColor);
 781         for (i = 0; i < ncolours; i++) {
 782             fe->colours[i].red = colours[i*3] * 0xFFFF;
 783             fe->colours[i].green = colours[i*3+1] * 0xFFFF;
 784             fe->colours[i].blue = colours[i*3+2] * 0xFFFF;
 785         }
 786         success = snewn(ncolours, gboolean);
 787         gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours,
 788                                   FALSE, FALSE, success);
 789         for (i = 0; i < ncolours; i++) {
 790             if (!success[i])
 791                 g_error("couldn't allocate colour %d (#%02x%02x%02x)\n",
 792                         i, fe->colours[i].red >> 8,
 793                         fe->colours[i].green >> 8,
 794                         fe->colours[i].blue >> 8);
 795         }
 796     }
 797
 798     if (midend_wants_statusbar(fe->me)) {
 799         GtkWidget *viewport;
 800         GtkRequisition req;
 801
 802         viewport = gtk_viewport_new(NULL, NULL);
 803         gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
 804         fe->statusbar = gtk_statusbar_new();
 805         gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar);
 806         gtk_widget_show(viewport);
 807         gtk_box_pack_end(vbox, viewport, FALSE, FALSE, 0);
 808         gtk_widget_show(fe->statusbar);
 809         fe->statusctx = gtk_statusbar_get_context_id
 810             (GTK_STATUSBAR(fe->statusbar), "game");
 811         gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx,
 812                            "test");
 813         gtk_widget_size_request(fe->statusbar, &req);
 814 #if 0
 815         /* For GTK 2.0, should we be using gtk_widget_set_size_request? */
 816 #endif
 817         gtk_widget_set_usize(viewport, x, req.height);
 818     } else
 819         fe->statusbar = NULL;
 820
 821     fe->area = gtk_drawing_area_new();
 822     midend_size(fe->me, &x, &y);
 823     gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
 824     fe->w = x;
 825     fe->h = y;
 826
 827     gtk_box_pack_end(vbox, fe->area, FALSE, FALSE, 0);
 828
 829     fe->pixmap = NULL;
 830     fe->fonts = NULL;
 831     fe->nfonts = fe->fontsize = 0;
 832
 833     fe->timer_active = FALSE;
 834
 835     gtk_signal_connect(GTK_OBJECT(fe->window), "destroy",
 836                        GTK_SIGNAL_FUNC(destroy), fe);
 837     gtk_signal_connect(GTK_OBJECT(fe->window), "key_press_event",
 838                        GTK_SIGNAL_FUNC(key_event), fe);
 839     gtk_signal_connect(GTK_OBJECT(fe->area), "button_press_event",
 840                        GTK_SIGNAL_FUNC(button_event), fe);
 841     gtk_signal_connect(GTK_OBJECT(fe->area), "expose_event",
 842                        GTK_SIGNAL_FUNC(expose_area), fe);
 843     gtk_signal_connect(GTK_OBJECT(fe->window), "map_event",
 844                        GTK_SIGNAL_FUNC(map_window), fe);
 845     gtk_signal_connect(GTK_OBJECT(fe->area), "configure_event",
 846                        GTK_SIGNAL_FUNC(configure_area), fe);
 847
 848     gtk_widget_add_events(GTK_WIDGET(fe->area), GDK_BUTTON_PRESS_MASK);
 849
 850     gtk_widget_show(fe->area);
 851     gtk_widget_show(fe->window);
 852
 853     return fe;
 854 }
 855
 856 int main(int argc, char **argv)
 857 {
 858     srand(time(NULL));
 859
 860     gtk_init(&argc, &argv);
 861     (void) new_window();
 862     gtk_main();
 863
 864     return 0;
 865 }