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