[sgt/puzzles] / gtk.c

/*
 * gtk.c: GTK front end for my puzzle collection.
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdarg.h>

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include "puzzles.h"

/* ----------------------------------------------------------------------
 * Error reporting functions used elsewhere.
 */

void fatal(char *fmt, ...)
{
    va_list ap;

    fprintf(stderr, "fatal error: ");

    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);

    fprintf(stderr, "\n");
    exit(1);
}

/* ----------------------------------------------------------------------
 * GTK front end to puzzles.
 */

/*
 * This structure holds all the data relevant to a single window.
 * In principle this would allow us to open multiple independent
 * puzzle windows, although I can't currently see any real point in
 * doing so. I'm just coding cleanly because there's no
 * particularly good reason not to.
 */
struct frontend {
    GtkWidget *window;
    GtkWidget *area;
    GdkPixmap *pixmap;
    GdkColor *colours;
    int ncolours;
    GdkColormap *colmap;
    int w, h;
    midend_data *me;
    GdkGC *gc;
    int bbox_l, bbox_r, bbox_u, bbox_d;
    int timer_active, timer_id;
};

void frontend_default_colour(frontend *fe, float *output)
{
    GdkColor col = fe->window->style->bg[GTK_STATE_NORMAL];
    output[0] = col.red / 65535.0;
    output[1] = col.green / 65535.0;
    output[2] = col.blue / 65535.0;
}

void start_draw(frontend *fe)
{
    fe->gc = gdk_gc_new(fe->area->window);
    fe->bbox_l = fe->w;
    fe->bbox_r = 0;
    fe->bbox_u = fe->h;
    fe->bbox_d = 0;
}

void draw_rect(frontend *fe, int x, int y, int w, int h, int colour)
{
    gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
    gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h);
}

void draw_line(frontend *fe, int x1, int y1, int x2, int y2, int colour)
{
    gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
    gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2);
}

void draw_polygon(frontend *fe, int *coords, int npoints,
                  int fill, int colour)
{
    GdkPoint *points = snewn(npoints, GdkPoint);
    int i;

    for (i = 0; i < npoints; i++) {
        points[i].x = coords[i*2];
        points[i].y = coords[i*2+1];
    }

    gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
    gdk_draw_polygon(fe->pixmap, fe->gc, fill, points, npoints);

    sfree(points);
}

void draw_update(frontend *fe, int x, int y, int w, int h)
{
    if (fe->bbox_l > x  ) fe->bbox_l = x  ;
    if (fe->bbox_r < x+w) fe->bbox_r = x+w;
    if (fe->bbox_u > y  ) fe->bbox_u = y  ;
    if (fe->bbox_d < y+h) fe->bbox_d = y+h;
}

void end_draw(frontend *fe)
{
    gdk_gc_unref(fe->gc);
    fe->gc = NULL;

    if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d) {
	gdk_draw_pixmap(fe->area->window,
			fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)],
			fe->pixmap,
                        fe->bbox_l, fe->bbox_u,
                        fe->bbox_l, fe->bbox_u,
                        fe->bbox_r - fe->bbox_l, fe->bbox_d - fe->bbox_u);
    }
}

static void destroy(GtkWidget *widget, gpointer data)
{
    gtk_main_quit();
}

static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
    frontend *fe = (frontend *)data;
    int keyval;

    if (!fe->pixmap)
        return TRUE;

    if (event->string[0] && !event->string[1])
        keyval = (unsigned char)event->string[0];
    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 ||
             event->keyval == GDK_KP_2)
        keyval = CURSOR_DOWN;
    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 ||
             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;

    if (keyval >= 0 &&
        !midend_process_key(fe->me, 0, 0, keyval))
	gtk_widget_destroy(fe->window);

    return TRUE;
}

static gint button_event(GtkWidget *widget, GdkEventButton *event,
                         gpointer data)
{
    frontend *fe = (frontend *)data;
    int button;

    if (!fe->pixmap)
        return TRUE;

    if (event->type != GDK_BUTTON_PRESS)
        return TRUE;

    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 (!midend_process_key(fe->me, event->x, event->y, button))
	gtk_widget_destroy(fe->window);

    return TRUE;
}

