X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/eb2ad6f1d0284c83b3cb5caf631c659441189d7d..6ae3730169b0c020d90fe20ace77262d19d26a2b:/gtk.c

diff --git a/gtk.c b/gtk.c
index 102ed9c..3c777af 100644
--- a/gtk.c
+++ b/gtk.c
@@ -3,9 +3,13 @@
  */
 
 #include <stdio.h>
+#include <assert.h>
 #include <stdlib.h>
 #include <time.h>
 #include <stdarg.h>
+#include <string.h>
+
+#include <sys/time.h>
 
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
@@ -34,6 +38,12 @@ void fatal(char *fmt, ...)
  * GTK front end to puzzles.
  */
 
+struct font {
+    GdkFont *font;
+    int type;
+    int size;
+};
+
 /*
  * This structure holds all the data relevant to a single window.
  * In principle this would allow us to open multiple independent
@@ -44,6 +54,8 @@ void fatal(char *fmt, ...)
 struct frontend {
     GtkWidget *window;
     GtkWidget *area;
+    GtkWidget *statusbar;
+    guint statusctx;
     GdkPixmap *pixmap;
     GdkColor *colours;
     int ncolours;
@@ -52,9 +64,23 @@ struct frontend {
     midend_data *me;
     GdkGC *gc;
     int bbox_l, bbox_r, bbox_u, bbox_d;
-    int timer_active;
+    int timer_active, timer_id;
+    struct timeval last_time;
+    struct font *fonts;
+    int nfonts, fontsize;
+    config_item *cfg;
+    int cfg_which, cfgret;
+    GtkWidget *cfgbox;
 };
 
+void get_random_seed(void **randseed, int *randseedsize)
+{
+    time_t *tp = snew(time_t);
+    time(tp);
+    *randseed = (void *)tp;
+    *randseedsize = sizeof(time_t);
+}
+
 void frontend_default_colour(frontend *fe, float *output)
 {
     GdkColor col = fe->window->style->bg[GTK_STATE_NORMAL];
@@ -63,6 +89,14 @@ void frontend_default_colour(frontend *fe, float *output)
     output[2] = col.blue / 65535.0;
 }
 
+void status_bar(frontend *fe, char *text)
+{
+    assert(fe->statusbar);
+
+    gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx);
+    gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, text);
+}
+
 void start_draw(frontend *fe)
 {
     fe->gc = gdk_gc_new(fe->area->window);
@@ -72,6 +106,85 @@ void start_draw(frontend *fe)
     fe->bbox_d = 0;
 }
 
+void clip(frontend *fe, int x, int y, int w, int h)
+{
+    GdkRectangle rect;
+
+    rect.x = x;
+    rect.y = y;
+    rect.width = w;
+    rect.height = h;
+
+    gdk_gc_set_clip_rectangle(fe->gc, &rect);
+}
+
+void unclip(frontend *fe)
+{
+    GdkRectangle rect;
+
+    rect.x = 0;
+    rect.y = 0;
+    rect.width = fe->w;
+    rect.height = fe->h;
+
+    gdk_gc_set_clip_rectangle(fe->gc, &rect);
+}
+
+void draw_text(frontend *fe, int x, int y, int fonttype, int fontsize,
+               int align, int colour, char *text)
+{
+    int i;
+
+    /*
+     * Find or create the font.
+     */
+    for (i = 0; i < fe->nfonts; i++)
+        if (fe->fonts[i].type == fonttype && fe->fonts[i].size == fontsize)
+            break;
+
+    if (i == fe->nfonts) {
+        if (fe->fontsize <= fe->nfonts) {
+            fe->fontsize = fe->nfonts + 10;
+            fe->fonts = sresize(fe->fonts, fe->fontsize, struct font);
+        }
+
+        fe->nfonts++;
+
+        fe->fonts[i].type = fonttype;
+        fe->fonts[i].size = fontsize;
+
+        /*
+         * FIXME: Really I should make at least _some_ effort to
+         * pick the correct font.
+         */
+        fe->fonts[i].font = gdk_font_load("variable");
+    }
+
+    /*
+     * Find string dimensions and process alignment.
+     */
+    {
+        int lb, rb, wid, asc, desc;
+
+        gdk_string_extents(fe->fonts[i].font, text,
+                           &lb, &rb, &wid, &asc, &desc);
+        if (align & ALIGN_VCENTRE)
+            y += asc - (asc+desc)/2;
+
+        if (align & ALIGN_HCENTRE)
+            x -= wid / 2;
+        else if (align & ALIGN_HRIGHT)
+            x -= wid;
+
+    }
+
+    /*
+     * Set colour and actually draw text.
+     */
+    gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
+    gdk_draw_string(fe->pixmap, fe->fonts[i].font, fe->gc, x, y, text);
+}
+
 void draw_rect(frontend *fe, int x, int y, int w, int h, int colour)
 {
     gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
@@ -126,6 +239,8 @@ void end_draw(frontend *fe)
 
 static void destroy(GtkWidget *widget, gpointer data)
 {
+    frontend *fe = (frontend *)data;
+    deactivate_timer(fe);
     gtk_main_quit();
 }
 
@@ -139,14 +254,26 @@ static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 
     if (event->string[0] && !event->string[1])
         keyval = (unsigned char)event->string[0];
-    else if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
+    else if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up ||
+             event->keyval == GDK_KP_8)
         keyval = CURSOR_UP;
