#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
#ifdef DEBUGGING
* GTK front end to puzzles.
*/
+static void changed_preset(frontend *fe);
+
struct font {
#ifdef USE_PANGO
PangoFontDescription *desc;
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
+ int npresets;
+ GtkWidget **preset_bullets;
+ GtkWidget *preset_custom_bullet;
+ GtkWidget *copy_menu_item;
};
void get_random_seed(void **randseed, int *randseedsize)
return TRUE;
#endif
+ /* Handle mnemonics. */
+ if (gtk_window_activate_key(GTK_WINDOW(fe->window), event))
+ return TRUE;
+
if (event->keyval == GDK_Up)
keyval = shift | ctrl | CURSOR_UP;
else if (event->keyval == GDK_KP_Up || event->keyval == GDK_KP_8)
else {
fe->cfgret = TRUE;
gtk_widget_destroy(fe->cfgbox);
+ changed_preset(fe);
}
}
gdk_window_resize(GTK_WIDGET(win)->window, x, y)
#endif
-static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
+static void update_menuitem_bullet(GtkWidget *label, int visible)
+{
+ if (visible) {
+ gtk_label_set_text(GTK_LABEL(label), "\xE2\x80\xA2");
+ } else {
+ gtk_label_set_text(GTK_LABEL(label), "");
+ }
+}
+
+/*
+ * 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);
+ int i;
+
+ /*
+ * Update the tick mark in the Type menu.
+ */
+ if (fe->preset_bullets) {
+ for (i = 0; i < fe->npresets; i++)
+ update_menuitem_bullet(fe->preset_bullets[i], n == i);
+ }
+ if (fe->preset_custom_bullet) {
+ update_menuitem_bullet(fe->preset_custom_bullet, n < 0);
+ }
+
+ /*
+ * 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);
+ }
+}
+
+static void resize_fe(frontend *fe)
{
- 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);
get_size(fe, &x, &y);
fe->w = x;
fe->h = y;
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);
+}
+
+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");
+
+ midend_set_params(fe->me, params);
+ midend_new_game(fe->me);
+ changed_preset(fe);
+ resize_fe(fe);
}
GdkAtom compound_text_atom, utf8_string_atom;
if (gtk_selection_owner_set(fe->area, GDK_SELECTION_PRIMARY,
CurrentTime)) {
+ gtk_selection_clear_targets(fe->area, GDK_SELECTION_PRIMARY);
gtk_selection_add_target(fe->area, GDK_SELECTION_PRIMARY,
GDK_SELECTION_TYPE_STRING, 1);
gtk_selection_add_target(fe->area, GDK_SELECTION_PRIMARY,
}
}
+#ifdef OLD_FILESEL
+
static void filesel_ok(GtkButton *button, gpointer data)
{
frontend *fe = (frontend *)data;
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,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN,
+ GTK_RESPONSE_ACCEPT,
+ NULL);
+
+ if (gtk_dialog_run(GTK_DIALOG(filesel)) == GTK_RESPONSE_ACCEPT) {
+ const char *name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filesel));
+ filesel_name = dupstr(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)
return;
}
- midend_serialise(fe->me, savefile_write, 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);
+ return;
+ }
+ }
- fclose(fp);
}
}
{
frontend *fe = (frontend *)data;
char *name, *err;
- int x, y;
name = file_selector(fe, "Enter name of saved game file to load", FALSE);
return;
}
- get_size(fe, &x, &y);
- fe->w = x;
- fe->h = y;
- 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);
- }
-
+ changed_preset(fe);
+ resize_fe(fe);
}
}
frontend *fe = (frontend *)data;
int which = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(menuitem),
"user-data"));
- int x, y;
if (!get_config(fe, which))
return;
midend_new_game(fe->me);
- get_size(fe, &x, &y);
- fe->w = x;
- fe->h = y;
- 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);
- }
+ resize_fe(fe);
}
static void menu_about_event(GtkMenuItem *menuitem, gpointer data)
enum { ARG_EITHER, ARG_SAVE, ARG_ID }; /* for argtype */
+static GtkWidget *make_preset_menuitem(GtkWidget **bulletlabel,
+ const char *name)
+{
+ GtkWidget *hbox, *lab1, *lab2, *menuitem;
+ GtkRequisition req;
+
+ hbox = gtk_hbox_new(FALSE, 0);
+ gtk_widget_show(hbox);
+ lab1 = gtk_label_new("\xE2\x80\xA2 ");
+ gtk_widget_show(lab1);
+ gtk_box_pack_start(GTK_BOX(hbox), lab1, FALSE, FALSE, 0);
+ gtk_misc_set_alignment(GTK_MISC(lab1), 0.0, 0.0);
+ lab2 = gtk_label_new(name);
+ gtk_widget_show(lab2);
+ gtk_box_pack_start(GTK_BOX(hbox), lab2, TRUE, TRUE, 0);
+ gtk_misc_set_alignment(GTK_MISC(lab2), 0.0, 0.0);
+
+ gtk_widget_size_request(lab1, &req);
+ gtk_widget_set_usize(lab1, req.width, -1);
+ gtk_label_set_text(GTK_LABEL(lab1), "");
+
+ menuitem = gtk_menu_item_new();
+ gtk_container_add(GTK_CONTAINER(menuitem), hbox);
+
+ *bulletlabel = lab1;
+ return menuitem;
+}
+
static frontend *new_window(char *arg, int argtype, char **error)
{
frontend *fe;
gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
gtk_widget_show(menubar);
- menuitem = gtk_menu_item_new_with_label("Game");
+ menuitem = gtk_menu_item_new_with_mnemonic("_Game");
gtk_container_add(GTK_CONTAINER(menubar), menuitem);
gtk_widget_show(menuitem);
GtkWidget *submenu;
int i;
- menuitem = gtk_menu_item_new_with_label("Type");
+ menuitem = gtk_menu_item_new_with_mnemonic("_Type");
gtk_container_add(GTK_CONTAINER(menubar), menuitem);
gtk_widget_show(menuitem);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
+ fe->npresets = n;
+ fe->preset_bullets = snewn(n, GtkWidget *);
+
for (i = 0; i < n; i++) {
char *name;
game_params *params;
midend_fetch_preset(fe->me, i, &name, ¶ms);
- menuitem = gtk_menu_item_new_with_label(name);
+ menuitem = make_preset_menuitem(&fe->preset_bullets[i], 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",
}
if (thegame.can_configure) {
- menuitem = gtk_menu_item_new_with_label("Custom...");
+ menuitem = make_preset_menuitem(&fe->preset_custom_bullet,
+ "Custom...");
+
+ gtk_container_add(GTK_CONTAINER(submenu), menuitem);
gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
GPOINTER_TO_INT(CFG_SETTINGS));
- gtk_container_add(GTK_CONTAINER(submenu), menuitem);
gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
GTK_SIGNAL_FUNC(menu_config_event), fe);
gtk_widget_show(menuitem);
- }
+ } else
+ fe->preset_custom_bullet = NULL;
+
+ } else {
+ fe->npresets = 0;
+ fe->preset_bullets = NULL;
+ fe->preset_custom_bullet = NULL;
}
add_menu_separator(GTK_CONTAINER(menu));
- menuitem = gtk_menu_item_new_with_label("Load");
+ 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);
gtk_widget_show(menuitem);
- menuitem = gtk_menu_item_new_with_label("Save");
+ 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);
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) {
+ 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);
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));
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");
+ menuitem = gtk_menu_item_new_with_mnemonic("_Help");
gtk_container_add(GTK_CONTAINER(menubar), menuitem);
gtk_widget_show(menuitem);
GTK_SIGNAL_FUNC(menu_about_event), fe);
gtk_widget_show(menuitem);
+ changed_preset(fe);
+
{
int i, ncolours;
float *colours;
gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours,
FALSE, FALSE, success);
for (i = 0; i < ncolours; i++) {
- if (!success[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);
+ }
}
}
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);
+
gdk_window_set_background(fe->area->window, &fe->colours[0]);
gdk_window_set_background(fe->window->window, &fe->colours[0]);
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;
- int output_window_id = FALSE;
+ char *screenshot_file = NULL;
int doing_opts = TRUE;
int ac = argc;
char **av = argv;
}
} else
ngenerate = 1;
+ } 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",
pname);
return 1;
}
- } else if (doing_opts && !strcmp(p, "--windowid")) {
+ } else if (doing_opts && !strcmp(p, "--screenshot")) {
/*
* Another internal option for the icon building
- * script. This causes the window ID of the central
+ * script. This causes a screenshot of the central
* drawing area (i.e. not including the menu bar or
- * status bar) to be printed on standard output once
- * the window has been drawn.
+ * status bar) to be saved to a PNG file once the
+ * window has been drawn, and then the application
+ * quits immediately.
*/
- output_window_id = TRUE;
+ if (--ac > 0) {
+ screenshot_file = *++av;
+ } else {
+ fprintf(stderr, "%s: no argument supplied to '--screenshot'\n",
+ pname);
+ return 1;
+ }
} else if (doing_opts && (!strcmp(p, "--with-solutions") ||
!strcmp(p, "--with-solution") ||
!strcmp(p, "--with-solns") ||
}
}
+ 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
* 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 (*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);
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);
+ ctx.fp = fopen(realname, "w");
+ if (!ctx.fp) {
+ fprintf(stderr, "%s: open: %s\n", realname,
+ strerror(errno));
+ return 1;
+ }
+ sfree(realname);
+ 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;
+ }
+ }
+ if (!doc && !savefile) {
id = midend_get_game_id(me);
puts(id);
sfree(id);
return 1;
}
- if (output_window_id) {
+ if (screenshot_file) {
/*
* Some puzzles will not redraw their entire area if
* given a partially completed animation, which means
midend_freeze_timer(fe->me, redo_proportion);
}
- if (output_window_id) {
+ if (screenshot_file) {
+ GdkPixbuf *pb;
+ GError *gerror = NULL;
+
midend_redraw(fe->me);
- printf("%p\n", (void *)GDK_WINDOW_XWINDOW(fe->area->window));
- fflush(stdout);
+
+ 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);
+
+ exit(0);
}
gtk_main();
~mdw / sgt / puzzles / blobdiff