static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
                        gpointer data)
{
    frontend *fe = (frontend *)data;

    if (fe->pixmap) {
	gdk_draw_pixmap(widget->window,
			widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
			fe->pixmap,
			event->area.x, event->area.y,
			event->area.x, event->area.y,
			event->area.width, event->area.height);
    }
    return TRUE;
}

static gint configure_area(GtkWidget *widget,
                           GdkEventConfigure *event, gpointer data)
{
    frontend *fe = (frontend *)data;
    GdkGC *gc;

    if (fe->pixmap)
        gdk_pixmap_unref(fe->pixmap);

    fe->pixmap = gdk_pixmap_new(widget->window, fe->w, fe->h, -1);

    gc = gdk_gc_new(fe->area->window);
    gdk_gc_set_foreground(gc, &fe->colours[0]);
    gdk_draw_rectangle(fe->pixmap, gc, 1, 0, 0, fe->w, fe->h);
    gdk_gc_unref(gc);

    midend_redraw(fe->me);

    return TRUE;
}

static gint timer_func(gpointer data)
{
    frontend *fe = (frontend *)data;

    if (fe->timer_active)
        midend_timer(fe->me, 0.02);    /* may clear timer_active */

    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)
{
    if (!fe->timer_active)
        fe->timer_id = gtk_timeout_add(20, timer_func, fe);
    fe->timer_active = TRUE;
}

static void menu_key_event(GtkMenuItem *menuitem, gpointer data)
{
    frontend *fe = (frontend *)data;
    int key = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
                                                  "user-data"));
    if (!midend_process_key(fe->me, 0, 0, key))
	gtk_widget_destroy(fe->window);
}

static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
{
    frontend *fe = (frontend *)data;
    game_params *params =
        (game_params *)gtk_object_get_data(GTK_OBJECT(menuitem), "user-data");
    int x, y;

    midend_set_params(fe->me, params);
    midend_new_game(fe->me, NULL);
    midend_size(fe->me, &x, &y);
    gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
    fe->w = x;
    fe->h = y;
}

static GtkWidget *add_menu_item_with_key(frontend *fe, GtkContainer *cont,
                                         char *text, int key)
{
    GtkWidget *menuitem = gtk_menu_item_new_with_label(text);
    gtk_container_add(cont, menuitem);
    gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
                        GINT_TO_POINTER(key));
    gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
		       GTK_SIGNAL_FUNC(menu_key_event), fe);
    gtk_widget_show(menuitem);
    return menuitem;
}

static void add_menu_separator(GtkContainer *cont)
{
    GtkWidget *menuitem = gtk_menu_item_new();
    gtk_container_add(cont, menuitem);
    gtk_widget_show(menuitem);
}

static frontend *new_window(void)
{
    frontend *fe;
    GtkBox *vbox;
    GtkWidget *menubar, *menu, *menuitem;
    int x, y, n;

    fe = snew(frontend);

    fe->me = midend_new(fe);
    midend_new_game(fe->me, NULL);

    fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(fe->window), game_name);
#if 0
    gtk_window_set_resizable(GTK_WINDOW(fe->window), FALSE);
#else
    gtk_window_set_policy(GTK_WINDOW(fe->window), FALSE, FALSE, TRUE);
