X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?a=blobdiff_plain;f=gtk.c;h=a8416b0c5cb9f9c76197fb71fa84f15733795669;hb=3234912f921916a1b8da164fd61dc75579358577;hp=c7713a1c4283f77dfc6d0d1f8e86527843aaded5;hpb=c1b0c1d091399a6e8d8dc3ed20a42b161810182f;p=sgt-puzzles.git diff --git a/gtk.c b/gtk.c index c7713a1..a8416b0 100644 --- a/gtk.c +++ b/gtk.c @@ -9,8 +9,10 @@ #include #include #include +#include #include +#include #include #include @@ -25,9 +27,47 @@ #include "puzzles.h" #if GTK_CHECK_VERSION(2,0,0) -#define USE_PANGO +# define USE_PANGO +# ifdef PANGO_VERSION_CHECK +# if PANGO_VERSION_CHECK(1,8,0) +# define HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION +# endif +# endif +#endif +#if !GTK_CHECK_VERSION(2,4,0) +# define OLD_FILESEL +#endif +#if GTK_CHECK_VERSION(2,8,0) +# define USE_CAIRO +# if GTK_CHECK_VERSION(3,0,0) || defined(GDK_DISABLE_DEPRECATED) +# define USE_CAIRO_WITHOUT_PIXMAP +# endif +#endif + +#if GTK_CHECK_VERSION(3,0,0) +/* The old names are still more concise! */ +#define gtk_hbox_new(x,y) gtk_box_new(GTK_ORIENTATION_HORIZONTAL,y) +#define gtk_vbox_new(x,y) gtk_box_new(GTK_ORIENTATION_VERTICAL,y) +/* GTK 3 has retired stock button labels */ +#define LABEL_OK "_OK" +#define LABEL_CANCEL "_Cancel" +#define LABEL_NO "_No" +#define LABEL_YES "_Yes" +#define LABEL_SAVE "_Save" +#define LABEL_OPEN "_Open" +#define gtk_button_new_with_our_label gtk_button_new_with_mnemonic +#else +#define LABEL_OK GTK_STOCK_OK +#define LABEL_CANCEL GTK_STOCK_CANCEL +#define LABEL_NO GTK_STOCK_NO +#define LABEL_YES GTK_STOCK_YES +#define LABEL_SAVE GTK_STOCK_SAVE +#define LABEL_OPEN GTK_STOCK_OPEN +#define gtk_button_new_with_our_label gtk_button_new_from_stock #endif +/* #undef USE_CAIRO */ +/* #define NO_THICK_LINE */ #ifdef DEBUGGING static FILE *debug_fp = NULL; @@ -79,6 +119,8 @@ void fatal(char *fmt, ...) * GTK front end to puzzles. */ +static void changed_preset(frontend *fe); + struct font { #ifdef USE_PANGO PangoFontDescription *desc; @@ -101,14 +143,26 @@ struct frontend { GtkAccelGroup *accelgroup; GtkWidget *area; GtkWidget *statusbar; + GtkWidget *menubar; guint statusctx; - GdkPixmap *pixmap; - GdkColor *colours; - int ncolours; - GdkColormap *colmap; int w, h; midend *me; +#ifdef USE_CAIRO + const float *colours; + cairo_t *cr; + cairo_surface_t *image; +#ifndef USE_CAIRO_WITHOUT_PIXMAP + GdkPixmap *pixmap; +#endif + GdkColor background; /* for painting outside puzzle area */ +#else + GdkPixmap *pixmap; GdkGC *gc; + GdkColor *colours; + GdkColormap *colmap; + int backgroundindex; /* which of colours[] is background */ +#endif + int ncolours; int bbox_l, bbox_r, bbox_u, bbox_d; int timer_active, timer_id; struct timeval last_time; @@ -121,7 +175,27 @@ struct frontend { int paste_data_len; int pw, ph; /* pixmap size (w, h are area size) */ int ox, oy; /* offset of pixmap in drawing area */ +#ifdef OLD_FILESEL char *filesel_name; +#endif + GSList *preset_radio; + int n_preset_menu_items; + int preset_threaded; + GtkWidget *preset_custom; + GtkWidget *copy_menu_item; +#if !GTK_CHECK_VERSION(3,0,0) + int drawing_area_shrink_pending; + int menubar_is_local; +#endif +}; + +struct blitter { +#ifdef USE_CAIRO + cairo_surface_t *image; +#else + GdkPixmap *pixmap; +#endif + int w, h, x, y; }; void get_random_seed(void **randseed, int *randseedsize) @@ -134,10 +208,26 @@ void get_random_seed(void **randseed, int *randseedsize) void frontend_default_colour(frontend *fe, float *output) { - GdkColor col = fe->window->style->bg[GTK_STATE_NORMAL]; +#if !GTK_CHECK_VERSION(3,0,0) + /* + * Use the widget style's default background colour as the + * background for the puzzle drawing area. + */ + GdkColor col = gtk_widget_get_style(fe->window)->bg[GTK_STATE_NORMAL]; output[0] = col.red / 65535.0; output[1] = col.green / 65535.0; output[2] = col.blue / 65535.0; +#else + /* + * GTK 3 has decided that there's no such thing as a 'default + * background colour' any more, because widget styles might set + * the background to something more complicated like a background + * image. We don't want to get into overlaying our entire puzzle + * on an arbitrary background image, so we'll just make up a + * reasonable shade of grey. + */ + output[0] = output[1] = output[2] = 0.9F; +#endif } void gtk_status_bar(void *handle, char *text) @@ -150,213 +240,381 @@ void gtk_status_bar(void *handle, char *text) gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, text); } -void gtk_start_draw(void *handle) +/* ---------------------------------------------------------------------- + * Cairo drawing functions. + */ + +#ifdef USE_CAIRO + +static void setup_drawing(frontend *fe) { - frontend *fe = (frontend *)handle; - 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; + fe->cr = cairo_create(fe->image); + cairo_set_antialias(fe->cr, CAIRO_ANTIALIAS_GRAY); + cairo_set_line_width(fe->cr, 1.0); + cairo_set_line_cap(fe->cr, CAIRO_LINE_CAP_SQUARE); + cairo_set_line_join(fe->cr, CAIRO_LINE_JOIN_ROUND); } -void gtk_clip(void *handle, int x, int y, int w, int h) +static void teardown_drawing(frontend *fe) { - frontend *fe = (frontend *)handle; - GdkRectangle rect; + cairo_destroy(fe->cr); + fe->cr = NULL; - rect.x = x; - rect.y = y; - rect.width = w; - rect.height = h; +#ifndef USE_CAIRO_WITHOUT_PIXMAP + { + cairo_t *cr = gdk_cairo_create(fe->pixmap); + cairo_set_source_surface(cr, fe->image, 0, 0); + cairo_rectangle(cr, + fe->bbox_l - 1, + fe->bbox_u - 1, + fe->bbox_r - fe->bbox_l + 2, + fe->bbox_d - fe->bbox_u + 2); + cairo_fill(cr); + cairo_destroy(cr); + } +#endif +} - gdk_gc_set_clip_rectangle(fe->gc, &rect); +static void snaffle_colours(frontend *fe) +{ + fe->colours = midend_colours(fe->me, &fe->ncolours); } -void gtk_unclip(void *handle) +static void set_colour(frontend *fe, int colour) { - frontend *fe = (frontend *)handle; - GdkRectangle rect; + cairo_set_source_rgb(fe->cr, + fe->colours[3*colour + 0], + fe->colours[3*colour + 1], + fe->colours[3*colour + 2]); +} - rect.x = 0; - rect.y = 0; - rect.width = fe->w; - rect.height = fe->h; +static void set_window_background(frontend *fe, int colour) +{ +#if GTK_CHECK_VERSION(3,0,0) + GdkRGBA rgba; + rgba.red = fe->colours[3*colour + 0]; + rgba.green = fe->colours[3*colour + 1]; + rgba.blue = fe->colours[3*colour + 2]; + rgba.alpha = 1.0; + gdk_window_set_background_rgba(gtk_widget_get_window(fe->area), &rgba); + gdk_window_set_background_rgba(gtk_widget_get_window(fe->window), &rgba); +#else + GdkColormap *colmap; - gdk_gc_set_clip_rectangle(fe->gc, &rect); + colmap = gdk_colormap_get_system(); + fe->background.red = fe->colours[3*colour + 0] * 65535; + fe->background.green = fe->colours[3*colour + 1] * 65535; + fe->background.blue = fe->colours[3*colour + 2] * 65535; + if (!gdk_colormap_alloc_color(colmap, &fe->background, FALSE, FALSE)) { + g_error("couldn't allocate background (#%02x%02x%02x)\n", + fe->background.red >> 8, fe->background.green >> 8, + fe->background.blue >> 8); + } + gdk_window_set_background(gtk_widget_get_window(fe->area), + &fe->background); + gdk_window_set_background(gtk_widget_get_window(fe->window), + &fe->background); +#endif } -void gtk_draw_text(void *handle, int x, int y, int fonttype, int fontsize, - int align, int colour, char *text) +static PangoLayout *make_pango_layout(frontend *fe) +{ + return (pango_cairo_create_layout(fe->cr)); +} + +static void draw_pango_layout(frontend *fe, PangoLayout *layout, + int x, int y) +{ + cairo_move_to(fe->cr, x, y); + pango_cairo_show_layout(fe->cr, layout); +} + +static void save_screenshot_png(frontend *fe, const char *screenshot_file) +{ + cairo_surface_write_to_png(fe->image, screenshot_file); +} + +static void do_clip(frontend *fe, int x, int y, int w, int h) +{ + cairo_new_path(fe->cr); + cairo_rectangle(fe->cr, x, y, w, h); + cairo_clip(fe->cr); +} + +static void do_unclip(frontend *fe) +{ + cairo_reset_clip(fe->cr); +} + +static void do_draw_rect(frontend *fe, int x, int y, int w, int h) +{ + cairo_save(fe->cr); + cairo_new_path(fe->cr); + cairo_set_antialias(fe->cr, CAIRO_ANTIALIAS_NONE); + cairo_rectangle(fe->cr, x, y, w, h); + cairo_fill(fe->cr); + cairo_restore(fe->cr); +} + +static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2) +{ + cairo_new_path(fe->cr); + cairo_move_to(fe->cr, x1 + 0.5, y1 + 0.5); + cairo_line_to(fe->cr, x2 + 0.5, y2 + 0.5); + cairo_stroke(fe->cr); +} + +static void do_draw_thick_line(frontend *fe, float thickness, + float x1, float y1, float x2, float y2) +{ + cairo_save(fe->cr); + cairo_set_line_width(fe->cr, thickness); + cairo_new_path(fe->cr); + cairo_move_to(fe->cr, x1, y1); + cairo_line_to(fe->cr, x2, y2); + cairo_stroke(fe->cr); + cairo_restore(fe->cr); +} + +static void do_draw_poly(frontend *fe, int *coords, int npoints, + int fillcolour, int outlinecolour) { - frontend *fe = (frontend *)handle; 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; + cairo_new_path(fe->cr); + for (i = 0; i < npoints; i++) + cairo_line_to(fe->cr, coords[i*2] + 0.5, coords[i*2 + 1] + 0.5); + cairo_close_path(fe->cr); + if (fillcolour >= 0) { + set_colour(fe, fillcolour); + cairo_fill_preserve(fe->cr); + } + assert(outlinecolour >= 0); + set_colour(fe, outlinecolour); + cairo_stroke(fe->cr); +} - if (i == fe->nfonts) { - if (fe->fontsize <= fe->nfonts) { - fe->fontsize = fe->nfonts + 10; - fe->fonts = sresize(fe->fonts, fe->fontsize, struct font); - } +static void do_draw_circle(frontend *fe, int cx, int cy, int radius, + int fillcolour, int outlinecolour) +{ + cairo_new_path(fe->cr); + cairo_arc(fe->cr, cx + 0.5, cy + 0.5, radius, 0, 2*PI); + cairo_close_path(fe->cr); /* Just in case... */ + if (fillcolour >= 0) { + set_colour(fe, fillcolour); + cairo_fill_preserve(fe->cr); + } + assert(outlinecolour >= 0); + set_colour(fe, outlinecolour); + cairo_stroke(fe->cr); +} - fe->nfonts++; +static void setup_blitter(blitter *bl, int w, int h) +{ + bl->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, w, h); +} - fe->fonts[i].type = fonttype; - fe->fonts[i].size = fontsize; +static void teardown_blitter(blitter *bl) +{ + cairo_surface_destroy(bl->image); +} -#ifdef USE_PANGO - /* - * Use Pango to find the closest match to the requested - * font. - */ - { - PangoFontDescription *fd; - - fd = pango_font_description_new(); - /* `Monospace' and `Sans' are meta-families guaranteed to exist */ - pango_font_description_set_family(fd, fonttype == FONT_FIXED ? - "Monospace" : "Sans"); - pango_font_description_set_weight(fd, PANGO_WEIGHT_BOLD); - /* - * I found some online Pango documentation which - * described a function called - * pango_font_description_set_absolute_size(), which is - * _exactly_ what I want here. Unfortunately, none of - * my local Pango installations have it (presumably - * they're too old), so I'm going to have to hack round - * it by figuring out the point size myself. This - * limits me to X and probably also breaks in later - * Pango installations, so ideally I should add another - * CHECK_VERSION type ifdef and use set_absolute_size - * where available. All very annoying. - */ -#ifdef HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION - pango_font_description_set_absolute_size(fd, PANGO_SCALE*fontsize); -#else - { - Display *d = GDK_DISPLAY(); - int s = DefaultScreen(d); - double resolution = - (PANGO_SCALE * 72.27 / 25.4) * - ((double) DisplayWidthMM(d, s) / DisplayWidth (d, s)); - pango_font_description_set_size(fd, resolution * fontsize); - } +static void do_blitter_save(frontend *fe, blitter *bl, int x, int y) +{ + cairo_t *cr = cairo_create(bl->image); + + cairo_set_source_surface(cr, fe->image, -x, -y); + cairo_paint(cr); + cairo_destroy(cr); +} + +static void do_blitter_load(frontend *fe, blitter *bl, int x, int y) +{ + cairo_set_source_surface(fe->cr, bl->image, x, y); + cairo_paint(fe->cr); +} + +static void clear_backing_store(frontend *fe) +{ + fe->image = NULL; +} + +static void wipe_and_destroy_cairo(frontend *fe, cairo_t *cr) +{ + cairo_set_source_rgb(cr, fe->colours[0], fe->colours[1], fe->colours[2]); + cairo_paint(cr); + cairo_destroy(cr); +} + +static void setup_backing_store(frontend *fe) +{ +#ifndef USE_CAIRO_WITHOUT_PIXMAP + fe->pixmap = gdk_pixmap_new(gtk_widget_get_window(fe->area), + fe->pw, fe->ph, -1); #endif - fe->fonts[i].desc = fd; - } + fe->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, + fe->pw, fe->ph); -#else - /* - * In GTK 1.2, I don't know of any plausible way to - * pick a suitable font, so I'm just going to be - * tedious. - */ - fe->fonts[i].font = gdk_font_load(fonttype == FONT_FIXED ? - "fixed" : "variable"); + wipe_and_destroy_cairo(fe, cairo_create(fe->image)); +#ifndef USE_CAIRO_WITHOUT_PIXMAP + wipe_and_destroy_cairo(fe, gdk_cairo_create(fe->pixmap)); #endif + wipe_and_destroy_cairo(fe, gdk_cairo_create + (gtk_widget_get_window(fe->area))); +} - } +static int backing_store_ok(frontend *fe) +{ + return (!!fe->image); +} - /* - * Set the colour. - */ - gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); +static void teardown_backing_store(frontend *fe) +{ + cairo_surface_destroy(fe->image); +#ifndef USE_CAIRO_WITHOUT_PIXMAP + gdk_pixmap_unref(fe->pixmap); +#endif + fe->image = NULL; +} -#ifdef USE_PANGO +#endif - { - PangoLayout *layout; - PangoRectangle rect; +/* ---------------------------------------------------------------------- + * GDK drawing functions. + */ - /* - * Create a layout. - */ - layout = pango_layout_new(gtk_widget_get_pango_context(fe->area)); - pango_layout_set_font_description(layout, fe->fonts[i].desc); - pango_layout_set_text(layout, text, strlen(text)); - pango_layout_get_pixel_extents(layout, NULL, &rect); +#ifndef USE_CAIRO - if (align & ALIGN_VCENTRE) - rect.y -= rect.height / 2; - else - rect.y -= rect.height; +static void setup_drawing(frontend *fe) +{ + fe->gc = gdk_gc_new(fe->area->window); +} - if (align & ALIGN_HCENTRE) - rect.x -= rect.width / 2; - else if (align & ALIGN_HRIGHT) - rect.x -= rect.width; +static void teardown_drawing(frontend *fe) +{ + gdk_gc_unref(fe->gc); + fe->gc = NULL; +} - gdk_draw_layout(fe->pixmap, fe->gc, rect.x + x, rect.y + y, layout); +static void snaffle_colours(frontend *fe) +{ + int i, ncolours; + float *colours; + gboolean *success; - g_object_unref(layout); + 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); + } + } +} -#else - /* - * Find string dimensions and process alignment. - */ - { - int lb, rb, wid, asc, desc; +static void set_window_background(frontend *fe, int colour) +{ + fe->backgroundindex = colour; + gdk_window_set_background(fe->area->window, &fe->colours[colour]); + gdk_window_set_background(fe->window->window, &fe->colours[colour]); +} - /* - * Measure vertical string extents with respect to the same - * string always... - */ - gdk_string_extents(fe->fonts[i].font, - "ABCDEFGHIJKLMNOPQRSTUVWXYZ", - &lb, &rb, &wid, &asc, &desc); - if (align & ALIGN_VCENTRE) - y += asc - (asc+desc)/2; - else - y += asc; +static void set_colour(frontend *fe, int colour) +{ + gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); +} - /* - * ... but horizontal extents with respect to the provided - * string. This means that multiple pieces of text centred - * on the same y-coordinate don't have different baselines. - */ - gdk_string_extents(fe->fonts[i].font, text, - &lb, &rb, &wid, &asc, &desc); +#ifdef USE_PANGO +static PangoLayout *make_pango_layout(frontend *fe) +{ + return (pango_layout_new(gtk_widget_get_pango_context(fe->area))); +} - if (align & ALIGN_HCENTRE) - x -= wid / 2; - else if (align & ALIGN_HRIGHT) - x -= wid; +static void draw_pango_layout(frontend *fe, PangoLayout *layout, + int x, int y) +{ + gdk_draw_layout(fe->pixmap, fe->gc, x, y, layout); +} +#endif - } +static void save_screenshot_png(frontend *fe, const char *screenshot_file) +{ + GdkPixbuf *pb; + GError *gerror = NULL; - /* - * Actually draw the text. - */ - gdk_draw_string(fe->pixmap, fe->fonts[i].font, fe->gc, x, y, text); -#endif + midend_redraw(fe->me); + pb = gdk_pixbuf_get_from_drawable(NULL, fe->pixmap, + NULL, 0, 0, 0, 0, -1, -1); + gdk_pixbuf_save(pb, screenshot_file, "png", &gerror, NULL); } -void gtk_draw_rect(void *handle, int x, int y, int w, int h, int colour) +static void do_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); +} + +static void do_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); +} + +static void do_draw_rect(frontend *fe, int x, int y, int w, int h) { - frontend *fe = (frontend *)handle; - gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h); } -void gtk_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour) +static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2) { - frontend *fe = (frontend *)handle; - gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2); } -void gtk_draw_poly(void *handle, int *coords, int npoints, - int fillcolour, int outlinecolour) +static void do_draw_thick_line(frontend *fe, float thickness, + float x1, float y1, float x2, float y2) +{ + GdkGCValues save; + + gdk_gc_get_values(fe->gc, &save); + gdk_gc_set_line_attributes(fe->gc, + thickness, + GDK_LINE_SOLID, + GDK_CAP_BUTT, + GDK_JOIN_BEVEL); + gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2); + gdk_gc_set_line_attributes(fe->gc, + save.line_width, + save.line_style, + save.cap_style, + save.join_style); +} + +static void do_draw_poly(frontend *fe, int *coords, int npoints, + int fillcolour, int outlinecolour) { - frontend *fe = (frontend *)handle; GdkPoint *points = snewn(npoints, GdkPoint); int i; @@ -366,11 +624,11 @@ void gtk_draw_poly(void *handle, int *coords, int npoints, } if (fillcolour >= 0) { - gdk_gc_set_foreground(fe->gc, &fe->colours[fillcolour]); + set_colour(fe, fillcolour); gdk_draw_polygon(fe->pixmap, fe->gc, TRUE, points, npoints); } assert(outlinecolour >= 0); - gdk_gc_set_foreground(fe->gc, &fe->colours[outlinecolour]); + set_colour(fe, outlinecolour); /* * In principle we ought to be able to use gdk_draw_polygon for @@ -386,38 +644,361 @@ void gtk_draw_poly(void *handle, int *coords, int npoints, sfree(points); } -void gtk_draw_circle(void *handle, int cx, int cy, int radius, - int fillcolour, int outlinecolour) +static void do_draw_circle(frontend *fe, int cx, int cy, int radius, + int fillcolour, int outlinecolour) { - frontend *fe = (frontend *)handle; if (fillcolour >= 0) { - gdk_gc_set_foreground(fe->gc, &fe->colours[fillcolour]); + set_colour(fe, fillcolour); gdk_draw_arc(fe->pixmap, fe->gc, TRUE, cx - radius, cy - radius, 2 * radius, 2 * radius, 0, 360 * 64); } assert(outlinecolour >= 0); - gdk_gc_set_foreground(fe->gc, &fe->colours[outlinecolour]); + set_colour(fe, outlinecolour); gdk_draw_arc(fe->pixmap, fe->gc, FALSE, cx - radius, cy - radius, 2 * radius, 2 * radius, 0, 360 * 64); } -struct blitter { - GdkPixmap *pixmap; - int w, h, x, y; -}; - -blitter *gtk_blitter_new(void *handle, int w, int h) +static void setup_blitter(blitter *bl, int w, int h) { /* * We can't create the pixmap right now, because fe->window * might not yet exist. So we just cache w and h and create it * during the firs call to blitter_save. */ - blitter *bl = snew(blitter); bl->pixmap = NULL; +} + +static void teardown_blitter(blitter *bl) +{ + if (bl->pixmap) + gdk_pixmap_unref(bl->pixmap); +} + +static void do_blitter_save(frontend *fe, blitter *bl, int x, int y) +{ + if (!bl->pixmap) + bl->pixmap = gdk_pixmap_new(fe->area->window, bl->w, bl->h, -1); + gdk_draw_pixmap(bl->pixmap, + fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], + fe->pixmap, + x, y, 0, 0, bl->w, bl->h); +} + +static void do_blitter_load(frontend *fe, blitter *bl, int x, int y) +{ + assert(bl->pixmap); + gdk_draw_pixmap(fe->pixmap, + fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], + bl->pixmap, + 0, 0, x, y, bl->w, bl->h); +} + +static void clear_backing_store(frontend *fe) +{ + fe->pixmap = NULL; +} + +static void setup_backing_store(frontend *fe) +{ + GdkGC *gc; + + fe->pixmap = gdk_pixmap_new(fe->area->window, fe->pw, fe->ph, -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->pw, fe->ph); + gdk_draw_rectangle(fe->area->window, gc, 1, 0, 0, fe->w, fe->h); + gdk_gc_unref(gc); +} + +static int backing_store_ok(frontend *fe) +{ + return (!!fe->pixmap); +} + +static void teardown_backing_store(frontend *fe) +{ + gdk_pixmap_unref(fe->pixmap); + fe->pixmap = NULL; +} + +#endif + +#ifndef USE_CAIRO_WITHOUT_PIXMAP +static void repaint_rectangle(frontend *fe, GtkWidget *widget, + int x, int y, int w, int h) +{ + GdkGC *gc = gdk_gc_new(gtk_widget_get_window(widget)); +#ifdef USE_CAIRO + gdk_gc_set_foreground(gc, &fe->background); +#else + gdk_gc_set_foreground(gc, &fe->colours[fe->backgroundindex]); +#endif + if (x < fe->ox) { + gdk_draw_rectangle(gtk_widget_get_window(widget), gc, + TRUE, x, y, fe->ox - x, h); + w -= (fe->ox - x); + x = fe->ox; + } + if (y < fe->oy) { + gdk_draw_rectangle(gtk_widget_get_window(widget), gc, + TRUE, x, y, w, fe->oy - y); + h -= (fe->oy - y); + y = fe->oy; + } + if (w > fe->pw) { + gdk_draw_rectangle(gtk_widget_get_window(widget), gc, + TRUE, x + fe->pw, y, w - fe->pw, h); + w = fe->pw; + } + if (h > fe->ph) { + gdk_draw_rectangle(gtk_widget_get_window(widget), gc, + TRUE, x, y + fe->ph, w, h - fe->ph); + h = fe->ph; + } + gdk_draw_pixmap(gtk_widget_get_window(widget), gc, fe->pixmap, + x - fe->ox, y - fe->oy, x, y, w, h); + gdk_gc_unref(gc); +} +#endif + +/* ---------------------------------------------------------------------- + * Pango font functions. + */ + +#ifdef USE_PANGO + +static void add_font(frontend *fe, int index, int fonttype, int fontsize) +{ + /* + * Use Pango to find the closest match to the requested + * font. + */ + PangoFontDescription *fd; + + fd = pango_font_description_new(); + /* `Monospace' and `Sans' are meta-families guaranteed to exist */ + pango_font_description_set_family(fd, fonttype == FONT_FIXED ? + "Monospace" : "Sans"); + pango_font_description_set_weight(fd, PANGO_WEIGHT_BOLD); + /* + * I found some online Pango documentation which + * described a function called + * pango_font_description_set_absolute_size(), which is + * _exactly_ what I want here. Unfortunately, none of + * my local Pango installations have it (presumably + * they're too old), so I'm going to have to hack round + * it by figuring out the point size myself. This + * limits me to X and probably also breaks in later + * Pango installations, so ideally I should add another + * CHECK_VERSION type ifdef and use set_absolute_size + * where available. All very annoying. + */ +#ifdef HAVE_SENSIBLE_ABSOLUTE_SIZE_FUNCTION + pango_font_description_set_absolute_size(fd, PANGO_SCALE*fontsize); +#else + { + Display *d = GDK_DISPLAY(); + int s = DefaultScreen(d); + double resolution = + (PANGO_SCALE * 72.27 / 25.4) * + ((double) DisplayWidthMM(d, s) / DisplayWidth (d, s)); + pango_font_description_set_size(fd, resolution * fontsize); + } +#endif + fe->fonts[index].desc = fd; +} + +static void align_and_draw_text(frontend *fe, + int index, int align, int x, int y, + const char *text) +{ + PangoLayout *layout; + PangoRectangle rect; + + layout = make_pango_layout(fe); + + /* + * Create a layout. + */ + pango_layout_set_font_description(layout, fe->fonts[index].desc); + pango_layout_set_text(layout, text, strlen(text)); + pango_layout_get_pixel_extents(layout, NULL, &rect); + + if (align & ALIGN_VCENTRE) + rect.y -= rect.height / 2; + else + rect.y -= rect.height; + + if (align & ALIGN_HCENTRE) + rect.x -= rect.width / 2; + else if (align & ALIGN_HRIGHT) + rect.x -= rect.width; + + draw_pango_layout(fe, layout, rect.x + x, rect.y + y); + + g_object_unref(layout); +} + +#endif + +/* ---------------------------------------------------------------------- + * Old-fashioned font functions. + */ + +#ifndef USE_PANGO + +static void add_font(int index, int fonttype, int fontsize) +{ + /* + * In GTK 1.2, I don't know of any plausible way to + * pick a suitable font, so I'm just going to be + * tedious. + */ + fe->fonts[i].font = gdk_font_load(fonttype == FONT_FIXED ? + "fixed" : "variable"); +} + +static void align_and_draw_text(int index, int align, int x, int y, + const char *text) +{ + int lb, rb, wid, asc, desc; + + /* + * Measure vertical string extents with respect to the same + * string always... + */ + gdk_string_extents(fe->fonts[i].font, + "ABCDEFGHIJKLMNOPQRSTUVWXYZ", + &lb, &rb, &wid, &asc, &desc); + if (align & ALIGN_VCENTRE) + y += asc - (asc+desc)/2; + else + y += asc; + + /* + * ... but horizontal extents with respect to the provided + * string. This means that multiple pieces of text centred + * on the same y-coordinate don't have different baselines. + */ + gdk_string_extents(fe->fonts[i].font, text, + &lb, &rb, &wid, &asc, &desc); + + if (align & ALIGN_HCENTRE) + x -= wid / 2; + else if (align & ALIGN_HRIGHT) + x -= wid; + + /* + * Actually draw the text. + */ + gdk_draw_string(fe->pixmap, fe->fonts[i].font, fe->gc, x, y, text); +} + +#endif + +/* ---------------------------------------------------------------------- + * The exported drawing functions. + */ + +void gtk_start_draw(void *handle) +{ + frontend *fe = (frontend *)handle; + fe->bbox_l = fe->w; + fe->bbox_r = 0; + fe->bbox_u = fe->h; + fe->bbox_d = 0; + setup_drawing(fe); +} + +void gtk_clip(void *handle, int x, int y, int w, int h) +{ + frontend *fe = (frontend *)handle; + do_clip(fe, x, y, w, h); +} + +void gtk_unclip(void *handle) +{ + frontend *fe = (frontend *)handle; + do_unclip(fe); +} + +void gtk_draw_text(void *handle, int x, int y, int fonttype, int fontsize, + int align, int colour, char *text) +{ + frontend *fe = (frontend *)handle; + 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; + add_font(fe, i, fonttype, fontsize); + } + + /* + * Do the job. + */ + set_colour(fe, colour); + align_and_draw_text(fe, i, align, x, y, text); +} + +void gtk_draw_rect(void *handle, int x, int y, int w, int h, int colour) +{ + frontend *fe = (frontend *)handle; + set_colour(fe, colour); + do_draw_rect(fe, x, y, w, h); +} + +void gtk_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour) +{ + frontend *fe = (frontend *)handle; + set_colour(fe, colour); + do_draw_line(fe, x1, y1, x2, y2); +} + +void gtk_draw_thick_line(void *handle, float thickness, + float x1, float y1, float x2, float y2, int colour) +{ + frontend *fe = (frontend *)handle; + set_colour(fe, colour); + do_draw_thick_line(fe, thickness, x1, y1, x2, y2); +} + +void gtk_draw_poly(void *handle, int *coords, int npoints, + int fillcolour, int outlinecolour) +{ + frontend *fe = (frontend *)handle; + do_draw_poly(fe, coords, npoints, fillcolour, outlinecolour); +} + +void gtk_draw_circle(void *handle, int cx, int cy, int radius, + int fillcolour, int outlinecolour) +{ + frontend *fe = (frontend *)handle; + do_draw_circle(fe, cx, cy, radius, fillcolour, outlinecolour); +} + +blitter *gtk_blitter_new(void *handle, int w, int h) +{ + blitter *bl = snew(blitter); + setup_blitter(bl, w, h); bl->w = w; bl->h = h; return bl; @@ -425,36 +1006,26 @@ blitter *gtk_blitter_new(void *handle, int w, int h) void gtk_blitter_free(void *handle, blitter *bl) { - if (bl->pixmap) - gdk_pixmap_unref(bl->pixmap); + teardown_blitter(bl); sfree(bl); } void gtk_blitter_save(void *handle, blitter *bl, int x, int y) { frontend *fe = (frontend *)handle; - if (!bl->pixmap) - bl->pixmap = gdk_pixmap_new(fe->area->window, bl->w, bl->h, -1); + do_blitter_save(fe, bl, x, y); bl->x = x; bl->y = y; - gdk_draw_pixmap(bl->pixmap, - fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], - fe->pixmap, - x, y, 0, 0, bl->w, bl->h); } void gtk_blitter_load(void *handle, blitter *bl, int x, int y) { frontend *fe = (frontend *)handle; - assert(bl->pixmap); if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) { x = bl->x; y = bl->y; } - gdk_draw_pixmap(fe->pixmap, - fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], - bl->pixmap, - 0, 0, x, y, bl->w, bl->h); + do_blitter_load(fe, bl, x, y); } void gtk_draw_update(void *handle, int x, int y, int w, int h) @@ -469,19 +1040,37 @@ void gtk_draw_update(void *handle, int x, int y, int w, int h) void gtk_end_draw(void *handle) { frontend *fe = (frontend *)handle; - gdk_gc_unref(fe->gc); - fe->gc = NULL; + + teardown_drawing(fe); 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->ox + fe->bbox_l, fe->oy + fe->bbox_u, - fe->bbox_r - fe->bbox_l, fe->bbox_d - fe->bbox_u); +#ifdef USE_CAIRO_WITHOUT_PIXMAP + gtk_widget_queue_draw_area(fe->area, + fe->bbox_l - 1 + fe->ox, + fe->bbox_u - 1 + fe->oy, + fe->bbox_r - fe->bbox_l + 2, + fe->bbox_d - fe->bbox_u + 2); +#else + repaint_rectangle(fe, fe->area, + fe->bbox_l - 1 + fe->ox, + fe->bbox_u - 1 + fe->oy, + fe->bbox_r - fe->bbox_l + 2, + fe->bbox_d - fe->bbox_u + 2); +#endif } } +#ifdef USE_PANGO +char *gtk_text_fallback(void *handle, const char *const *strings, int nstrings) +{ + /* + * We assume Pango can cope with any UTF-8 likely to be emitted + * by a puzzle. + */ + return dupstr(strings[0]); +} +#endif + const struct drawing_api gtk_drawing = { gtk_draw_text, gtk_draw_rect, @@ -499,7 +1088,17 @@ const struct drawing_api gtk_drawing = { gtk_blitter_save, gtk_blitter_load, NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */ - NULL, /* line_width */ + NULL, NULL, /* line_width, line_dotted */ +#ifdef USE_PANGO + gtk_text_fallback, +#else + NULL, +#endif +#ifdef NO_THICK_LINE + NULL, +#else + gtk_draw_thick_line, +#endif }; static void destroy(GtkWidget *widget, gpointer data) @@ -517,7 +1116,7 @@ static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data) int shift = (event->state & GDK_SHIFT_MASK) ? MOD_SHFT : 0; int ctrl = (event->state & GDK_CONTROL_MASK) ? MOD_CTRL : 0; - if (!fe->pixmap) + if (!backing_store_ok(fe)) return TRUE; #if !GTK_CHECK_VERSION(2,0,0) @@ -530,37 +1129,51 @@ static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data) return TRUE; #endif - if (event->keyval == GDK_Up) + /* Handle mnemonics. */ + if (gtk_window_activate_key(GTK_WINDOW(fe->window), event)) + return TRUE; + + if (event->keyval == GDK_KEY_Up) keyval = shift | ctrl | CURSOR_UP; - else if (event->keyval == GDK_KP_Up || event->keyval == GDK_KP_8) + else if (event->keyval == GDK_KEY_KP_Up || + event->keyval == GDK_KEY_KP_8) keyval = MOD_NUM_KEYPAD | '8'; - else if (event->keyval == GDK_Down) + else if (event->keyval == GDK_KEY_Down) keyval = shift | ctrl | CURSOR_DOWN; - else if (event->keyval == GDK_KP_Down || event->keyval == GDK_KP_2) + else if (event->keyval == GDK_KEY_KP_Down || + event->keyval == GDK_KEY_KP_2) keyval = MOD_NUM_KEYPAD | '2'; - else if (event->keyval == GDK_Left) + else if (event->keyval == GDK_KEY_Left) keyval = shift | ctrl | CURSOR_LEFT; - else if (event->keyval == GDK_KP_Left || event->keyval == GDK_KP_4) + else if (event->keyval == GDK_KEY_KP_Left || + event->keyval == GDK_KEY_KP_4) keyval = MOD_NUM_KEYPAD | '4'; - else if (event->keyval == GDK_Right) + else if (event->keyval == GDK_KEY_Right) keyval = shift | ctrl | CURSOR_RIGHT; - else if (event->keyval == GDK_KP_Right || event->keyval == GDK_KP_6) + else if (event->keyval == GDK_KEY_KP_Right || + event->keyval == GDK_KEY_KP_6) keyval = MOD_NUM_KEYPAD | '6'; - else if (event->keyval == GDK_KP_Home || event->keyval == GDK_KP_7) + else if (event->keyval == GDK_KEY_KP_Home || + event->keyval == GDK_KEY_KP_7) keyval = MOD_NUM_KEYPAD | '7'; - else if (event->keyval == GDK_KP_End || event->keyval == GDK_KP_1) + else if (event->keyval == GDK_KEY_KP_End || + event->keyval == GDK_KEY_KP_1) keyval = MOD_NUM_KEYPAD | '1'; - else if (event->keyval == GDK_KP_Page_Up || event->keyval == GDK_KP_9) + else if (event->keyval == GDK_KEY_KP_Page_Up || + event->keyval == GDK_KEY_KP_9) keyval = MOD_NUM_KEYPAD | '9'; - else if (event->keyval == GDK_KP_Page_Down || event->keyval == GDK_KP_3) + else if (event->keyval == GDK_KEY_KP_Page_Down || + event->keyval == GDK_KEY_KP_3) keyval = MOD_NUM_KEYPAD | '3'; - else if (event->keyval == GDK_KP_Insert || event->keyval == GDK_KP_0) + else if (event->keyval == GDK_KEY_KP_Insert || + event->keyval == GDK_KEY_KP_0) keyval = MOD_NUM_KEYPAD | '0'; - else if (event->keyval == GDK_KP_Begin || event->keyval == GDK_KP_5) + else if (event->keyval == GDK_KEY_KP_Begin || + event->keyval == GDK_KEY_KP_5) keyval = MOD_NUM_KEYPAD | '5'; - else if (event->keyval == GDK_BackSpace || - event->keyval == GDK_Delete || - event->keyval == GDK_KP_Delete) + else if (event->keyval == GDK_KEY_BackSpace || + event->keyval == GDK_KEY_Delete || + event->keyval == GDK_KEY_KP_Delete) keyval = '\177'; else if (event->string[0] && !event->string[1]) keyval = (unsigned char)event->string[0]; @@ -580,7 +1193,7 @@ static gint button_event(GtkWidget *widget, GdkEventButton *event, frontend *fe = (frontend *)data; int button; - if (!fe->pixmap) + if (!backing_store_ok(fe)) return TRUE; if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE) @@ -592,10 +1205,14 @@ static gint button_event(GtkWidget *widget, GdkEventButton *event, button = RIGHT_BUTTON; else if (event->button == 1) button = LEFT_BUTTON; + else if (event->button == 8 && event->type == GDK_BUTTON_PRESS) + button = 'u'; + else if (event->button == 9 && event->type == GDK_BUTTON_PRESS) + button = 'r'; else return FALSE; /* don't even know what button! */ - if (event->type == GDK_BUTTON_RELEASE) + if (event->type == GDK_BUTTON_RELEASE && button >= LEFT_BUTTON) button += LEFT_RELEASE - LEFT_BUTTON; if (!midend_process_key(fe->me, event->x - fe->ox, @@ -611,7 +1228,7 @@ static gint motion_event(GtkWidget *widget, GdkEventMotion *event, frontend *fe = (frontend *)data; int button; - if (!fe->pixmap) + if (!backing_store_ok(fe)) return TRUE; if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK)) @@ -626,25 +1243,52 @@ static gint motion_event(GtkWidget *widget, GdkEventMotion *event, if (!midend_process_key(fe->me, event->x - fe->ox, event->y - fe->oy, button)) gtk_widget_destroy(fe->window); +#if GTK_CHECK_VERSION(2,12,0) + gdk_event_request_motions(event); +#else + gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, NULL); +#endif return TRUE; } +#if GTK_CHECK_VERSION(3,0,0) +static gint draw_area(GtkWidget *widget, cairo_t *cr, gpointer data) +{ + frontend *fe = (frontend *)data; + GdkRectangle dirtyrect; + + gdk_cairo_get_clip_rectangle(cr, &dirtyrect); + cairo_set_source_surface(cr, fe->image, fe->ox, fe->oy); + cairo_rectangle(cr, dirtyrect.x, dirtyrect.y, + dirtyrect.width, dirtyrect.height); + cairo_fill(cr); + + return TRUE; +} +#else 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 - fe->ox, event->area.y - fe->oy, - event->area.x, event->area.y, - event->area.width, event->area.height); + if (backing_store_ok(fe)) { +#ifdef USE_CAIRO_WITHOUT_PIXMAP + cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget)); + cairo_set_source_surface(cr, fe->image, fe->ox, fe->oy); + cairo_rectangle(cr, event->area.x, event->area.y, + event->area.width, event->area.height); + cairo_fill(cr); + cairo_destroy(cr); +#else + repaint_rectangle(fe, widget, + event->area.x, event->area.y, + event->area.width, event->area.height); +#endif } return TRUE; } +#endif static gint map_window(GtkWidget *widget, GdkEvent *event, gpointer data) @@ -665,28 +1309,25 @@ static gint configure_area(GtkWidget *widget, GdkEventConfigure *event, gpointer data) { frontend *fe = (frontend *)data; - GdkGC *gc; int x, y; + int oldw = fe->w, oldpw = fe->pw, oldh = fe->h, oldph = fe->ph; - if (fe->pixmap) - gdk_pixmap_unref(fe->pixmap); - - x = fe->w = event->width; - y = fe->h = event->height; + x = event->width; + y = event->height; + fe->w = x; + fe->h = y; midend_size(fe->me, &x, &y, TRUE); fe->pw = x; fe->ph = y; fe->ox = (fe->w - fe->pw) / 2; fe->oy = (fe->h - fe->ph) / 2; - fe->pixmap = gdk_pixmap_new(widget->window, fe->pw, fe->ph, -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->pw, fe->ph); - gdk_draw_rectangle(widget->window, gc, 1, 0, 0, - event->width, event->height); - gdk_gc_unref(gc); + if (oldw != fe->w || oldpw != fe->pw || + oldh != fe->h || oldph != fe->ph || !backing_store_ok(fe)) { + if (backing_store_ok(fe)) + teardown_backing_store(fe); + setup_backing_store(fe); + } midend_force_redraw(fe->me); @@ -715,7 +1356,7 @@ void deactivate_timer(frontend *fe) if (!fe) return; /* can happen due to --generate */ if (fe->timer_active) - gtk_timeout_remove(fe->timer_id); + g_source_remove(fe->timer_id); fe->timer_active = FALSE; } @@ -724,38 +1365,26 @@ void activate_timer(frontend *fe) if (!fe) return; /* can happen due to --generate */ if (!fe->timer_active) { - fe->timer_id = gtk_timeout_add(20, timer_func, fe); + fe->timer_id = g_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 msgbox_button_clicked(GtkButton *button, gpointer data) -{ - GtkWidget *window = GTK_WIDGET(data); - int v, *ip; - - ip = (int *)gtk_object_get_data(GTK_OBJECT(window), "user-data"); - v = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(button), "user-data")); - *ip = v; - - gtk_widget_destroy(GTK_WIDGET(data)); +static void window_destroy(GtkWidget *widget, gpointer data) +{ + gtk_main_quit(); } static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) { - GtkObject *cancelbutton = GTK_OBJECT(data); + GObject *cancelbutton = G_OBJECT(data); /* * `Escape' effectively clicks the cancel button */ - if (event->keyval == GDK_Escape) { - gtk_signal_emit_by_name(GTK_OBJECT(cancelbutton), "clicked"); + if (event->keyval == GDK_KEY_Escape) { + g_signal_emit_by_name(cancelbutton, "clicked"); return TRUE; } @@ -764,6 +1393,47 @@ static int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) enum { MB_OK, MB_YESNO }; +static void align_label(GtkLabel *label, double x, double y) +{ +#if GTK_CHECK_VERSION(3,16,0) + gtk_label_set_xalign(label, x); + gtk_label_set_yalign(label, y); +#else + gtk_misc_set_alignment(GTK_MISC(label), x, y); +#endif +} + +#if GTK_CHECK_VERSION(3,0,0) +int message_box(GtkWidget *parent, char *title, char *msg, int centre, + int type) +{ + GtkWidget *window; + gint ret; + + window = gtk_message_dialog_new + (GTK_WINDOW(parent), + (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), + (type == MB_OK ? GTK_MESSAGE_INFO : GTK_MESSAGE_QUESTION), + (type == MB_OK ? GTK_BUTTONS_OK : GTK_BUTTONS_YES_NO), + "%s", msg); + gtk_window_set_title(GTK_WINDOW(window), title); + ret = gtk_dialog_run(GTK_DIALOG(window)); + gtk_widget_destroy(window); + return (type == MB_OK ? TRUE : (ret == GTK_RESPONSE_YES)); +} +#else /* GTK_CHECK_VERSION(3,0,0) */ +static void msgbox_button_clicked(GtkButton *button, gpointer data) +{ + GtkWidget *window = GTK_WIDGET(data); + int v, *ip; + + ip = (int *)g_object_get_data(G_OBJECT(window), "user-data"); + v = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "user-data")); + *ip = v; + + gtk_widget_destroy(GTK_WIDGET(data)); +} + int message_box(GtkWidget *parent, char *title, char *msg, int centre, int type) { @@ -773,59 +1443,61 @@ int message_box(GtkWidget *parent, char *title, char *msg, int centre, window = gtk_dialog_new(); text = gtk_label_new(msg); - gtk_misc_set_alignment(GTK_MISC(text), 0.0, 0.0); + align_label(GTK_LABEL(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_box_pack_start + (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window))), + hbox, FALSE, FALSE, 20); gtk_widget_show(text); gtk_widget_show(hbox); gtk_window_set_title(GTK_WINDOW(window), title); gtk_label_set_line_wrap(GTK_LABEL(text), TRUE); if (type == MB_OK) { - titles = "OK\0"; + titles = LABEL_OK "\0"; def = cancel = 0; } else { assert(type == MB_YESNO); - titles = "Yes\0No\0"; - def = 0; - cancel = 1; + titles = LABEL_NO "\0" LABEL_YES "\0"; + def = 1; + cancel = 0; } i = 0; while (*titles) { - button = gtk_button_new_with_label(titles); - gtk_box_pack_end(GTK_BOX(GTK_DIALOG(window)->action_area), - button, FALSE, FALSE, 0); + button = gtk_button_new_with_our_label(titles); + gtk_box_pack_end + (GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(window))), + button, FALSE, FALSE, 0); gtk_widget_show(button); if (i == def) { - GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); + gtk_widget_set_can_default(button, TRUE); gtk_window_set_default(GTK_WINDOW(window), button); } if (i == cancel) { - gtk_signal_connect(GTK_OBJECT(window), "key_press_event", - GTK_SIGNAL_FUNC(win_key_press), button); + g_signal_connect(G_OBJECT(window), "key_press_event", + G_CALLBACK(win_key_press), button); } - gtk_signal_connect(GTK_OBJECT(button), "clicked", - GTK_SIGNAL_FUNC(msgbox_button_clicked), window); - gtk_object_set_data(GTK_OBJECT(button), "user-data", - GINT_TO_POINTER(i)); + g_signal_connect(G_OBJECT(button), "clicked", + G_CALLBACK(msgbox_button_clicked), window); + g_object_set_data(G_OBJECT(button), "user-data", + GINT_TO_POINTER(i)); titles += strlen(titles)+1; i++; } - gtk_object_set_data(GTK_OBJECT(window), "user-data", - GINT_TO_POINTER(&i)); - gtk_signal_connect(GTK_OBJECT(window), "destroy", - GTK_SIGNAL_FUNC(window_destroy), NULL); + g_object_set_data(G_OBJECT(window), "user-data", &i); + g_signal_connect(G_OBJECT(window), "destroy", + G_CALLBACK(window_destroy), NULL); 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); i = -1; gtk_main(); - return (type == MB_YESNO ? i == 0 : TRUE); + return (type == MB_YESNO ? i == 1 : TRUE); } +#endif /* GTK_CHECK_VERSION(3,0,0) */ void error_box(GtkWidget *parent, char *msg) { @@ -844,6 +1516,7 @@ static void config_ok_button_clicked(GtkButton *button, gpointer data) else { fe->cfgret = TRUE; gtk_widget_destroy(fe->cfgbox); + changed_preset(fe); } } @@ -865,11 +1538,12 @@ static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data) * 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) { + if (event->keyval == GDK_KEY_Return && + gtk_widget_get_parent(widget) != 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); + g_signal_stop_emission_by_name(G_OBJECT(widget), "key_press_event"); + g_signal_emit_by_name(G_OBJECT(gtk_widget_get_parent(widget)), + "key_press_event", event, &return_val); return return_val; } return FALSE; @@ -890,17 +1564,17 @@ static void button_toggled(GtkToggleButton *tb, gpointer data) i->ival = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb)); } -static void droplist_sel(GtkMenuItem *item, gpointer data) +static void droplist_sel(GtkComboBox *combo, gpointer data) { config_item *i = (config_item *)data; - i->ival = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item), - "user-data")); + i->ival = gtk_combo_box_get_active(combo); } static int get_config(frontend *fe, int which) { GtkWidget *w, *table, *cancel; + GtkBox *content_box, *button_box; char *title; config_item *i; int y; @@ -909,35 +1583,57 @@ static int get_config(frontend *fe, int which) fe->cfg_which = which; fe->cfgret = FALSE; +#if GTK_CHECK_VERSION(3,0,0) + /* GtkDialog isn't quite flexible enough */ + fe->cfgbox = gtk_window_new(GTK_WINDOW_TOPLEVEL); + content_box = GTK_BOX(gtk_vbox_new(FALSE, 8)); + g_object_set(G_OBJECT(content_box), "margin", 8, (const char *)NULL); + gtk_widget_show(GTK_WIDGET(content_box)); + gtk_container_add(GTK_CONTAINER(fe->cfgbox), GTK_WIDGET(content_box)); + button_box = GTK_BOX(gtk_hbox_new(FALSE, 8)); + gtk_widget_show(GTK_WIDGET(button_box)); + gtk_box_pack_end(content_box, GTK_WIDGET(button_box), FALSE, FALSE, 0); + { + GtkWidget *sep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); + gtk_widget_show(sep); + gtk_box_pack_end(content_box, sep, FALSE, FALSE, 0); + } +#else fe->cfgbox = gtk_dialog_new(); + content_box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(fe->cfgbox))); + button_box = GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(fe->cfgbox))); +#endif 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); + w = gtk_button_new_with_our_label(LABEL_CANCEL); + gtk_box_pack_end(button_box, 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); + g_signal_connect(G_OBJECT(w), "clicked", + G_CALLBACK(config_cancel_button_clicked), fe); + cancel = w; - w = gtk_button_new_with_label("Cancel"); - gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->action_area), - w, FALSE, FALSE, 0); + w = gtk_button_new_with_our_label(LABEL_OK); + gtk_box_pack_end(button_box, 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; + gtk_widget_set_can_default(w, TRUE); + gtk_window_set_default(GTK_WINDOW(fe->cfgbox), w); + g_signal_connect(G_OBJECT(w), "clicked", + G_CALLBACK(config_ok_button_clicked), fe); +#if GTK_CHECK_VERSION(3,0,0) + table = gtk_grid_new(); +#else table = gtk_table_new(1, 2, FALSE); +#endif y = 0; - gtk_box_pack_end(GTK_BOX(GTK_DIALOG(fe->cfgbox)->vbox), - table, FALSE, FALSE, 0); + gtk_box_pack_start(content_box, table, FALSE, FALSE, 0); gtk_widget_show(table); for (i = fe->cfg; i->type != C_END; i++) { +#if !GTK_CHECK_VERSION(3,0,0) gtk_table_resize(GTK_TABLE(table), y+1, 2); +#endif switch (i->type) { case C_STRING: @@ -946,23 +1642,32 @@ static int get_config(frontend *fe, int which) */ w = gtk_label_new(i->name); - gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5); + align_label(GTK_LABEL(w), 0.0, 0.5); +#if GTK_CHECK_VERSION(3,0,0) + gtk_grid_attach(GTK_GRID(table), w, 0, y, 1, 1); +#else gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1, - GTK_EXPAND | GTK_SHRINK | GTK_FILL, + GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); +#endif gtk_widget_show(w); w = gtk_entry_new(); +#if GTK_CHECK_VERSION(3,0,0) + gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1); + g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL); +#else 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); +#endif 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); + g_signal_connect(G_OBJECT(w), "changed", + G_CALLBACK(editbox_changed), i); + g_signal_connect(G_OBJECT(w), "key_press_event", + G_CALLBACK(editbox_key), NULL); gtk_widget_show(w); break; @@ -972,47 +1677,49 @@ static int get_config(frontend *fe, int which) * Simple checkbox. */ w = gtk_check_button_new_with_label(i->name); - gtk_signal_connect(GTK_OBJECT(w), "toggled", - GTK_SIGNAL_FUNC(button_toggled), i); + g_signal_connect(G_OBJECT(w), "toggled", + G_CALLBACK(button_toggled), i); +#if GTK_CHECK_VERSION(3,0,0) + gtk_grid_attach(GTK_GRID(table), w, 0, y, 2, 1); + g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL); +#else 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); +#endif gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), i->ival); gtk_widget_show(w); break; case C_CHOICES: /* - * Drop-down list (GtkOptionMenu). + * Drop-down list (GtkComboBox). */ w = gtk_label_new(i->name); - gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5); + align_label(GTK_LABEL(w), 0.0, 0.5); +#if GTK_CHECK_VERSION(3,0,0) + gtk_grid_attach(GTK_GRID(table), w, 0, y, 1, 1); +#else 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, + GTK_SHRINK | GTK_FILL, + GTK_EXPAND | GTK_SHRINK | GTK_FILL , 3, 3); +#endif gtk_widget_show(w); - { - int c, val; + { + int c; char *p, *q, *name; - GtkWidget *menuitem; - GtkWidget *menu = gtk_menu_new(); + GtkListStore *model; + GtkCellRenderer *cr; + GtkTreeIter iter; - gtk_option_menu_set_menu(GTK_OPTION_MENU(w), menu); + model = gtk_list_store_new(1, G_TYPE_STRING); c = *i->sval; p = i->sval+1; - val = 0; while (*p) { q = p; @@ -1025,32 +1732,45 @@ static int get_config(frontend *fe, int which) 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++; + gtk_list_store_append(model, &iter); + gtk_list_store_set(model, &iter, 0, name, -1); p = q; } - gtk_option_menu_set_history(GTK_OPTION_MENU(w), i->ival); - } + w = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); + + gtk_combo_box_set_active(GTK_COMBO_BOX(w), i->ival); + cr = gtk_cell_renderer_text_new(); + gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(w), cr, TRUE); + gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(w), cr, + "text", 0, NULL); + + g_signal_connect(G_OBJECT(w), "changed", + G_CALLBACK(droplist_sel), i); + } + +#if GTK_CHECK_VERSION(3,0,0) + gtk_grid_attach(GTK_GRID(table), w, 1, y, 1, 1); + g_object_set(G_OBJECT(w), "hexpand", TRUE, (const char *)NULL); +#else + 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); +#endif + gtk_widget_show(w); 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); + g_signal_connect(G_OBJECT(fe->cfgbox), "destroy", + G_CALLBACK(window_destroy), NULL); + g_signal_connect(G_OBJECT(fe->cfgbox), "key_press_event", + G_CALLBACK(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)); @@ -1066,8 +1786,8 @@ static int get_config(frontend *fe, int which) 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")); + int key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), + "user-data")); if (!midend_process_key(fe->me, 0, 0, key)) gtk_widget_destroy(fe->window); } @@ -1100,118 +1820,195 @@ static void get_size(frontend *fe, int *px, int *py) gdk_window_resize(GTK_WIDGET(win)->window, x, y) #endif +/* + * Called when any other code in this file has changed the + * selected game parameters. + */ +static void changed_preset(frontend *fe) +{ + int n = midend_which_preset(fe->me); + + fe->preset_threaded = TRUE; + if (n < 0 && fe->preset_custom) { + gtk_check_menu_item_set_active( + GTK_CHECK_MENU_ITEM(fe->preset_custom), + TRUE); + } else { + GSList *gs = fe->preset_radio; + int i = fe->n_preset_menu_items - 1 - n; + if (fe->preset_custom) + gs = gs->next; + while (i && gs) { + i--; + gs = gs->next; + } + if (gs) { + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gs->data), + TRUE); + } else for (gs = fe->preset_radio; gs; gs = gs->next) { + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gs->data), + FALSE); + } + } + fe->preset_threaded = FALSE; + + /* + * Update the greying on the Copy menu option. + */ + if (fe->copy_menu_item) { + int enabled = midend_can_format_as_text_now(fe->me); + gtk_widget_set_sensitive(fe->copy_menu_item, enabled); + } +} + +#if !GTK_CHECK_VERSION(3,0,0) +static gboolean not_size_allocated_yet(GtkWidget *w) +{ + /* + * This function tests whether a widget has not yet taken up space + * on the screen which it will occupy in future. (Therefore, it + * returns true only if the widget does exist but does not have a + * size allocation. A null widget is already taking up all the + * space it ever will.) + */ + if (!w) + return FALSE; /* nonexistent widgets aren't a problem */ + +#if GTK_CHECK_VERSION(2,18,0) /* skip if no gtk_widget_get_allocation */ + { + GtkAllocation a; + gtk_widget_get_allocation(w, &a); + if (a.height == 0 || a.width == 0) + return TRUE; /* widget exists but has no size yet */ + } +#endif + + return FALSE; +} + +static void try_shrink_drawing_area(frontend *fe) +{ + if (fe->drawing_area_shrink_pending && + (!fe->menubar_is_local || !not_size_allocated_yet(fe->menubar)) && + !not_size_allocated_yet(fe->statusbar)) { + /* + * In order to permit the user to resize the window smaller as + * well as bigger, we call this function after the window size + * has ended up where we want it. This shouldn't shrink the + * window immediately; it just arranges that the next time the + * user tries to shrink it, they can. + * + * However, at puzzle creation time, we defer the first of + * these operations until after the menu bar and status bar + * are actually visible. On Ubuntu 12.04 I've found that these + * can take a while to be displayed, and that it's a mistake + * to reduce the drawing area's size allocation before they've + * turned up or else the drawing area makes room for them by + * shrinking to less than the size we intended. + */ + gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), 1, 1); + fe->drawing_area_shrink_pending = FALSE; + } +} +#endif /* !GTK_CHECK_VERSION(3,0,0) */ + +static gint configure_window(GtkWidget *widget, + GdkEventConfigure *event, gpointer data) +{ +#if !GTK_CHECK_VERSION(3,0,0) + /* + * When the main puzzle window changes size, it might be because + * the menu bar or status bar has turned up after starting off + * absent, in which case we should have another go at enacting a + * pending shrink of the drawing area. + */ + frontend *fe = (frontend *)data; + try_shrink_drawing_area(fe); +#endif + return FALSE; +} + static void resize_fe(frontend *fe) { int x, y; get_size(fe, &x, &y); - fe->w = x; - fe->h = y; + +#if GTK_CHECK_VERSION(3,0,0) + gtk_window_resize_to_geometry(GTK_WINDOW(fe->window), x, y); +#else + fe->drawing_area_shrink_pending = FALSE; gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y); { GtkRequisition req; gtk_widget_size_request(GTK_WIDGET(fe->window), &req); gtk_window_resize(GTK_WINDOW(fe->window), req.width, req.height); } - /* - * Now that we've established the preferred size of the window, - * reduce the drawing area's size request so the user can shrink - * the window. - */ - gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), 1, 1); + fe->drawing_area_shrink_pending = TRUE; + try_shrink_drawing_area(fe); +#endif } 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"); + (game_params *)g_object_get_data(G_OBJECT(menuitem), "user-data"); + if (fe->preset_threaded || + (GTK_IS_CHECK_MENU_ITEM(menuitem) && + !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)))) + return; midend_set_params(fe->me, params); midend_new_game(fe->me); + changed_preset(fe); resize_fe(fe); } GdkAtom compound_text_atom, utf8_string_atom; int paste_initialised = FALSE; -void init_paste() +static void set_selection(frontend *fe, GdkAtom selection) { - unsigned char empty[] = { 0 }; - - if (paste_initialised) - return; - - if (!compound_text_atom) - compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE); - if (!utf8_string_atom) - utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE); + if (!paste_initialised) { + compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE); + utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE); + paste_initialised = TRUE; + } /* - * Ensure that all the cut buffers exist - according to the - * ICCCM, we must do this before we start using cut buffers. + * For this simple application we can safely assume that the + * data passed to this function is pure ASCII, which means we + * can return precisely the same stuff for types STRING, + * COMPOUND_TEXT or UTF8_STRING. */ - XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), - XA_CUT_BUFFER0, XA_STRING, 8, PropModeAppend, empty, 0); - XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), - XA_CUT_BUFFER1, XA_STRING, 8, PropModeAppend, empty, 0); - XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), - XA_CUT_BUFFER2, XA_STRING, 8, PropModeAppend, empty, 0); - XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), - XA_CUT_BUFFER3, XA_STRING, 8, PropModeAppend, empty, 0); - XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), - XA_CUT_BUFFER4, XA_STRING, 8, PropModeAppend, empty, 0); - XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), - XA_CUT_BUFFER5, XA_STRING, 8, PropModeAppend, empty, 0); - XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), - XA_CUT_BUFFER6, XA_STRING, 8, PropModeAppend, empty, 0); - XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), - XA_CUT_BUFFER7, XA_STRING, 8, PropModeAppend, empty, 0); -} - -/* Store data in a cut-buffer. */ -void store_cutbuffer(char *ptr, int len) -{ - /* ICCCM says we must rotate the buffers before storing to buffer 0. */ - XRotateBuffers(GDK_DISPLAY(), 1); - XStoreBytes(GDK_DISPLAY(), ptr, len); + + if (gtk_selection_owner_set(fe->area, selection, CurrentTime)) { + gtk_selection_clear_targets(fe->area, selection); + gtk_selection_add_target(fe->area, selection, + GDK_SELECTION_TYPE_STRING, 1); + gtk_selection_add_target(fe->area, selection, compound_text_atom, 1); + gtk_selection_add_target(fe->area, selection, utf8_string_atom, 1); + } } void write_clip(frontend *fe, char *data) { - init_paste(); - if (fe->paste_data) sfree(fe->paste_data); - /* - * For this simple application we can safely assume that the - * data passed to this function is pure ASCII, which means we - * can return precisely the same stuff for types STRING, - * COMPOUND_TEXT or UTF8_STRING. - */ - fe->paste_data = data; fe->paste_data_len = strlen(data); - store_cutbuffer(fe->paste_data, fe->paste_data_len); - - if (gtk_selection_owner_set(fe->area, GDK_SELECTION_PRIMARY, - CurrentTime)) { - gtk_selection_add_target(fe->area, GDK_SELECTION_PRIMARY, - GDK_SELECTION_TYPE_STRING, 1); - gtk_selection_add_target(fe->area, GDK_SELECTION_PRIMARY, - compound_text_atom, 1); - gtk_selection_add_target(fe->area, GDK_SELECTION_PRIMARY, - utf8_string_atom, 1); - } + set_selection(fe, GDK_SELECTION_PRIMARY); + set_selection(fe, GDK_SELECTION_CLIPBOARD); } void selection_get(GtkWidget *widget, GtkSelectionData *seldata, guint info, guint time_stamp, gpointer data) { frontend *fe = (frontend *)data; - gtk_selection_data_set(seldata, seldata->target, 8, + gtk_selection_data_set(seldata, gtk_selection_data_get_target(seldata), 8, fe->paste_data, fe->paste_data_len); } @@ -1241,11 +2038,13 @@ static void menu_copy_event(GtkMenuItem *menuitem, gpointer data) } } +#ifdef OLD_FILESEL + static void filesel_ok(GtkButton *button, gpointer data) { frontend *fe = (frontend *)data; - gpointer filesel = gtk_object_get_data(GTK_OBJECT(button), "user-data"); + gpointer filesel = g_object_get_data(G_OBJECT(button), "user-data"); const char *name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel)); @@ -1261,20 +2060,20 @@ static char *file_selector(frontend *fe, char *title, int save) fe->filesel_name = NULL; gtk_window_set_modal(GTK_WINDOW(filesel), TRUE); - gtk_object_set_data - (GTK_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "user-data", + g_object_set_data + (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "user-data", (gpointer)filesel); - gtk_signal_connect - (GTK_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", - GTK_SIGNAL_FUNC(filesel_ok), fe); - gtk_signal_connect_object - (GTK_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", - GTK_SIGNAL_FUNC(gtk_widget_destroy), (gpointer)filesel); - gtk_signal_connect_object - (GTK_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button), "clicked", - GTK_SIGNAL_FUNC(gtk_widget_destroy), (gpointer)filesel); - gtk_signal_connect(GTK_OBJECT(filesel), "destroy", - GTK_SIGNAL_FUNC(window_destroy), NULL); + g_signal_connect + (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", + G_CALLBACK(filesel_ok), fe); + g_signal_connect_swapped + (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", + G_CALLBACK(gtk_widget_destroy), (gpointer)filesel); + g_signal_connect_object + (G_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button), "clicked", + G_CALLBACK(gtk_widget_destroy), (gpointer)filesel); + g_signal_connect(G_OBJECT(filesel), "destroy", + G_CALLBACK(window_destroy), NULL); gtk_widget_show(filesel); gtk_window_set_transient_for(GTK_WINDOW(filesel), GTK_WINDOW(fe->window)); gtk_main(); @@ -1282,10 +2081,45 @@ static char *file_selector(frontend *fe, char *title, int save) return fe->filesel_name; } +#else + +static char *file_selector(frontend *fe, char *title, int save) +{ + char *filesel_name = NULL; + + GtkWidget *filesel = + gtk_file_chooser_dialog_new(title, + GTK_WINDOW(fe->window), + save ? GTK_FILE_CHOOSER_ACTION_SAVE : + GTK_FILE_CHOOSER_ACTION_OPEN, + LABEL_CANCEL, GTK_RESPONSE_CANCEL, + save ? LABEL_SAVE : LABEL_OPEN, + GTK_RESPONSE_ACCEPT, + NULL); + + if (gtk_dialog_run(GTK_DIALOG(filesel)) == GTK_RESPONSE_ACCEPT) { + char *name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filesel)); + filesel_name = dupstr(name); + g_free(name); + } + + gtk_widget_destroy(filesel); + + return filesel_name; +} + +#endif + +struct savefile_write_ctx { + FILE *fp; + int error; +}; + static void savefile_write(void *wctx, void *buf, int len) { - FILE *fp = (FILE *)wctx; - fwrite(buf, 1, len, fp); + struct savefile_write_ctx *ctx = (struct savefile_write_ctx *)wctx; + if (fwrite(buf, 1, len, ctx->fp) < len) + ctx->error = errno; } static int savefile_read(void *wctx, void *buf, int len) @@ -1316,20 +2150,32 @@ static void menu_save_event(GtkMenuItem *menuitem, gpointer data) " file \"%.*s\"?", FILENAME_MAX, name); if (!message_box(fe->window, "Question", buf, TRUE, MB_YESNO)) - return; + goto free_and_return; } fp = fopen(name, "w"); - sfree(name); if (!fp) { error_box(fe->window, "Unable to open save file"); - return; + goto free_and_return; } - midend_serialise(fe->me, savefile_write, fp); - - fclose(fp); + { + struct savefile_write_ctx ctx; + ctx.fp = fp; + ctx.error = 0; + midend_serialise(fe->me, savefile_write, &ctx); + fclose(fp); + if (ctx.error) { + char boxmsg[512]; + sprintf(boxmsg, "Error writing save file: %.400s", + strerror(errno)); + error_box(fe->window, boxmsg); + goto free_and_return; + } + } + free_and_return: + sfree(name); } } @@ -1358,6 +2204,7 @@ static void menu_load_event(GtkMenuItem *menuitem, gpointer data) return; } + changed_preset(fe); resize_fe(fe); } } @@ -1383,9 +2230,14 @@ static void menu_restart_event(GtkMenuItem *menuitem, gpointer data) 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 which = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), + "user-data")); + if (fe->preset_threaded || + (GTK_IS_CHECK_MENU_ITEM(menuitem) && + !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)))) + return; + changed_preset(fe); /* Put the old preset back! */ if (!get_config(fe, which)) return; @@ -1396,6 +2248,21 @@ static void menu_config_event(GtkMenuItem *menuitem, gpointer data) static void menu_about_event(GtkMenuItem *menuitem, gpointer data) { frontend *fe = (frontend *)data; + +#if GTK_CHECK_VERSION(3,0,0) + extern char *const *const xpm_icons[]; + extern const int n_xpm_icons; + GdkPixbuf *icon = gdk_pixbuf_new_from_xpm_data + ((const gchar **)xpm_icons[n_xpm_icons-1]); + gtk_show_about_dialog + (GTK_WINDOW(fe->window), + "program-name", thegame.name, + "version", ver, + "comments", "Part of Simon Tatham's Portable Puzzle Collection", + "logo", icon, + (const gchar *)NULL); + g_object_unref(G_OBJECT(icon)); +#else char titlebuf[256]; char textbuf[1024]; @@ -1406,6 +2273,7 @@ static void menu_about_event(GtkMenuItem *menuitem, gpointer data) "%.500s", thegame.name, ver); message_box(fe->window, titlebuf, textbuf, TRUE, MB_OK); +#endif } static GtkWidget *add_menu_item_with_key(frontend *fe, GtkContainer *cont, @@ -1414,10 +2282,9 @@ static GtkWidget *add_menu_item_with_key(frontend *fe, GtkContainer *cont, GtkWidget *menuitem = gtk_menu_item_new_with_label(text); int keyqual; 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); + g_object_set_data(G_OBJECT(menuitem), "user-data", GINT_TO_POINTER(key)); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_key_event), fe); switch (key & ~0x1F) { case 0x00: key += 0x60; @@ -1451,9 +2318,8 @@ enum { ARG_EITHER, ARG_SAVE, ARG_ID }; /* for argtype */ static frontend *new_window(char *arg, int argtype, char **error) { frontend *fe; - GtkBox *vbox; - GtkWidget *menubar, *menu, *menuitem; - GdkPixmap *iconpm; + GtkBox *vbox, *hbox; + GtkWidget *menu, *menuitem; GList *iconlist; int x, y, n; char errbuf[1024]; @@ -1527,6 +2393,35 @@ static frontend *new_window(char *arg, int argtype, char **error) midend_new_game(fe->me); } +#if !GTK_CHECK_VERSION(3,0,0) + { + /* + * try_shrink_drawing_area() will do some fiddling with the + * window size request (see comment in that function) after + * all the bits and pieces such as the menu bar and status bar + * have appeared in the puzzle window. + * + * However, on Unity systems, the menu bar _doesn't_ appear in + * the puzzle window, because the Unity shell hijacks it into + * the menu bar at the very top of the screen. We therefore + * try to detect that situation here, so that we don't sit + * here forever waiting for a menu bar. + */ + const char prop[] = "gtk-shell-shows-menubar"; + GtkSettings *settings = gtk_settings_get_default(); + if (!g_object_class_find_property(G_OBJECT_GET_CLASS(settings), + prop)) { + fe->menubar_is_local = TRUE; + } else { + int unity_mode; + g_object_get(gtk_settings_get_default(), + prop, &unity_mode, + (const gchar *)NULL); + fe->menubar_is_local = !unity_mode; + } + } +#endif + fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name); @@ -1537,12 +2432,16 @@ static frontend *new_window(char *arg, int argtype, char **error) fe->accelgroup = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(fe->window), fe->accelgroup); - menubar = gtk_menu_bar_new(); - gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0); - gtk_widget_show(menubar); + hbox = GTK_BOX(gtk_hbox_new(FALSE, 0)); + gtk_box_pack_start(vbox, GTK_WIDGET(hbox), FALSE, FALSE, 0); + gtk_widget_show(GTK_WIDGET(hbox)); + + fe->menubar = gtk_menu_bar_new(); + gtk_box_pack_start(hbox, fe->menubar, TRUE, TRUE, 0); + gtk_widget_show(fe->menubar); - menuitem = gtk_menu_item_new_with_label("Game"); - gtk_container_add(GTK_CONTAINER(menubar), menuitem); + menuitem = gtk_menu_item_new_with_mnemonic("_Game"); + gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); gtk_widget_show(menuitem); menu = gtk_menu_new(); @@ -1552,32 +2451,36 @@ static frontend *new_window(char *arg, int argtype, char **error) menuitem = gtk_menu_item_new_with_label("Restart"); gtk_container_add(GTK_CONTAINER(menu), menuitem); - gtk_signal_connect(GTK_OBJECT(menuitem), "activate", - GTK_SIGNAL_FUNC(menu_restart_event), fe); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_restart_event), fe); gtk_widget_show(menuitem); menuitem = gtk_menu_item_new_with_label("Specific..."); - gtk_object_set_data(GTK_OBJECT(menuitem), "user-data", - GINT_TO_POINTER(CFG_DESC)); + g_object_set_data(G_OBJECT(menuitem), "user-data", + GINT_TO_POINTER(CFG_DESC)); gtk_container_add(GTK_CONTAINER(menu), menuitem); - gtk_signal_connect(GTK_OBJECT(menuitem), "activate", - GTK_SIGNAL_FUNC(menu_config_event), fe); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_config_event), fe); gtk_widget_show(menuitem); menuitem = gtk_menu_item_new_with_label("Random Seed..."); - gtk_object_set_data(GTK_OBJECT(menuitem), "user-data", - GINT_TO_POINTER(CFG_SEED)); + g_object_set_data(G_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); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_config_event), fe); gtk_widget_show(menuitem); + fe->preset_radio = NULL; + fe->preset_custom = NULL; + fe->n_preset_menu_items = 0; + fe->preset_threaded = FALSE; 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(menubar), menuitem); + menuitem = gtk_menu_item_new_with_mnemonic("_Type"); + gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); gtk_widget_show(menuitem); submenu = gtk_menu_new(); @@ -1589,60 +2492,74 @@ static frontend *new_window(char *arg, int argtype, char **error) midend_fetch_preset(fe->me, i, &name, ¶ms); - menuitem = gtk_menu_item_new_with_label(name); + menuitem = + gtk_radio_menu_item_new_with_label(fe->preset_radio, name); + fe->preset_radio = + gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); + fe->n_preset_menu_items++; 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); + g_object_set_data(G_OBJECT(menuitem), "user-data", params); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(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)); + menuitem = fe->preset_custom = + gtk_radio_menu_item_new_with_label(fe->preset_radio, + "Custom..."); + fe->preset_radio = + gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); gtk_container_add(GTK_CONTAINER(submenu), menuitem); - gtk_signal_connect(GTK_OBJECT(menuitem), "activate", - GTK_SIGNAL_FUNC(menu_config_event), fe); + g_object_set_data(G_OBJECT(menuitem), "user-data", + GINT_TO_POINTER(CFG_SETTINGS)); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_config_event), fe); gtk_widget_show(menuitem); } + } add_menu_separator(GTK_CONTAINER(menu)); menuitem = gtk_menu_item_new_with_label("Load..."); gtk_container_add(GTK_CONTAINER(menu), menuitem); - gtk_signal_connect(GTK_OBJECT(menuitem), "activate", - GTK_SIGNAL_FUNC(menu_load_event), fe); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_load_event), fe); gtk_widget_show(menuitem); menuitem = gtk_menu_item_new_with_label("Save..."); gtk_container_add(GTK_CONTAINER(menu), menuitem); - gtk_signal_connect(GTK_OBJECT(menuitem), "activate", - GTK_SIGNAL_FUNC(menu_save_event), fe); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_save_event), fe); gtk_widget_show(menuitem); +#ifndef STYLUS_BASED 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", 'r'); - if (thegame.can_format_as_text) { +#endif + if (thegame.can_format_as_text_ever) { add_menu_separator(GTK_CONTAINER(menu)); menuitem = gtk_menu_item_new_with_label("Copy"); gtk_container_add(GTK_CONTAINER(menu), menuitem); - gtk_signal_connect(GTK_OBJECT(menuitem), "activate", - GTK_SIGNAL_FUNC(menu_copy_event), fe); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_copy_event), fe); gtk_widget_show(menuitem); + fe->copy_menu_item = menuitem; + } else { + fe->copy_menu_item = NULL; } if (thegame.can_solve) { add_menu_separator(GTK_CONTAINER(menu)); menuitem = gtk_menu_item_new_with_label("Solve"); gtk_container_add(GTK_CONTAINER(menu), menuitem); - gtk_signal_connect(GTK_OBJECT(menuitem), "activate", - GTK_SIGNAL_FUNC(menu_solve_event), fe); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_solve_event), fe); gtk_widget_show(menuitem); } add_menu_separator(GTK_CONTAINER(menu)); add_menu_item_with_key(fe, GTK_CONTAINER(menu), "Exit", 'q'); - menuitem = gtk_menu_item_new_with_label("Help"); - gtk_container_add(GTK_CONTAINER(menubar), menuitem); + menuitem = gtk_menu_item_new_with_mnemonic("_Help"); + gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem); gtk_widget_show(menuitem); menu = gtk_menu_new(); @@ -1650,35 +2567,49 @@ static frontend *new_window(char *arg, int argtype, char **error) menuitem = gtk_menu_item_new_with_label("About"); gtk_container_add(GTK_CONTAINER(menu), menuitem); - gtk_signal_connect(GTK_OBJECT(menuitem), "activate", - GTK_SIGNAL_FUNC(menu_about_event), fe); + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(menu_about_event), fe); gtk_widget_show(menuitem); - { - 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); - } +#ifdef STYLUS_BASED + menuitem=gtk_button_new_with_mnemonic("_Redo"); + g_object_set_data(G_OBJECT(menuitem), "user-data", + GINT_TO_POINTER((int)('r'))); + g_signal_connect(G_OBJECT(menuitem), "clicked", + G_CALLBACK(menu_key_event), fe); + gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0); + gtk_widget_show(menuitem); + + menuitem=gtk_button_new_with_mnemonic("_Undo"); + g_object_set_data(G_OBJECT(menuitem), "user-data", + GINT_TO_POINTER((int)('u'))); + g_signal_connect(G_OBJECT(menuitem), "clicked", + G_CALLBACK(menu_key_event), fe); + gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0); + gtk_widget_show(menuitem); + + if (thegame.flags & REQUIRE_NUMPAD) { + hbox = GTK_BOX(gtk_hbox_new(FALSE, 0)); + gtk_box_pack_start(vbox, GTK_WIDGET(hbox), FALSE, FALSE, 0); + gtk_widget_show(GTK_WIDGET(hbox)); + + *((int*)errbuf)=0; + errbuf[1]='\0'; + for(errbuf[0]='0';errbuf[0]<='9';errbuf[0]++) { + menuitem=gtk_button_new_with_label(errbuf); + g_object_set_data(G_OBJECT(menuitem), "user-data", + GINT_TO_POINTER((int)(errbuf[0]))); + g_signal_connect(G_OBJECT(menuitem), "clicked", + G_CALLBACK(menu_key_event), fe); + gtk_box_pack_start(hbox, menuitem, TRUE, TRUE, 0); + gtk_widget_show(menuitem); + } } +#endif /* STYLUS_BASED */ + + changed_preset(fe); + + snaffle_colours(fe); if (midend_wants_statusbar(fe->me)) { GtkWidget *viewport; @@ -1694,61 +2625,84 @@ static frontend *new_window(char *arg, int argtype, char **error) fe->statusctx = gtk_statusbar_get_context_id (GTK_STATUSBAR(fe->statusbar), "game"); gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, - "test"); + DEFAULT_STATUSBAR_TEXT); +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_get_preferred_size(fe->statusbar, &req, NULL); +#else 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); + gtk_widget_set_size_request(viewport, -1, req.height); } else fe->statusbar = NULL; fe->area = gtk_drawing_area_new(); +#if GTK_CHECK_VERSION(2,0,0) && !GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_double_buffered(fe->area, FALSE); +#endif + { + GdkGeometry geom; + geom.base_width = geom.base_height = 0; + gtk_window_set_geometry_hints(GTK_WINDOW(fe->window), fe->area, + &geom, GDK_HINT_BASE_SIZE); + } + fe->w = -1; + fe->h = -1; get_size(fe, &x, &y); +#if GTK_CHECK_VERSION(3,0,0) + gtk_window_set_default_geometry(GTK_WINDOW(fe->window), x, y); +#else + fe->drawing_area_shrink_pending = FALSE; gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y); - fe->w = x; - fe->h = y; +#endif gtk_box_pack_end(vbox, fe->area, TRUE, TRUE, 0); - fe->pixmap = NULL; + clear_backing_store(fe); fe->fonts = NULL; fe->nfonts = fe->fontsize = 0; fe->paste_data = NULL; fe->paste_data_len = 0; - 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), "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), "selection_get", - GTK_SIGNAL_FUNC(selection_get), fe); - gtk_signal_connect(GTK_OBJECT(fe->area), "selection_clear_event", - GTK_SIGNAL_FUNC(selection_clear), 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); + g_signal_connect(G_OBJECT(fe->window), "destroy", + G_CALLBACK(destroy), fe); + g_signal_connect(G_OBJECT(fe->window), "key_press_event", + G_CALLBACK(key_event), fe); + g_signal_connect(G_OBJECT(fe->area), "button_press_event", + G_CALLBACK(button_event), fe); + g_signal_connect(G_OBJECT(fe->area), "button_release_event", + G_CALLBACK(button_event), fe); + g_signal_connect(G_OBJECT(fe->area), "motion_notify_event", + G_CALLBACK(motion_event), fe); + g_signal_connect(G_OBJECT(fe->area), "selection_get", + G_CALLBACK(selection_get), fe); + g_signal_connect(G_OBJECT(fe->area), "selection_clear_event", + G_CALLBACK(selection_clear), fe); +#if GTK_CHECK_VERSION(3,0,0) + g_signal_connect(G_OBJECT(fe->area), "draw", + G_CALLBACK(draw_area), fe); +#else + g_signal_connect(G_OBJECT(fe->area), "expose_event", + G_CALLBACK(expose_area), fe); +#endif + g_signal_connect(G_OBJECT(fe->window), "map_event", + G_CALLBACK(map_window), fe); + g_signal_connect(G_OBJECT(fe->area), "configure_event", + G_CALLBACK(configure_area), fe); + g_signal_connect(G_OBJECT(fe->window), "configure_event", + G_CALLBACK(configure_window), fe); gtk_widget_add_events(GTK_WIDGET(fe->area), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | - GDK_BUTTON_MOTION_MASK); + GDK_BUTTON_MOTION_MASK | + GDK_POINTER_MOTION_HINT_MASK); if (n_xpm_icons) { - gtk_widget_realize(fe->window); - iconpm = gdk_pixmap_create_from_xpm_d(fe->window->window, NULL, - NULL, (gchar **)xpm_icons[0]); - gdk_window_set_icon(fe->window->window, NULL, iconpm, NULL); + gtk_window_set_icon(GTK_WINDOW(fe->window), + gdk_pixbuf_new_from_xpm_data + ((const gchar **)xpm_icons[0])); + iconlist = NULL; for (n = 0; n < n_xpm_icons; n++) { iconlist = @@ -1756,21 +2710,18 @@ static frontend *new_window(char *arg, int argtype, char **error) gdk_pixbuf_new_from_xpm_data((const gchar **) xpm_icons[n])); } - gdk_window_set_icon_list(fe->window->window, iconlist); + gtk_window_set_icon_list(GTK_WINDOW(fe->window), iconlist); } gtk_widget_show(fe->area); gtk_widget_show(fe->window); - /* - * Now that we've established the preferred size of the window, - * reduce the drawing area's size request so the user can shrink - * the window. - */ - gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), 1, 1); +#if !GTK_CHECK_VERSION(3,0,0) + fe->drawing_area_shrink_pending = TRUE; + try_shrink_drawing_area(fe); +#endif - gdk_window_set_background(fe->area->window, &fe->colours[0]); - gdk_window_set_background(fe->window->window, &fe->colours[0]); + set_window_background(fe, 0); return fe; } @@ -1799,9 +2750,11 @@ int main(int argc, char **argv) char *pname = argv[0]; char *error; int ngenerate = 0, print = FALSE, px = 1, py = 1; + int time_generation = FALSE, test_solve = FALSE, list_presets = FALSE; int soln = FALSE, colour = FALSE; float scale = 1.0F; float redo_proportion = 0.0F; + char *savefile = NULL, *savesuffix = NULL; char *arg = NULL; int argtype = ARG_EITHER; char *screenshot_file = NULL; @@ -1850,6 +2803,29 @@ int main(int argc, char **argv) } } else ngenerate = 1; + } else if (doing_opts && !strcmp(p, "--time-generation")) { + time_generation = TRUE; + } else if (doing_opts && !strcmp(p, "--test-solve")) { + test_solve = TRUE; + } else if (doing_opts && !strcmp(p, "--list-presets")) { + list_presets = TRUE; + } else if (doing_opts && !strcmp(p, "--save")) { + if (--ac > 0) { + savefile = *++av; + } else { + fprintf(stderr, "%s: '--save' expected a filename\n", + pname); + return 1; + } + } else if (doing_opts && (!strcmp(p, "--save-suffix") || + !strcmp(p, "--savesuffix"))) { + if (--ac > 0) { + savesuffix = *++av; + } else { + fprintf(stderr, "%s: '--save-suffix' expected a filename\n", + pname); + return 1; + } } else if (doing_opts && !strcmp(p, "--print")) { if (!thegame.can_print) { fprintf(stderr, "%s: this game does not support printing\n", @@ -1954,11 +2930,6 @@ int main(int argc, char **argv) } } - if (*errbuf) { - fputs(errbuf, stderr); - return 1; - } - /* * Special standalone mode for generating puzzle IDs on the * command line. Useful for generating puzzles to be printed @@ -1980,17 +2951,32 @@ int main(int argc, char **argv) * you may specify it to be 1). Sorry; that was the * simplest-to-parse command-line syntax I came up with. */ - if (ngenerate > 0 || print) { + if (ngenerate > 0 || print || savefile || savesuffix) { int i, n = 1; midend *me; char *id; document *doc = NULL; + /* + * If we're in this branch, we should display any pending + * error message from the command line, since GTK isn't going + * to take another crack at making sense of it. + */ + if (*errbuf) { + fputs(errbuf, stderr); + return 1; + } + n = ngenerate; me = midend_new(NULL, &thegame, NULL, NULL); i = 0; + if (savefile && !savesuffix) + savesuffix = ""; + if (!savefile && savesuffix) + savefile = ""; + if (print) doc = document_new(px, py, scale); @@ -2011,7 +2997,8 @@ int main(int argc, char **argv) * generated descriptive game IDs.) */ while (ngenerate == 0 || i < n) { - char *pstr, *err; + char *pstr, *err, *seed; + struct rusage before, after; if (ngenerate == 0) { pstr = fgetline(stdin); @@ -2037,9 +3024,63 @@ int main(int argc, char **argv) return 1; } } - sfree(pstr); - midend_new_game(me); + if (time_generation) + getrusage(RUSAGE_SELF, &before); + + midend_new_game(me); + + seed = midend_get_random_seed(me); + + if (time_generation) { + double elapsed; + + getrusage(RUSAGE_SELF, &after); + + elapsed = (after.ru_utime.tv_sec - + before.ru_utime.tv_sec); + elapsed += (after.ru_utime.tv_usec - + before.ru_utime.tv_usec) / 1000000.0; + + printf("%s %s: %.6f\n", thegame.name, seed, elapsed); + } + + if (test_solve && thegame.can_solve) { + /* + * Now destroy the aux_info in the midend, by means of + * re-entering the same game id, and then try to solve + * it. + */ + char *game_id, *err; + + game_id = midend_get_game_id(me); + err = midend_game_id(me, game_id); + if (err) { + fprintf(stderr, "%s %s: game id re-entry error: %s\n", + thegame.name, seed, err); + return 1; + } + midend_new_game(me); + sfree(game_id); + + err = midend_solve(me); + /* + * If the solve operation returned the error "Solution + * not known for this puzzle", that's OK, because that + * just means it's a puzzle for which we don't have an + * algorithmic solver and hence can't solve it without + * the aux_info, e.g. Netslide. Any other error is a + * problem, though. + */ + if (err && strcmp(err, "Solution not known for this puzzle")) { + fprintf(stderr, "%s %s: solve error: %s\n", + thegame.name, seed, err); + return 1; + } + } + + sfree(pstr); + sfree(seed); if (doc) { err = midend_print_puzzle(me, doc, soln); @@ -2047,7 +3088,43 @@ int main(int argc, char **argv) fprintf(stderr, "%s: error in printing: %s\n", pname, err); return 1; } - } else { + } + if (savefile) { + struct savefile_write_ctx ctx; + char *realname = snewn(40 + strlen(savefile) + + strlen(savesuffix), char); + sprintf(realname, "%s%d%s", savefile, i, savesuffix); + + if (soln) { + char *err = midend_solve(me); + if (err) { + fprintf(stderr, "%s: unable to show solution: %s\n", + realname, err); + return 1; + } + } + + ctx.fp = fopen(realname, "w"); + if (!ctx.fp) { + fprintf(stderr, "%s: open: %s\n", realname, + strerror(errno)); + return 1; + } + ctx.error = 0; + midend_serialise(me, savefile_write, &ctx); + if (ctx.error) { + fprintf(stderr, "%s: write: %s\n", realname, + strerror(ctx.error)); + return 1; + } + if (fclose(ctx.fp)) { + fprintf(stderr, "%s: close: %s\n", realname, + strerror(errno)); + return 1; + } + sfree(realname); + } + if (!doc && !savefile && !time_generation) { id = midend_get_game_id(me); puts(id); sfree(id); @@ -2066,6 +3143,30 @@ int main(int argc, char **argv) midend_free(me); return 0; + } else if (list_presets) { + /* + * Another specialist mode which causes the puzzle to list the + * game_params strings for all its preset configurations. + */ + int i, npresets; + midend *me; + + me = midend_new(NULL, &thegame, NULL, NULL); + npresets = midend_num_presets(me); + + for (i = 0; i < npresets; i++) { + game_params *params; + char *name, *paramstr; + + midend_fetch_preset(me, i, &name, ¶ms); + paramstr = thegame.encode_params(params, TRUE); + + printf("%s %s\n", paramstr, name); + sfree(paramstr); + } + + midend_free(me); + return 0; } else { frontend *fe; @@ -2096,15 +3197,7 @@ int main(int argc, char **argv) } if (screenshot_file) { - GdkPixbuf *pb; - GError *gerror = NULL; - - midend_redraw(fe->me); - - pb = gdk_pixbuf_get_from_drawable(NULL, fe->pixmap, - NULL, 0, 0, 0, 0, -1, -1); - gdk_pixbuf_save(pb, screenshot_file, "png", &gerror, NULL); - + save_screenshot_png(fe, screenshot_file); exit(0); }