-    else if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
+    else if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down ||
+             event->keyval == GDK_KP_2)
         keyval = CURSOR_DOWN;
-    else if (event->keyval == GDK_Left || event->keyval == GDK_KP_Left)
+    else if (event->keyval == GDK_Left || event->keyval == GDK_KP_Left ||
+             event->keyval == GDK_KP_4)
         keyval = CURSOR_LEFT;
-    else if (event->keyval == GDK_Right || event->keyval == GDK_KP_Right)
+    else if (event->keyval == GDK_Right || event->keyval == GDK_KP_Right ||
+             event->keyval == GDK_KP_6)
         keyval = CURSOR_RIGHT;
+    else if (event->keyval == GDK_KP_Home || event->keyval == GDK_KP_7)
+        keyval = CURSOR_UP_LEFT;
+    else if (event->keyval == GDK_KP_End || event->keyval == GDK_KP_1)
+        keyval = CURSOR_DOWN_LEFT;
+    else if (event->keyval == GDK_KP_Page_Up || event->keyval == GDK_KP_9)
+        keyval = CURSOR_UP_RIGHT;
+    else if (event->keyval == GDK_KP_Page_Down || event->keyval == GDK_KP_3)
+        keyval = CURSOR_DOWN_RIGHT;
     else
         keyval = -1;
 
@@ -166,18 +293,45 @@ static gint button_event(GtkWidget *widget, GdkEventButton *event,
     if (!fe->pixmap)
         return TRUE;
 
-    if (event->type != GDK_BUTTON_PRESS)
+    if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE)
         return TRUE;
 
-    if (event->button == 1)
-	button = LEFT_BUTTON;
-    else if (event->button == 2)
+    if (event->button == 2 || (event->state & GDK_SHIFT_MASK))
 	button = MIDDLE_BUTTON;
+    else if (event->button == 1)
+	button = LEFT_BUTTON;
     else if (event->button == 3)
 	button = RIGHT_BUTTON;
     else
 	return FALSE;		       /* don't even know what button! */
 
+    if (event->type == GDK_BUTTON_RELEASE)
+        button += LEFT_RELEASE - LEFT_BUTTON;
+
+    if (!midend_process_key(fe->me, event->x, event->y, button))
+	gtk_widget_destroy(fe->window);
+
+    return TRUE;
+}
+
+static gint motion_event(GtkWidget *widget, GdkEventMotion *event,
+                         gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    int button;
+
+    if (!fe->pixmap)
+        return TRUE;
+
+    if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK))
+	button = MIDDLE_DRAG;
+    else if (event->state & GDK_BUTTON1_MASK)
+	button = LEFT_DRAG;
+    else if (event->state & GDK_BUTTON3_MASK)
+	button = RIGHT_DRAG;
+    else
+	return FALSE;		       /* don't even know what button! */
+
     if (!midend_process_key(fe->me, event->x, event->y, button))
 	gtk_widget_destroy(fe->window);
 
@@ -200,6 +354,21 @@ static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
     return TRUE;
 }
 