#endif
    vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
    gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
    gtk_widget_show(GTK_WIDGET(vbox));

    menubar = gtk_menu_bar_new();
    gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
    gtk_widget_show(menubar);

    menuitem = gtk_menu_item_new_with_label("Game");
    gtk_container_add(GTK_CONTAINER(menubar), menuitem);
    gtk_widget_show(menuitem);

    menu = gtk_menu_new();
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);

    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) {
        GtkWidget *submenu;
        int i;

        menuitem = gtk_menu_item_new_with_label("Type");
        gtk_container_add(GTK_CONTAINER(menu), menuitem);
        gtk_widget_show(menuitem);

        submenu = gtk_menu_new();
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);

        for (i = 0; i < n; i++) {
            char *name;
            game_params *params;

            midend_fetch_preset(fe->me, i, &name, &params);

            menuitem = gtk_menu_item_new_with_label(name);
            gtk_container_add(GTK_CONTAINER(submenu), menuitem);
            gtk_object_set_data(GTK_OBJECT(menuitem), "user-data", params);
            gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
                               GTK_SIGNAL_FUNC(menu_preset_event), fe);
            gtk_widget_show(menuitem);
        }
    }

    add_menu_separator(GTK_CONTAINER(menu));
    add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Undo", 'u');
    add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Redo", '\x12');
    add_menu_separator(GTK_CONTAINER(menu));
    add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Exit", 'q');

    {
        int i, ncolours;
        float *colours;
        gboolean *success;

        fe->colmap = gdk_colormap_get_system();
        colours = midend_colours(fe->me, &ncolours);
        fe->ncolours = ncolours;
        fe->colours = snewn(ncolours, GdkColor);
        for (i = 0; i < ncolours; i++) {
            fe->colours[i].red = colours[i*3] * 0xFFFF;
            fe->colours[i].green = colours[i*3+1] * 0xFFFF;
            fe->colours[i].blue = colours[i*3+2] * 0xFFFF;
        }
        success = snewn(ncolours, gboolean);
        gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours,
                                  FALSE, FALSE, success);
        for (i = 0; i < ncolours; i++) {
            if (!success[i])
                g_error("couldn't allocate colour %d (#%02x%02x%02x)\n",
                        i, fe->colours[i].red >> 8,
                        fe->colours[i].green >> 8,
                        fe->colours[i].blue >> 8);
        }
    }

    fe->area = gtk_drawing_area_new();
    midend_size(fe->me, &x, &y);
    gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
    fe->w = x;
    fe->h = y;

    gtk_box_pack_end(vbox, fe->area, FALSE, FALSE, 0);

    fe->pixmap = NULL;

    fe->timer_active = FALSE;

    gtk_signal_connect(GTK_OBJECT(fe->window), "destroy",
		       GTK_SIGNAL_FUNC(destroy), fe);
    gtk_signal_connect(GTK_OBJECT(fe->window), "key_press_event",
		       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), "expose_event",
		       GTK_SIGNAL_FUNC(expose_area), 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_show(fe->area);
    gtk_widget_show(fe->window);

    return fe;
}

int main(int argc, char **argv)
{
    srand(time(NULL));

    gtk_init(&argc, &argv);
    (void) new_window();
    gtk_main();

    return 0;
}
Commit	Line	Data
720a8fb7	1	/*
	2	* gtk.c: GTK front end for my puzzle collection.
	3	*/
	4
	5	#include <stdio.h>
	6	#include <stdlib.h>
2ef96bd6	7	#include <time.h>
720a8fb7	8	#include <stdarg.h>
720a8fb7	9
83680571	10	#include <gtk/gtk.h>
1482ee76	11	#include <gdk/gdkkeysyms.h>
83680571	12
720a8fb7	13	#include "puzzles.h"
720a8fb7	14
83680571	15	/* ----------------------------------------------------------------------
	16	* Error reporting functions used elsewhere.
	17	*/
	18
720a8fb7	19	void fatal(char *fmt, ...)
	20	{
	21	va_list ap;
	22
	23	fprintf(stderr, "fatal error: ");
	24
	25	va_start(ap, fmt);
	26	vfprintf(stderr, fmt, ap);
	27	va_end(ap);
	28
	29	fprintf(stderr, "\n");
	30	exit(1);
	31	}
83680571	32
	33	/* ----------------------------------------------------------------------
	34	* GTK front end to puzzles.
	35	*/
	36
	37	/*
	38	* This structure holds all the data relevant to a single window.
	39	* In principle this would allow us to open multiple independent
	40	* puzzle windows, although I can't currently see any real point in
	41	* doing so. I'm just coding cleanly because there's no
	42	* particularly good reason not to.
	43	*/
