gtk.c

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