+static gint map_window(GtkWidget *widget, GdkEvent *event,
+		       gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    /*
+     * Apparently we need to do this because otherwise the status
+     * bar will fail to update immediately. Annoying, but there we
+     * go.
+     */
+    gtk_widget_queue_draw(fe->window);
+
+    return TRUE;
+}
+
 static gint configure_area(GtkWidget *widget,
                            GdkEventConfigure *event, gpointer data)
 {
@@ -225,23 +394,325 @@ static gint timer_func(gpointer data)
 {
     frontend *fe = (frontend *)data;
 
-    if (fe->timer_active)
-        midend_timer(fe->me, 0.02);    /* may clear timer_active */
+    if (fe->timer_active) {
+	struct timeval now;
+	float elapsed;
+	gettimeofday(&now, NULL);
+	elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F +
+		   (now.tv_sec - fe->last_time.tv_sec));
+        midend_timer(fe->me, elapsed);	/* may clear timer_active */
+	fe->last_time = now;
+    }
 
     return fe->timer_active;
 }
 
 void deactivate_timer(frontend *fe)
 {
+    if (fe->timer_active)
+        gtk_timeout_remove(fe->timer_id);
     fe->timer_active = FALSE;
 }
 
 void activate_timer(frontend *fe)
 {
-    gtk_timeout_add(20, timer_func, fe);
+    if (!fe->timer_active) {
+        fe->timer_id = gtk_timeout_add(20, timer_func, fe);
+	gettimeofday(&fe->last_time, NULL);
+    }
     fe->timer_active = TRUE;
 }
 