2ef96bd6	44	struct frontend {
83680571	45	GtkWidget *window;
7f77ea24	46	GtkWidget *area;
2ef96bd6	47	GdkPixmap *pixmap;
	48	GdkColor *colours;
	49	int ncolours;
	50	GdkColormap *colmap;
	51	int w, h;
7f77ea24	52	midend_data *me;
2ef96bd6	53	GdkGC *gc;
2ef96bd6	54	int bbox_l, bbox_r, bbox_u, bbox_d;
20ee89e3	55	int timer_active, timer_id;
83680571	56	};
83680571	57
2ef96bd6	58	void frontend_default_colour(frontend fe, float output)
	59	{
	60	GdkColor col = fe->window->style->bg[GTK_STATE_NORMAL];
	61	output[0] = col.red / 65535.0;
	62	output[1] = col.green / 65535.0;
	63	output[2] = col.blue / 65535.0;
	64	}
	65
	66	void start_draw(frontend *fe)
	67	{
	68	fe->gc = gdk_gc_new(fe->area->window);
	69	fe->bbox_l = fe->w;
	70	fe->bbox_r = 0;
	71	fe->bbox_u = fe->h;
	72	fe->bbox_d = 0;
	73	}
	74
	75	void draw_rect(frontend *fe, int x, int y, int w, int h, int colour)
	76	{
	77	gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
	78	gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h);
	79	}
	80
	81	void draw_line(frontend *fe, int x1, int y1, int x2, int y2, int colour)
	82	{
	83	gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
	84	gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2);
	85	}
	86
	87	void draw_polygon(frontend fe, int coords, int npoints,
	88	int fill, int colour)
	89	{
	90	GdkPoint *points = snewn(npoints, GdkPoint);
	91	int i;
	92
	93	for (i = 0; i < npoints; i++) {
	94	points[i].x = coords[i*2];
	95	points[i].y = coords[i*2+1];
	96	}
	97
	98	gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
	99	gdk_draw_polygon(fe->pixmap, fe->gc, fill, points, npoints);
	100
	101	sfree(points);
	102	}
	103
	104	void draw_update(frontend *fe, int x, int y, int w, int h)
	105	{
	106	if (fe->bbox_l > x ) fe->bbox_l = x ;
	107	if (fe->bbox_r < x+w) fe->bbox_r = x+w;
	108	if (fe->bbox_u > y ) fe->bbox_u = y ;
	109	if (fe->bbox_d < y+h) fe->bbox_d = y+h;
	110	}
	111
	112	void end_draw(frontend *fe)
	113	{
	114	gdk_gc_unref(fe->gc);
	115	fe->gc = NULL;
	116
	117	if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d) {
	118	gdk_draw_pixmap(fe->area->window,
	119	fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)],
	120	fe->pixmap,
	121	fe->bbox_l, fe->bbox_u,
122	fe->bbox_l, fe->bbox_u,
123	fe->bbox_r - fe->bbox_l, fe->bbox_d - fe->bbox_u);
124	}
125	}
126
83680571	127	static void destroy(GtkWidget *widget, gpointer data)
	128	{
	129	gtk_main_quit();
	130	}
	131
