#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
#include <gdk/gdkx.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#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
+ GSList *preset_radio;
+ int n_preset_menu_items;
+ int preset_threaded;
+ GtkWidget *preset_custom;
+ GtkWidget *copy_menu_item;
};
void get_random_seed(void **randseed, int *randseedsize)
}
}
+#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,
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
};
static void destroy(GtkWidget *widget, gpointer data)
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)
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(widget->window, NULL, NULL, NULL);
+#endif
return TRUE;
}
else {
fe->cfgret = TRUE;
gtk_widget_destroy(fe->cfgbox);
+ changed_preset(fe);
}
}
w = gtk_label_new(i->name);
gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
- GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+ GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
3, 3);
gtk_widget_show(w);
w = gtk_label_new(i->name);
gtk_misc_set_alignment(GTK_MISC(w), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1,
- GTK_EXPAND | GTK_SHRINK | GTK_FILL,
- GTK_EXPAND | GTK_SHRINK | GTK_FILL,
+ GTK_SHRINK | GTK_FILL,
+ GTK_EXPAND | GTK_SHRINK | GTK_FILL ,
3, 3);
gtk_widget_show(w);
gdk_window_resize(GTK_WIDGET(win)->window, x, y)
#endif
-static void menu_preset_event(GtkMenuItem *menuitem, gpointer data)
+/*
+ * 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);
+ }
+}
+
+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");
+
+ 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;
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 (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;
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)
gtk_widget_show(menuitem);
}
-static frontend *new_window(char *arg, char **error)
+enum { ARG_EITHER, ARG_SAVE, ARG_ID }; /* for argtype */
+
+static frontend *new_window(char *arg, int argtype, char **error)
{
frontend *fe;
- GtkBox *vbox;
+ GtkBox *vbox, *hbox;
GtkWidget *menubar, *menu, *menuitem;
+ GdkPixmap *iconpm;
+ GList *iconlist;
int x, y, n;
char errbuf[1024];
+ extern char *const *const xpm_icons[];
+ extern const int n_xpm_icons;
fe = snew(frontend);
if (arg) {
char *err;
+ FILE *fp;
errbuf[0] = '\0';
- /*
- * Try treating the argument as a game ID.
- */
- err = midend_game_id(fe->me, arg);
- if (!err) {
- /*
- * It's a valid game ID.
- */
- midend_new_game(fe->me);
- } else {
- FILE *fp = fopen(arg, "r");
+ switch (argtype) {
+ case ARG_ID:
+ err = midend_game_id(fe->me, arg);
+ if (!err)
+ midend_new_game(fe->me);
+ else
+ sprintf(errbuf, "Invalid game ID: %.800s", err);
+ break;
+ case ARG_SAVE:
+ fp = fopen(arg, "r");
if (!fp) {
- sprintf(errbuf, "Supplied argument is neither a game ID (%.400s)"
- " nor a save file (%.400s)", err, strerror(errno));
+ sprintf(errbuf, "Error opening file: %.800s", strerror(errno));
} else {
err = midend_deserialise(fe->me, savefile_read, fp);
if (err)
- sprintf(errbuf, "%.800s", err);
+ sprintf(errbuf, "Invalid save file: %.800s", err);
fclose(fp);
}
- }
+ break;
+ default /*case ARG_EITHER*/:
+ /*
+ * First try treating the argument as a game ID.
+ */
+ err = midend_game_id(fe->me, arg);
+ if (!err) {
+ /*
+ * It's a valid game ID.
+ */
+ midend_new_game(fe->me);
+ } else {
+ FILE *fp = fopen(arg, "r");
+ if (!fp) {
+ sprintf(errbuf, "Supplied argument is neither a game ID (%.400s)"
+ " nor a save file (%.400s)", err, strerror(errno));
+ } else {
+ err = midend_deserialise(fe->me, savefile_read, fp);
+ if (err)
+ sprintf(errbuf, "%.800s", err);
+ fclose(fp);
+ }
+ }
+ break;
+ }
if (*errbuf) {
*error = dupstr(errbuf);
midend_free(fe->me);
fe->accelgroup = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(fe->window), fe->accelgroup);
+ 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));
+
menubar = gtk_menu_bar_new();
- gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
+ gtk_box_pack_start(hbox, menubar, TRUE, TRUE, 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);
GTK_SIGNAL_FUNC(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");
+ menuitem = gtk_menu_item_new_with_mnemonic("_Type");
gtk_container_add(GTK_CONTAINER(menubar), menuitem);
gtk_widget_show(menuitem);
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_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",
}
if (thegame.can_configure) {
- menuitem = gtk_menu_item_new_with_label("Custom...");
+ menuitem = fe->preset_custom =
+ gtk_radio_menu_item_new_with_label(fe->preset_radio,
+ "Custom...");
+ fe->preset_radio =
+ gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(menuitem));
+ 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);
}
+
}
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);
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);
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);
+#ifdef STYLUS_BASED
+ menuitem=gtk_button_new_with_mnemonic("_Redo");
+ gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
+ GINT_TO_POINTER((int)('r')));
+ gtk_signal_connect(GTK_OBJECT(menuitem), "clicked",
+ GTK_SIGNAL_FUNC(menu_key_event), fe);
+ gtk_box_pack_end(hbox, menuitem, FALSE, FALSE, 0);
+ gtk_widget_show(menuitem);
+
+ menuitem=gtk_button_new_with_mnemonic("_Undo");
+ gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
+ GINT_TO_POINTER((int)('u')));
+ gtk_signal_connect(GTK_OBJECT(menuitem), "clicked",
+ GTK_SIGNAL_FUNC(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);
+ gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
+ GINT_TO_POINTER((int)(errbuf[0])));
+ gtk_signal_connect(GTK_OBJECT(menuitem), "clicked",
+ GTK_SIGNAL_FUNC(menu_key_event), fe);
+ gtk_box_pack_start(hbox, menuitem, TRUE, TRUE, 0);
+ gtk_widget_show(menuitem);
+ }
+ }
+#endif /* STYLUS_BASED */
+
+ 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_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);
+ iconlist = NULL;
+ for (n = 0; n < n_xpm_icons; n++) {
+ iconlist =
+ g_list_append(iconlist,
+ gdk_pixbuf_new_from_xpm_data((const gchar **)
+ xpm_icons[n]));
+ }
+ gdk_window_set_icon_list(fe->window->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);
+
gdk_window_set_background(fe->area->window, &fe->colours[0]);
gdk_window_set_background(fe->window->window, &fe->colours[0]);
int ngenerate = 0, print = FALSE, px = 1, py = 1;
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;
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, "--redo")) {
+ /*
+ * This is an internal option which I don't expect
+ * users to have any particular use for. The effect of
+ * --redo is that once the game has been loaded and
+ * initialised, the next move in the redo chain is
+ * replayed, and the game screen is redrawn part way
+ * through the making of the move. This is only
+ * meaningful if there _is_ a next move in the redo
+ * chain, which means in turn that this option is only
+ * useful if you're also passing a save file on the
+ * command line.
+ *
+ * This option is used by the script which generates
+ * the puzzle icons and website screenshots, and I
+ * don't imagine it's useful for anything else.
+ * (Unless, I suppose, users don't like my screenshots
+ * and want to generate their own in the same way for
+ * some repackaged version of the puzzles.)
+ */
+ if (--ac > 0) {
+ redo_proportion = atof(*++av);
+ } else {
+ fprintf(stderr, "%s: no argument supplied to '--redo'\n",
+ pname);
+ return 1;
+ }
+ } else if (doing_opts && !strcmp(p, "--screenshot")) {
+ /*
+ * Another internal option for the icon building
+ * script. This causes a screenshot of the central
+ * drawing area (i.e. not including the menu bar or
+ * status bar) to be saved to a PNG file once the
+ * window has been drawn, and then the application
+ * quits immediately.
+ */
+ 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") ||
return 1;
}
colour = TRUE;
+ } else if (doing_opts && !strcmp(p, "--load")) {
+ argtype = ARG_SAVE;
+ } else if (doing_opts && !strcmp(p, "--game")) {
+ argtype = ARG_ID;
} else if (doing_opts && !strcmp(p, "--")) {
doing_opts = FALSE;
} else if (!doing_opts || p[0] != '-') {
}
}
+ 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 0;
} else {
+ frontend *fe;
gtk_init(&argc, &argv);
- if (!new_window(argc > 1 ? argv[1] : NULL, &error)) {
+ fe = new_window(arg, argtype, &error);
+
+ if (!fe) {
fprintf(stderr, "%s: %s\n", pname, error);
return 1;
}
+ if (screenshot_file) {
+ /*
+ * Some puzzles will not redraw their entire area if
+ * given a partially completed animation, which means
+ * we must redraw now and _then_ redraw again after
+ * freezing the move timer.
+ */
+ midend_force_redraw(fe->me);
+ }
+
+ if (redo_proportion) {
+ /* Start a redo. */
+ midend_process_key(fe->me, 0, 0, 'r');
+ /* And freeze the timer at the specified position. */
+ midend_freeze_timer(fe->me, redo_proportion);
+ }
+
+ 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);
+
+ exit(0);
+ }
+
gtk_main();
}
~mdw / sgt / puzzles / blobdiff