#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>
* GTK front end to puzzles.
*/
+static void changed_preset(frontend *fe);
+
struct font {
#ifdef USE_PANGO
PangoFontDescription *desc;
int pw, ph; /* pixmap size (w, h are area size) */
int ox, oy; /* offset of pixmap in drawing area */
char *filesel_name;
+ int npresets;
+ GtkWidget **preset_bullets;
+ GtkWidget *preset_custom_bullet;
+ GtkWidget *copy_menu_item;
};
void get_random_seed(void **randseed, int *randseedsize)
if (!fe->pixmap)
return TRUE;
+#if !GTK_CHECK_VERSION(2,0,0)
+ /* Gtk 1.2 passes a key event to this function even if it's also
+ * defined as an accelerator.
+ * Gtk 2 doesn't do this, and this function appears not to exist there. */
+ if (fe->accelgroup &&
+ gtk_accel_group_get_entry(fe->accelgroup,
+ event->keyval, event->state))
+ return TRUE;
+#endif
+
if (event->keyval == GDK_Up)
keyval = shift | ctrl | CURSOR_UP;
else if (event->keyval == GDK_KP_Up || event->keyval == GDK_KP_8)
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);
midend_force_redraw(fe->me);
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;
{
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)
gtk_widget_show(menuitem);
}
-static frontend *new_window(char *arg, char **error)
+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;
GtkBox *vbox;
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->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name);
-#if 0
- gtk_window_set_resizable(GTK_WINDOW(fe->window), FALSE);
-#else
- gtk_window_set_policy(GTK_WINDOW(fe->window), FALSE, FALSE, TRUE);
-#endif
+
vbox = GTK_BOX(gtk_vbox_new(FALSE, 0));
gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
gtk_widget_show(GTK_WIDGET(vbox));
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;
+
+ changed_preset(fe);
+ } 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));
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_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 *arg = NULL;
+ int argtype = ARG_EITHER;
+ char *screenshot_file = NULL;
int doing_opts = TRUE;
int ac = argc;
char **av = argv;
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
char *id;
document *doc = NULL;
- if (*errbuf) {
- fputs(errbuf, stderr);
- return 1;
- }
-
n = ngenerate;
me = midend_new(NULL, &thegame, NULL, NULL);
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