2ef96bd6	132	static gint key_event(GtkWidget widget, GdkEventKey event, gpointer data)
7f77ea24	133	{
2ef96bd6	134	frontend fe = (frontend )data;
1482ee76	135	int keyval;
7f77ea24	136
2ef96bd6	137	if (!fe->pixmap)
2ef96bd6	138	return TRUE;
7f77ea24	139
1482ee76	140	if (event->string[0] && !event->string[1])
1482ee76	141	keyval = (unsigned char)event->string[0];
c71454c0	142	else if (event->keyval == GDK_Up \|\| event->keyval == GDK_KP_Up \|\|
c71454c0	143	event->keyval == GDK_KP_8)
1482ee76	144	keyval = CURSOR_UP;
c71454c0	145	else if (event->keyval == GDK_Down \|\| event->keyval == GDK_KP_Down \|\|
c71454c0	146	event->keyval == GDK_KP_2)
1482ee76	147	keyval = CURSOR_DOWN;
c71454c0	148	else if (event->keyval == GDK_Left \|\| event->keyval == GDK_KP_Left \|\|
c71454c0	149	event->keyval == GDK_KP_4)
1482ee76	150	keyval = CURSOR_LEFT;
c71454c0	151	else if (event->keyval == GDK_Right \|\| event->keyval == GDK_KP_Right \|\|
c71454c0	152	event->keyval == GDK_KP_6)
1482ee76	153	keyval = CURSOR_RIGHT;
c71454c0	154	else if (event->keyval == GDK_KP_Home \|\| event->keyval == GDK_KP_7)
	155	keyval = CURSOR_UP_LEFT;
	156	else if (event->keyval == GDK_KP_End \|\| event->keyval == GDK_KP_1)
	157	keyval = CURSOR_DOWN_LEFT;
	158	else if (event->keyval == GDK_KP_Page_Up \|\| event->keyval == GDK_KP_9)
	159	keyval = CURSOR_UP_RIGHT;
	160	else if (event->keyval == GDK_KP_Page_Down \|\| event->keyval == GDK_KP_3)
	161	keyval = CURSOR_DOWN_RIGHT;
1482ee76	162	else
	163	keyval = -1;
	164
	165	if (keyval >= 0 &&
	166	!midend_process_key(fe->me, 0, 0, keyval))
2ef96bd6	167	gtk_widget_destroy(fe->window);
7f77ea24	168
	169	return TRUE;
	170	}
	171
2ef96bd6	172	static gint button_event(GtkWidget widget, GdkEventButton event,
2ef96bd6	173	gpointer data)
7f77ea24	174	{
2ef96bd6	175	frontend fe = (frontend )data;
	176	int button;
	177
	178	if (!fe->pixmap)
	179	return TRUE;
	180
	181	if (event->type != GDK_BUTTON_PRESS)
	182	return TRUE;
7f77ea24	183
b0f06719	184	if (event->button == 2 \|\| (event->state & GDK_SHIFT_MASK))
2ef96bd6	185	button = MIDDLE_BUTTON;
b0f06719	186	else if (event->button == 1)
b0f06719	187	button = LEFT_BUTTON;
2ef96bd6	188	else if (event->button == 3)
	189	button = RIGHT_BUTTON;
	190	else
	191	return FALSE; /* don't even know what button! */
	192
	193	if (!midend_process_key(fe->me, event->x, event->y, button))
	194	gtk_widget_destroy(fe->window);
7f77ea24	195
	196	return TRUE;
	197	}
	198
2ef96bd6	199	static gint expose_area(GtkWidget widget, GdkEventExpose event,
2ef96bd6	200	gpointer data)
83680571	201	{
2ef96bd6	202	frontend fe = (frontend )data;
	203
	204	if (fe->pixmap) {
	205	gdk_draw_pixmap(widget->window,
	206	widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
	207	fe->pixmap,
	208	event->area.x, event->area.y,
	209	event->area.x, event->area.y,
	210	event->area.width, event->area.height);
	211	}
	212	return TRUE;
	213	}
	214
	215	static gint configure_area(GtkWidget *widget,
	216	GdkEventConfigure *event, gpointer data)
	217	{
	218	frontend fe = (frontend )data;
	219	GdkGC *gc;
	220
eb2ad6f1	221	if (fe->pixmap)
	222	gdk_pixmap_unref(fe->pixmap);
	223
2ef96bd6	224	fe->pixmap = gdk_pixmap_new(widget->window, fe->w, fe->h, -1);
	225
	226	gc = gdk_gc_new(fe->area->window);
	227	gdk_gc_set_foreground(gc, &fe->colours[0]);
	228	gdk_draw_rectangle(fe->pixmap, gc, 1, 0, 0, fe->w, fe->h);
	229	gdk_gc_unref(gc);
	230
	231	midend_redraw(fe->me);
	232
	233	return TRUE;
	234	}
	235
	236	static gint timer_func(gpointer data)
	237	{
	238	frontend fe = (frontend )data;
	239
	240	if (fe->timer_active)
	241	midend_timer(fe->me, 0.02); /* may clear timer_active */
	242
	243	return fe->timer_active;
	244	}
	245
	246	void deactivate_timer(frontend *fe)
	247	{
20ee89e3	248	if (fe->timer_active)
20ee89e3	249	gtk_timeout_remove(fe->timer_id);
2ef96bd6	250	fe->timer_active = FALSE;
	251	}
	252
	253	void activate_timer(frontend *fe)
	254	{
20ee89e3	255	if (!fe->timer_active)
20ee89e3	256	fe->timer_id = gtk_timeout_add(20, timer_func, fe);
2ef96bd6	257	fe->timer_active = TRUE;
	258	}
	259