+static void window_destroy(GtkWidget *widget, gpointer data)
+{
+    gtk_main_quit();
+}
+
+static void errmsg_button_clicked(GtkButton *button, gpointer data)
+{
+    gtk_widget_destroy(GTK_WIDGET(data));
+}
+
+static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
+{
+    GtkObject *cancelbutton = GTK_OBJECT(data);
+
+    /*
+     * `Escape' effectively clicks the cancel button
+     */
+    if (event->keyval == GDK_Escape) {
+	gtk_signal_emit_by_name(GTK_OBJECT(cancelbutton), "clicked");
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+void error_box(GtkWidget *parent, char *msg)
+{
+    GtkWidget *window, *hbox, *text, *ok;
+
+    window = gtk_dialog_new();
+    text = gtk_label_new(msg);
+    gtk_misc_set_alignment(GTK_MISC(text), 0.0, 0.0);
+    hbox = gtk_hbox_new(FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox), text, FALSE, FALSE, 20);
+    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox),
+                       hbox, FALSE, FALSE, 20);
+    gtk_widget_show(text);
+    gtk_widget_show(hbox);
+    gtk_window_set_title(GTK_WINDOW(window), "Error");
+    gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
+    ok = gtk_button_new_with_label("OK");
+    gtk_box_pack_end(GTK_BOX(GTK_DIALOG(window)->action_area),
+                     ok, FALSE, FALSE, 0);
+    gtk_widget_show(ok);
+    GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
+    gtk_window_set_default(GTK_WINDOW(window), ok);
+    gtk_signal_connect(GTK_OBJECT(ok), "clicked",
+                       GTK_SIGNAL_FUNC(errmsg_button_clicked), window);
+    gtk_signal_connect(GTK_OBJECT(window), "destroy",
+                       GTK_SIGNAL_FUNC(window_destroy), NULL);
+    gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
+		       GTK_SIGNAL_FUNC(win_key_press), ok);
+    gtk_window_set_modal(GTK_WINDOW(window), TRUE);
+    gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(parent));
+    //set_transient_window_pos(parent, window);
+    gtk_widget_show(window);
+    gtk_main();
+}
+
+static void config_ok_button_clicked(GtkButton *button, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    char *err;
+
+    err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
+
+    if (err)
+	error_box(fe->cfgbox, err);
+    else {
+	fe->cfgret = TRUE;
+	gtk_widget_destroy(fe->cfgbox);
+    }
+}
+
+static void config_cancel_button_clicked(GtkButton *button, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+
+    gtk_widget_destroy(fe->cfgbox);
+}
+
+static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data)
+{
+    /*
+     * GtkEntry has a nasty habit of eating the Return key, which
+     * is unhelpful since it doesn't actually _do_ anything with it
+     * (it calls gtk_widget_activate, but our edit boxes never need
+     * activating). So I catch Return before GtkEntry sees it, and
+     * pass it straight on to the parent widget. Effect: hitting
+     * Return in an edit box will now activate the default button
+     * in the dialog just like it will everywhere else.
+     */
+    if (event->keyval == GDK_Return && widget->parent != NULL) {
+	gint return_val;
+	gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key_press_event");
+	gtk_signal_emit_by_name(GTK_OBJECT(widget->parent), "key_press_event",
+				event, &return_val);
+	return return_val;
+    }
+    return FALSE;
+}
+
+static void editbox_changed(GtkEditable *ed, gpointer data)
+{
+    config_item *i = (config_item *)data;
+
+    sfree(i->sval);
+    i->sval = dupstr(gtk_entry_get_text(GTK_ENTRY(ed)));
+}
+
+static void button_toggled(GtkToggleButton *tb, gpointer data)
+{
+    config_item *i = (config_item *)data;
+
+    i->ival = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb));
+}
+
+static void droplist_sel(GtkMenuItem *item, gpointer data)
+{
+    config_item *i = (config_item *)data;
+
+    i->ival = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),
+						  "user-data"));
+}
+
+static int get_config(frontend *fe, int which)
+{
+    GtkWidget *w, *table, *cancel;
+    char *title;
+    config_item *i;
+    int y;
+
+    fe->cfg = midend_get_config(fe->me, which, &title);
+    fe->cfg_which = which;
+    fe->cfgret = FALSE;
+
+    fe->cfgbox = gtk_dialog_new();
+    gtk_window_set_title(GTK_WINDOW(fe->cfgbox), title);
+    sfree(title);
+
+    w = gtk_button_new_with_label("OK");
+    gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area),
+                     w, FALSE, FALSE, 0);
+    gtk_widget_show(w);
+    GTK_WIDGET_SET_FLAGS(w, GTK_CAN_DEFAULT);
+    gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w);
+    gtk_signal_connect(GTK_OBJECT(w), "clicked",
+                       GTK_SIGNAL_FUNC(config_ok_button_clicked), fe);
+
+    w = gtk_button_new_with_label("Cancel");
+    gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area),
+                     w, FALSE, FALSE, 0);
+    gtk_widget_show(w);
+    gtk_signal_connect(GTK_OBJECT(w), "clicked",
+                       GTK_SIGNAL_FUNC(config_cancel_button_clicked), fe);
+    cancel = w;
+
+    table = gtk_table_new(1, 2, FALSE);
+    y = 0;
+    gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->vbox),
+                     table, FALSE, FALSE, 0);
+    gtk_widget_show(table);
+
+    for (i = fe->cfg; i->type != C_END; i++) {
+	gtk_table_resize(GTK_TABLE(table), y+1, 2);
+
+	switch (i->type) {
+	  case C_STRING:
+	    /*
+	     * Edit box with a label beside it.
+	     */
+
+	    w = gtk_label_new(i->name);
+	    gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
+	    gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     3, 3);
+	    gtk_widget_show(w);
+
+	    w = gtk_entry_new();
+	    gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     3, 3);
+	    gtk_entry_set_text(GTK_ENTRY(w), i->sval);
+	    gtk_signal_connect(GTK_OBJECT(w), "changed",
+			       GTK_SIGNAL_FUNC(editbox_changed), i);
+	    gtk_signal_connect(GTK_OBJECT(w), "key_press_event",
+			       GTK_SIGNAL_FUNC(editbox_key), NULL);
+	    gtk_widget_show(w);
+
+	    break;
+
+	  case C_BOOLEAN:
+	    /*
+	     * Simple checkbox.
+	     */
+            w = gtk_check_button_new_with_label(i->name);
+	    gtk_signal_connect(GTK_OBJECT(w), "toggled",
+			       GTK_SIGNAL_FUNC(button_toggled), i);
+	    gtk_table_attach(GTK_TABLE(table), w, 0, 2, y, y+1,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     3, 3);
+	    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), i->ival);
+	    gtk_widget_show(w);
+	    break;
+
+	  case C_CHOICES:
+	    /*
+	     * Drop-down list (GtkOptionMenu).
+	     */
+
+	    w = gtk_label_new(i->name);
+	    gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
+	    gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     3, 3);
+	    gtk_widget_show(w);
+
+	    w = gtk_option_menu_new();
+	    gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+			     3, 3);
+	    gtk_widget_show(w);
+
+	    {
+		int c, val;
+		char *p, *q, *name;
+		GtkWidget *menuitem;
+		GtkWidget *menu = gtk_menu_new();
+
+		gtk_option_menu_set_menu(GTK_OPTION_MENU(w), menu);
+
+		c = *i->sval;
+		p = i->sval+1;
+		val = 0;
+
+		while (*p) {
+		    q = p;
+		    while (*q && *q != c)
+			q++;
+
+		    name = snewn(q-p+1, char);
+		    strncpy(name, p, q-p);
+		    name[q-p] = '\0';
+
+		    if (*q) q++;       /* eat delimiter */
+
+		    menuitem = gtk_menu_item_new_with_label(name);
+		    gtk_container_add(GTK_CONTAINER(menu), menuitem);
+		    gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
+					GINT_TO_POINTER(val));
+		    gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
+				       GTK_SIGNAL_FUNC(droplist_sel), i);
+		    gtk_widget_show(menuitem);
+
+		    val++;
+
+		    p = q;
+		}
+
+		gtk_option_menu_set_history(GTK_OPTION_MENU(w), i->ival);
+	    }
+
+	    break;
+	}
+
+	y++;
+    }
+
+    gtk_signal_connect(GTK_OBJECT(fe->cfgbox), "destroy",
+                       GTK_SIGNAL_FUNC(window_destroy), NULL);
+    gtk_signal_connect(GTK_OBJECT(fe->cfgbox), "key_press_event",
+		       GTK_SIGNAL_FUNC(win_key_press), cancel);
+    gtk_window_set_modal(GTK_WINDOW(fe->cfgbox), TRUE);
+    gtk_window_set_transient_for(GTK_WINDOW(fe->cfgbox),
+				 GTK_WINDOW(fe->window));
+    //set_transient_window_pos(fe->window, fe->cfgbox);
+    gtk_widget_show(fe->cfgbox);
+    gtk_main();
+
+    free_cfg(fe->cfg);
+
+    return fe->cfgret;
+}
+
 static void menu_key_event(GtkMenuItem *menuitem, gpointer data)
 {
     frontend *fe = (frontend *)data;
@@ -259,7 +730,24 @@ static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
     int x, y;
 
     midend_set_params(fe->me, params);
-    midend_new_game(fe->me, NULL);
+    midend_new_game(fe->me);
+    midend_size(fe->me, &x, &y);
+    gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
+    fe->w = x;
+    fe->h = y;
+}
+
+static void menu_config_event(GtkMenuItem *menuitem, gpointer data)
+{
+    frontend *fe = (frontend *)data;
+    int which = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
+						    "user-data"));
+    int x, y;
+
+    if (!get_config(fe, which))
+	return;
+
+    midend_new_game(fe->me);
     midend_size(fe->me, &x, &y);
     gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
     fe->w = x;
