gtk.c

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