eb2ad6f1	260	static void menu_key_event(GtkMenuItem *menuitem, gpointer data)
	261	{
	262	frontend fe = (frontend )data;
	263	int key = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
	264	"user-data"));
	265	if (!midend_process_key(fe->me, 0, 0, key))
	266	gtk_widget_destroy(fe->window);
	267	}
	268
	269	static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
	270	{
	271	frontend fe = (frontend )data;
	272	game_params *params =
	273	(game_params *)gtk_object_get_data(GTK_OBJECT(menuitem), "user-data");
	274	int x, y;
	275
	276	midend_set_params(fe->me, params);
	277	midend_new_game(fe->me, NULL);
	278	midend_size(fe->me, &x, &y);
	279	gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
	280	fe->w = x;
	281	fe->h = y;
	282	}
	283
	284	static GtkWidget add_menu_item_with_key(frontend fe, GtkContainer *cont,
	285	char *text, int key)
	286	{
	287	GtkWidget *menuitem = gtk_menu_item_new_with_label(text);
	288	gtk_container_add(cont, menuitem);
	289	gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
	290	GINT_TO_POINTER(key));
	291	gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
	292	GTK_SIGNAL_FUNC(menu_key_event), fe);
	293	gtk_widget_show(menuitem);
	294	return menuitem;
	295	}
	296
	297	static void add_menu_separator(GtkContainer *cont)
	298	{
	299	GtkWidget *menuitem = gtk_menu_item_new();
	300	gtk_container_add(cont, menuitem);
	301	gtk_widget_show(menuitem);
	302	}
	303
2ef96bd6	304	static frontend *new_window(void)
	305	{
	306	frontend *fe;
eb2ad6f1	307	GtkBox *vbox;
	308	GtkWidget menubar, menu, *menuitem;
	309	int x, y, n;
83680571	310
2ef96bd6	311	fe = snew(frontend);
83680571	312
2ef96bd6	313	fe->me = midend_new(fe);
2ef96bd6	314	midend_new_game(fe->me, NULL);
7f77ea24	315
2ef96bd6	316	fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
0c490335	317	gtk_window_set_title(GTK_WINDOW(fe->window), game_name);
ff2f787b	318	#if 0
	319	gtk_window_set_resizable(GTK_WINDOW(fe->window), FALSE);
	320	#else
	321	gtk_window_set_policy(GTK_WINDOW(fe->window), FALSE, FALSE, TRUE);
	322	#endif
eb2ad6f1	323	vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
	324	gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
	325	gtk_widget_show(GTK_WIDGET(vbox));
	326
	327	menubar = gtk_menu_bar_new();
	328	gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
	329	gtk_widget_show(menubar);
	330
	331	menuitem = gtk_menu_item_new_with_label("Game");
	332	gtk_container_add(GTK_CONTAINER(menubar), menuitem);
	333	gtk_widget_show(menuitem);
	334
	335	menu = gtk_menu_new();
	336	gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
	337
	338	add_menu_item_with_key(fe, GTK_CONTAINER(menu), "New", 'n');
	339	add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Restart", 'r');
	340
	341	if ((n = midend_num_presets(fe->me)) > 0) {
	342	GtkWidget *submenu;
	343	int i;
	344
	345	menuitem = gtk_menu_item_new_with_label("Type");
	346	gtk_container_add(GTK_CONTAINER(menu), menuitem);
	347	gtk_widget_show(menuitem);
	348
	349	submenu = gtk_menu_new();
	350	gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
	351
	352	for (i = 0; i < n; i++) {
	353	char *name;
	354	game_params *params;
	355
	356	midend_fetch_preset(fe->me, i, &name, &params);
	357
	358	menuitem = gtk_menu_item_new_with_label(name);
	359	gtk_container_add(GTK_CONTAINER(submenu), menuitem);
	360	gtk_object_set_data(GTK_OBJECT(menuitem), "user-data", params);
	361	gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
	362	GTK_SIGNAL_FUNC(menu_preset_event), fe);
	363	gtk_widget_show(menuitem);
	364	}
	365	}
	366
	367	add_menu_separator(GTK_CONTAINER(menu));
	368	add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Undo", 'u');
	369	add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Redo", '\x12');
	370	add_menu_separator(GTK_CONTAINER(menu));
	371	add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Exit", 'q');