@@ -286,7 +774,7 @@ static void add_menu_separator(GtkContainer *cont)
     gtk_widget_show(menuitem);
 }
 
-static frontend *new_window(void)
+static frontend *new_window(char *game_id, char **error)
 {
     frontend *fe;
     GtkBox *vbox;
@@ -295,10 +783,19 @@ static frontend *new_window(void)
 
     fe = snew(frontend);
 
-    fe->me = midend_new(fe);
-    midend_new_game(fe->me, NULL);
+    fe->me = midend_new(fe, &thegame);
+    if (game_id) {
+        *error = midend_game_id(fe->me, game_id, FALSE);
+        if (*error) {
+            midend_free(fe->me);
+            sfree(fe);
+            return NULL;
+        }
+    }
+    midend_new_game(fe->me);
 
     fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name);
 #if 0
     gtk_window_set_resizable(GTK_WINDOW(fe->window), FALSE);
 #else
@@ -322,12 +819,20 @@ static frontend *new_window(void)
     add_menu_item_with_key(fe, GTK_CONTAINER(menu), "New", 'n');
     add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Restart", 'r');
 
-    if ((n = midend_num_presets(fe->me)) > 0) {
+    menuitem = gtk_menu_item_new_with_label("Specific...");
+    gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
+			GINT_TO_POINTER(CFG_SEED));
+    gtk_container_add(GTK_CONTAINER(menu), menuitem);
+    gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
+		       GTK_SIGNAL_FUNC(menu_config_event), fe);
+    gtk_widget_show(menuitem);
+
+    if ((n = midend_num_presets(fe->me)) > 0 || thegame.can_configure) {
         GtkWidget *submenu;
         int i;
 
         menuitem = gtk_menu_item_new_with_label("Type");
-        gtk_container_add(GTK_CONTAINER(menu), menuitem);
+        gtk_container_add(GTK_CONTAINER(menubar), menuitem);
         gtk_widget_show(menuitem);
 
         submenu = gtk_menu_new();
@@ -346,6 +851,16 @@ static frontend *new_window(void)
                                GTK_SIGNAL_FUNC(menu_preset_event), fe);
             gtk_widget_show(menuitem);
         }
+
+	if (thegame.can_configure) {
+            menuitem = gtk_menu_item_new_with_label("Custom...");
+            gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
+				GPOINTER_TO_INT(CFG_SETTINGS));
+            gtk_container_add(GTK_CONTAINER(submenu), menuitem);
+            gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
+                               GTK_SIGNAL_FUNC(menu_config_event), fe);
+            gtk_widget_show(menuitem);
+	}
     }
 
     add_menu_separator(GTK_CONTAINER(menu));
@@ -380,6 +895,29 @@ static frontend *new_window(void)
         }
     }
 
+    if (midend_wants_statusbar(fe->me)) {
+	GtkWidget *viewport;
+	GtkRequisition req;
+
+	viewport = gtk_viewport_new(NULL, NULL);
+	gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
+	fe->statusbar = gtk_statusbar_new();
+	gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar);
+	gtk_widget_show(viewport);
+	gtk_box_pack_end(vbox, viewport, FALSE, FALSE, 0);
+	gtk_widget_show(fe->statusbar);
+	fe->statusctx = gtk_statusbar_get_context_id
+	    (GTK_STATUSBAR(fe->statusbar), "game");
+	gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx,
+			   "test");
+	gtk_widget_size_request(fe->statusbar, &req);
+#if 0
+	/* For GTK 2.0, should we be using gtk_widget_set_size_request? */
+#endif
+	gtk_widget_set_usize(viewport, -1, req.height);
+    } else
+	fe->statusbar = NULL;
+
     fe->area = gtk_drawing_area_new();
     midend_size(fe->me, &x, &y);
     gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
@@ -389,6 +927,10 @@ static frontend *new_window(void)
     gtk_box_pack_end(vbox, fe->area, FALSE, FALSE, 0);
 
     fe->pixmap = NULL;
+    fe->fonts = NULL;
+    fe->nfonts = fe->fontsize = 0;
+
+    fe->timer_active = FALSE;
 
     gtk_signal_connect(GTK_OBJECT(fe->window), "destroy",
 		       GTK_SIGNAL_FUNC(destroy), fe);
@@ -396,12 +938,21 @@ static frontend *new_window(void)
 		       GTK_SIGNAL_FUNC(key_event), fe);
     gtk_signal_connect(GTK_OBJECT(fe->area), "button_press_event",
 		       GTK_SIGNAL_FUNC(button_event), fe);
+    gtk_signal_connect(GTK_OBJECT(fe->area), "button_release_event",
+		       GTK_SIGNAL_FUNC(button_event), fe);
+    gtk_signal_connect(GTK_OBJECT(fe->area), "motion_notify_event",
+		       GTK_SIGNAL_FUNC(motion_event), fe);
     gtk_signal_connect(GTK_OBJECT(fe->area), "expose_event",
 		       GTK_SIGNAL_FUNC(expose_area), fe);
+    gtk_signal_connect(GTK_OBJECT(fe->window), "map_event",
+		       GTK_SIGNAL_FUNC(map_window), fe);
     gtk_signal_connect(GTK_OBJECT(fe->area), "configure_event",
 		       GTK_SIGNAL_FUNC(configure_area), fe);
 
-    gtk_widget_add_events(GTK_WIDGET(fe->area), GDK_BUTTON_PRESS_MASK);
+    gtk_widget_add_events(GTK_WIDGET(fe->area),
+                          GDK_BUTTON_PRESS_MASK |
+                          GDK_BUTTON_RELEASE_MASK |
+			  GDK_BUTTON_MOTION_MASK);
 
     gtk_widget_show(fe->area);
     gtk_widget_show(fe->window);
@@ -411,10 +962,16 @@ static frontend *new_window(void)
 
 int main(int argc, char **argv)
 {
-    srand(time(NULL));
+    char *pname = argv[0];
+    char *error;
 
     gtk_init(&argc, &argv);
-    (void) new_window();
+
+    if (!new_window(argc > 1 ? argv[1] : NULL, &error)) {
+        fprintf(stderr, "%s: %s\n", pname, error);
+        return 1;
+    }
+
     gtk_main();
 
     return 0;