7f77ea24	372
2ef96bd6	373	{
	374	int i, ncolours;
	375	float *colours;
	376	gboolean *success;
7f77ea24	377
2ef96bd6	378	fe->colmap = gdk_colormap_get_system();
	379	colours = midend_colours(fe->me, &ncolours);
	380	fe->ncolours = ncolours;
	381	fe->colours = snewn(ncolours, GdkColor);
	382	for (i = 0; i < ncolours; i++) {
	383	fe->colours[i].red = colours[i3] 0xFFFF;
	384	fe->colours[i].green = colours[i3+1] 0xFFFF;
	385	fe->colours[i].blue = colours[i3+2] 0xFFFF;
	386	}
	387	success = snewn(ncolours, gboolean);
	388	gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours,
	389	FALSE, FALSE, success);
	390	for (i = 0; i < ncolours; i++) {
	391	if (!success[i])
	392	g_error("couldn't allocate colour %d (#%02x%02x%02x)\n",
	393	i, fe->colours[i].red >> 8,
	394	fe->colours[i].green >> 8,
	395	fe->colours[i].blue >> 8);
	396	}
	397	}
7f77ea24	398
2ef96bd6	399	fe->area = gtk_drawing_area_new();
	400	midend_size(fe->me, &x, &y);
	401	gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
	402	fe->w = x;
	403	fe->h = y;
	404
eb2ad6f1	405	gtk_box_pack_end(vbox, fe->area, FALSE, FALSE, 0);
2ef96bd6	406
	407	fe->pixmap = NULL;
	408
20ee89e3	409	fe->timer_active = FALSE;
20ee89e3	410
2ef96bd6	411	gtk_signal_connect(GTK_OBJECT(fe->window), "destroy",
	412	GTK_SIGNAL_FUNC(destroy), fe);
	413	gtk_signal_connect(GTK_OBJECT(fe->window), "key_press_event",
	414	GTK_SIGNAL_FUNC(key_event), fe);
	415	gtk_signal_connect(GTK_OBJECT(fe->area), "button_press_event",
	416	GTK_SIGNAL_FUNC(button_event), fe);
	417	gtk_signal_connect(GTK_OBJECT(fe->area), "expose_event",
	418	GTK_SIGNAL_FUNC(expose_area), fe);
	419	gtk_signal_connect(GTK_OBJECT(fe->area), "configure_event",
	420	GTK_SIGNAL_FUNC(configure_area), fe);
	421
	422	gtk_widget_add_events(GTK_WIDGET(fe->area), GDK_BUTTON_PRESS_MASK);
	423
	424	gtk_widget_show(fe->area);
	425	gtk_widget_show(fe->window);
	426
	427	return fe;
83680571	428	}
	429
	430	int main(int argc, char **argv)
	431	{
2ef96bd6	432	srand(time(NULL));
2ef96bd6	433
83680571	434	gtk_init(&argc, &argv);
	435	(void) new_window();
	436	gtk_main();
	437
	438	return 0;
	439	}