18 files changed, 54 insertions, 16884 deletions

diff --git a/apps/plugins/puzzles/SOURCES b/apps/plugins/puzzles/SOURCES
index 58a16bc9b9..6fd787b3f1 100644
--- a/apps/plugins/puzzles/SOURCES
+++ b/apps/plugins/puzzles/SOURCES
@@ -1,33 +1,29 @@
+/* Auto-generated by resync.sh */
 rockbox.c
 rbwrappers.c
 rbmalloc.c
 lz4tiny.c
 
+/* puzzles core sources */
 src/combi.c
 src/divvy.c
 src/drawing.c
 src/dsf.c
 src/findloop.c
 src/grid.c
+src/hat.c
 src/latin.c
 src/laydomino.c
 src/loopgen.c
-/*src/malloc.c*/ /* we have our own */
 src/matching.c
 src/midend.c
 src/misc.c
-src/penrose.c
 src/penrose-legacy.c
-src/printing.c
+src/penrose.c
 src/random.c
 src/sort.c
+src/spectre.c
 src/tdq.c
 src/tree234.c
 src/version.c
-
-src/hat.c
-src/spectre.c
-
-#ifdef COMBINED
-src/list.c
-#endif
+src/printing.c
diff --git a/apps/plugins/puzzles/SOURCES.games b/apps/plugins/puzzles/SOURCES.games
index 29af18e7b8..190412295b 100644
--- a/apps/plugins/puzzles/SOURCES.games
+++ b/apps/plugins/puzzles/SOURCES.games
@@ -1,5 +1,3 @@
-/* every game works! :) */
-
 src/blackbox.c
 src/bridges.c
 src/cube.c
diff --git a/apps/plugins/puzzles/SOURCES.rockbox b/apps/plugins/puzzles/SOURCES.rockbox
new file mode 100644
index 0000000000..c5bbb9af70
--- /dev/null
+++ b/apps/plugins/puzzles/SOURCES.rockbox
@@ -0,0 +1,4 @@
+rockbox.c
+rbwrappers.c
+rbmalloc.c
+lz4tiny.c
diff --git a/apps/plugins/puzzles/resync.sh b/apps/plugins/puzzles/resync.sh
index 384fc79d1f..7c2df45c7e 100755
--- a/apps/plugins/puzzles/resync.sh
+++ b/apps/plugins/puzzles/resync.sh
@@ -25,12 +25,55 @@ read ans
 if [ "YES" == $ans ]
 then
     pushd "$(dirname "$0")" > /dev/null
+    ROOT="$PWD"
 
     echo "[1/5] Removing current src/ directory"
     rm -rf src
     echo "[2/5] Copying new sources"
     mkdir src
-    cp -r "$1"/{*.c,*.h,*.but,LICENCE,README,CMakeLists.txt} src
+    cp -r "$1"/{*.h,puzzles.but,LICENCE,README,CMakeLists.txt} src
+
+    # Parse out definitions of core, core_obj, and common from
+    # CMakeLists. Extract the .c filenames, except malloc.c, and store
+    # in SOURCES.core.
+    cat src/CMakeLists.txt | awk '/add_library\(/{p=1} p{printf $0" "} /\)/{if(p) print; p=0}' | grep -E "core|common" | grep -Po "[a-z0-9\-]*?\.c" | sort -n | grep -vE 'malloc\.c|ps\.c' | awk '{print "src/"$0}' | uniq > SOURCES.core
+    echo "src/printing.c" >> SOURCES.core
+
+    # Parse out puzzle definitions to build SOURCES.games, but
+    # preserve the ability to disable puzzles based on memory size.
+    cat src/CMakeLists.txt | awk '/puzzle\(/{p=1} p{print} /\)/{p=0}' | grep -Eo "\(.*$" | tr -dc "a-z\n" | grep -v nullgame | awk '$0!~/loopy|pearl|solo/' | awk '{print "src/"$0".c"}' > SOURCES.games
+
+    SRC="$(cat SOURCES.games SOURCES.core | sed 's/src\///' | tr '\n' ' ' | head -c-1) loopy.c pearl.c solo.c"
+    echo "Detected sources:" $SRC
+    pushd "$1" > /dev/null
+    cp $SRC "$ROOT"/src
+    popd > /dev/null
+
+    cat <<EOF >> SOURCES.games
+
+/* Disabled for now. Fix puzzles.make and CATEGORIES to accomodate these. */
+/* The help system would also need to be patched to compile these. */
+/*src/unfinished/group.c*/
+/*src/unfinished/separate.c*/
+/*src/unfinished/slide.c*/
+/*src/unfinished/sokoban.c*/
+
+/* no c200v2 */
+#if PLUGIN_BUFFER_SIZE > 0x14000
+src/loopy.c
+src/pearl.c
+src/solo.c
+#endif
+EOF
+
+    cat <<EOF > SOURCES
+/* Auto-generated by resync.sh */
+EOF
+    cat SOURCES.rockbox | cpp | grep -vE "^#" >> SOURCES
+    echo -e "\n/* puzzles core sources */" >> SOURCES
+    cat SOURCES.core >> SOURCES
+    rm SOURCES.core
+
     echo "[3/5] Regenerating help"
     rm -rf help
     ./genhelp.sh
diff --git a/apps/plugins/puzzles/src/devel.but b/apps/plugins/puzzles/src/devel.but
deleted file mode 100644
index c201a3e6c9..0000000000
--- a/apps/plugins/puzzles/src/devel.but
+++ /dev/null
@@ -1,6122 +0,0 @@
-\cfg{text-indent}{0}
-\cfg{text-width}{72}
-\cfg{text-title-align}{left}
-\cfg{text-chapter-align}{left}
-\cfg{text-chapter-numeric}{true}
-\cfg{text-chapter-suffix}{. }
-\cfg{text-chapter-underline}{-}
-\cfg{text-section-align}{0}{left}
-\cfg{text-section-numeric}{0}{true}
-\cfg{text-section-suffix}{0}{. }
-\cfg{text-section-underline}{0}{-}
-\cfg{text-section-align}{1}{left}
-\cfg{text-section-numeric}{1}{true}
-\cfg{text-section-suffix}{1}{. }
-\cfg{text-section-underline}{1}{-}
-\cfg{text-versionid}{0}
-
-\cfg{html-contents-filename}{index.html}
-\cfg{html-template-filename}{%k.html}
-\cfg{html-index-filename}{docindex.html}
-\cfg{html-leaf-level}{1}
-\cfg{html-contents-depth-0}{1}
-\cfg{html-contents-depth-1}{3}
-\cfg{html-leaf-contains-contents}{true}
-
-\define{dash} \u2013{-}
-
-\title Developer documentation for Simon Tatham's puzzle collection
-
-This is a guide to the internal structure of Simon Tatham's Portable
-Puzzle Collection (henceforth referred to simply as \q{Puzzles}),
-for use by anyone attempting to implement a new puzzle or port to a
-new platform.
-
-This guide is believed correct as of \cw{git} commit
-\cw{a2212e82aa2f4b9a4ee22783d6fed2761c213432}. Hopefully it will be
-updated along with the code in future, but if not, I've at least left
-this version number in here so you can figure out what's changed by
-tracking commit comments from there onwards.
-
-\C{intro} Introduction
-
-The Puzzles code base is divided into four parts: a set of
-interchangeable front ends, a set of interchangeable back ends, a
-universal \q{middle end} which acts as a buffer between the two, and
-a bunch of miscellaneous utility functions. In the following
-sections I give some general discussion of each of these parts.
-
-\H{intro-frontend} Front end
-
-The front end is the non-portable part of the code: it's the bit
-that you replace completely when you port to a different platform.
-So it's responsible for all system calls, all GUI interaction, and
-anything else platform-specific.
-
-The front end contains \cw{main()} or the local platform's
-equivalent. Top-level control over the application's execution flow
-belongs to the front end (it isn't, for example, a set of functions
-called by a universal \cw{main()} somewhere else).
-
-The front end has complete freedom to design the GUI for any given
-port of Puzzles. There is no centralised mechanism for maintaining the
-menu layout, for example. This has a cost in consistency (when I
-\e{do} want the same menu layout on more than one platform, I have to
-edit N pieces of code in parallel every time I make a change), but the
-advantage is that local GUI conventions can be conformed to and local
-constraints adapted to. For example, MacOS has strict human interface
-guidelines which specify a different menu layout from the one I've
-used on Windows and GTK; there's nothing stopping the MacOS front end
-from providing a menu layout consistent with those guidelines.
-
-Although the front end is mostly caller rather than the callee in
-its interactions with other parts of the code, it is required to
-implement a small API for other modules to call, mostly of drawing
-functions for games to use when drawing their graphics. The drawing
-API is documented in \k{drawing}; the other miscellaneous front end
-API functions are documented in \k{frontend-api}.
-
-\H{intro-backend} Back end
-
-A \q{back end}, in this collection, is synonymous with a \q{puzzle}.
-Each back end implements a different game.
-
-At the top level, a back end is simply a data structure, containing
-a few constants (flag words, preferred pixel size) and a large
-number of function pointers. Back ends are almost invariably callee
-rather than caller, which means there's a limitation on what a back
-end can do on its own initiative.
-
-The persistent state in a back end is divided into a number of data
-structures, which are used for different purposes and therefore
-likely to be switched around, changed without notice, and otherwise
-updated by the rest of the code. It is important when designing a
-back end to put the right pieces of data into the right structures,
-or standard midend-provided features (such as Undo) may fail to
-work.
-
-The functions and variables provided in the back end data structure
-are documented in \k{backend}.
-
-\H{intro-midend} Middle end
-
-Puzzles has a single and universal \q{middle end}. This code is
-common to all platforms and all games; it sits in between the front
-end and the back end and provides standard functionality everywhere.
-
-People adding new back ends or new front ends should generally not
-need to edit the middle end. On rare occasions there might be a
-change that can be made to the middle end to permit a new game to do
-something not currently anticipated by the middle end's present
-design; however, this is terribly easy to get wrong and should
-probably not be undertaken without consulting the primary maintainer
-(me). Patch submissions containing unannounced mid-end changes will
-be treated on their merits like any other patch; this is just a
-friendly warning that mid-end changes will need quite a lot of
-merits to make them acceptable.
-
-Functionality provided by the mid-end includes:
-
-\b Maintaining a list of game state structures and moving back and
-forth along that list to provide Undo and Redo.
-
-\b Handling timers (for move animations, flashes on completion, and
-in some cases actually timing the game).
-
-\b Handling the container format of game IDs: receiving them,
-picking them apart into parameters, description and/or random seed,
-and so on. The game back end need only handle the individual parts
-of a game ID (encoded parameters and encoded game description);
-everything else is handled centrally by the mid-end.
-
-\b Handling standard keystrokes and menu commands, such as \q{New
-Game}, \q{Restart Game} and \q{Quit}.
-
-\b Pre-processing mouse events so that the game back ends can rely
-on them arriving in a sensible order (no missing button-release
-events, no sudden changes of which button is currently pressed,
-etc).
-
-\b Handling the dialog boxes which ask the user for a game ID.
-
-\b Handling serialisation of entire games (for loading and saving a
-half-finished game to a disk file; for handling application shutdown
-and restart on platforms such as PalmOS where state is expected to be
-saved; for storing the previous game in order to undo and redo across
-a New Game event).
-
-Thus, there's a lot of work done once by the mid-end so that
-individual back ends don't have to worry about it. All the back end
-has to do is cooperate in ensuring the mid-end can do its work
-properly.
-
-The API of functions provided by the mid-end to be called by the
-front end is documented in \k{midend}.
-
-\H{intro-utils} Miscellaneous utilities
-
-In addition to these three major structural components, the Puzzles
-code also contains a variety of utility modules usable by all of the
-above components. There is a set of functions to provide
-platform-independent random number generation; functions to make
-memory allocation easier; functions which implement a balanced tree
-structure to be used as necessary in complex algorithms; and a few
-other miscellaneous functions. All of these are documented in
-\k{utils}.
-
-\H{intro-structure} Structure of this guide
-
-There are a number of function call interfaces within Puzzles, and
-this guide will discuss each one in a chapter of its own. After
-that, \k{writing} discusses how to design new games, with some
-general design thoughts and tips.
-
-\C{backend} Interface to the back end
-
-This chapter gives a detailed discussion of the interface that each
-back end must implement.
-
-At the top level, each back end source file exports a single global
-symbol, which is a \c{const struct game} containing a large number
-of function pointers and a small amount of constant data. This
-structure is called by different names depending on what kind of
-platform the puzzle set is being compiled on:
-
-\b On platforms such as Windows and GTK, which build a separate
-binary for each puzzle, the game structure in every back end has the
-same name, \cq{thegame}; the front end refers directly to this name,
-so that compiling the same front end module against a different back
-end module builds a different puzzle.
-
-\b On platforms such as MacOS X and PalmOS, which build all the
-puzzles into a single monolithic binary, the game structure in each
-back end must have a different name, and there's a helper module
-\c{list.c} which constructs a complete list of those game structures
-from a header file generated by CMake.
-
-On the latter type of platform, source files may assume that the
-preprocessor symbol \c{COMBINED} has been defined. Thus, the usual
-code to declare the game structure looks something like this:
-
-\c #ifdef COMBINED
-\c #define thegame net    /* or whatever this game is called */
-\e                 iii    iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
-\c #endif
-\c 
-\c const struct game thegame = {
-\c     /* lots of structure initialisation in here */
-\e     iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
-\c };
-
-Game back ends must also internally define a number of data
-structures, for storing their various persistent state. This chapter
-will first discuss the nature and use of those structures, and then
-go on to give details of every element of the game structure.
-
-\H{backend-structs} Data structures
-
-Each game is required to define four separate data structures. This
-section discusses each one and suggests what sorts of things need to
-be put in it.
-
-\S{backend-game-params} \c{game_params}
-
-The \c{game_params} structure contains anything which affects the
-automatic generation of new puzzles. So if puzzle generation is
-parametrised in any way, those parameters need to be stored in
-\c{game_params}.
-
-Most puzzles currently in this collection are played on a grid of
-squares, meaning that the most obvious parameter is the grid size.
-Many puzzles have additional parameters; for example, Mines allows
-you to control the number of mines in the grid independently of its
-size, Net can be wrapping or non-wrapping, Solo has difficulty
-levels and symmetry settings, and so on.
-
-A simple rule for deciding whether a data item needs to go in
-\c{game_params} is: would the user expect to be able to control this
-data item from either the preset-game-types menu or the \q{Custom}
-game type configuration? If so, it's part of \c{game_params}.
-
-\c{game_params} structures are permitted to contain pointers to
-subsidiary data if they need to. The back end is required to provide
-functions to create and destroy \c{game_params}, and those functions
-can allocate and free additional memory if necessary. (It has not
-yet been necessary to do this in any puzzle so far, but the
-capability is there just in case.)
-
-\c{game_params} is also the only structure which the game's
-\cw{compute_size()} function may refer to; this means that any aspect
-of the game which affects the size of the window it needs to be drawn
-in (other than the magnification level) must be stored in
-\c{game_params}. In particular, this imposes the fundamental
-limitation that random game generation may not have a random effect on
-the window size: game generation algorithms are constrained to work by
-starting from the grid size rather than generating it as an emergent
-phenomenon. (Although this is a restriction in theory, it has not yet
-seemed to be a problem.)
-
-\S{backend-game-state} \c{game_state}
-
-While the user is actually playing a puzzle, the \c{game_state}
-structure stores all the data corresponding to the current state of
-play.
-
-The mid-end keeps \c{game_state}s in a list, and adds to the list
-every time the player makes a move; the Undo and Redo functions step
-back and forth through that list.
-
-Therefore, a good means of deciding whether a data item needs to go in
-\c{game_state} is: would a player expect that data item to be restored
-on undo? If so, put it in \c{game_state}, and this will automatically
-happen without you having to lift a finger. If not, then you might
-have found a data item that needs to go in \c{game_ui} instead.
-
-Two quite different examples of this:
-
-\b if the game provides an interface for making moves by moving a
-cursor around the grid with the keyboard and pressing some other key
-when you get to a square you want to change, then the location of that
-cursor belongs in \c{game_ui}, because the player will want to undo
-one \e{square change} at a time, not one \e{cursor movement} at a
-time.
-
-\b Mines tracks the number of times you opened a mine square and died.
-Every time you do that, you can only continue the game by pressing
-Undo. So the deaths counter belongs in \c{game_ui}, because otherwise,
-it would revert to 0 every time you undid your mistaken move.
-
-During play, \c{game_state}s are often passed around without an
-accompanying \c{game_params} structure. Therefore, any information
-in \c{game_params} which is important during play (such as the grid
-size) must be duplicated within the \c{game_state}. One simple
-method of doing this is to have the \c{game_state} structure
-\e{contain} a \c{game_params} structure as one of its members,
-although this isn't obligatory if you prefer to do it another way.
-
-\S{backend-game-drawstate} \c{game_drawstate}
-
-\c{game_drawstate} carries persistent state relating to the current
-graphical contents of the puzzle window. The same \c{game_drawstate}
-is passed to every call to the game redraw function, so that it can
-remember what it has already drawn and what needs redrawing.
-
-A typical use for a \c{game_drawstate} is to have an array mirroring
-the array of grid squares in the \c{game_state}, but describing what
-was drawn in the window on the most recent redraw. This is used to
-identify the squares that need redrawing next time, by deciding what
-the new value in that array should be, and comparing it to what was
-drawn last time. See \k{writing-howto-redraw} for more on this
-subject.
-
-\c{game_drawstate} is occasionally completely torn down and
-reconstructed by the mid-end, if the user somehow forces a full
-redraw. Therefore, no data should be stored in \c{game_drawstate}
-which is \e{not} related to the state of the puzzle window, because
-it might be unexpectedly destroyed.
-
-The back end provides functions to create and destroy
-\c{game_drawstate}, which means it can contain pointers to
-subsidiary allocated data if it needs to. A common thing to want to
-allocate in a \c{game_drawstate} is a \c{blitter}; see
-\k{drawing-blitter} for more on this subject.
-
-\S{backend-game-ui} \c{game_ui}
-
-\c{game_ui} contains whatever doesn't fit into the above three
-structures!
-
-A new \c{game_ui} is created when the user begins playing a new
-instance of a puzzle (i.e. during \q{New Game} or after entering a
-game ID etc). It persists until the user finishes playing that game
-and begins another one (or closes the window); in particular,
-\q{Restart Game} does \e{not} destroy the \c{game_ui}.
-
-There are various things that you might store in \c{game_ui}, which
-are conceptually different from each other, but I haven't yet found a
-need to split them out into smaller sub-structures for different
-purposes:
-
-\dt Transient UI state:
-
-\dd Storing a piece of UI state in \c{game_state} means that you can
-only update it by appending a move to the undo chain. Some UI state
-shouldn't really be treated this way. For example, if your puzzle has
-a keyboard-controlled cursor, you probably don't want every cursor
-movement to be an undoable action, because the history of where the
-cursor went just isn't interesting. More likely the cursor should just
-move freely, and the only undoable actions are the ones where you
-modify the element under the cursor. So you'd store the cursor
-position in \c{game_ui} rather than \c{game_state}. See
-\k{writing-keyboard-cursor} for more details.
-
-\lcont{ Another example of this is the state of an ongoing mouse drag.
-If there's an undoable action involved, it will probably occur when
-the drag is released. In between, you still need to store state that
-the redraw function will use to update the display \dash and that can
-live in \c{game_ui}. See \k{writing-howto-dragging} for more details
-of this. }
-
-\dt Persistent UI state:
-
-\dd An example of this is the counter of deaths in Mines or Inertia.
-This shouldn't be reverted by pressing Undo, for the opposite reason
-to the cursor position: the cursor position is too boring to store the
-history of, but the deaths counter is too \e{important}!
-
-\dt Information about recent changes to the game state:
-
-\dd This is used in Mines, for example, to indicate whether a
-requested \q{flash} should be a white flash for victory or a red flash
-for defeat; see \k{writing-flash-types}.
-
-\dt User preferences:
-
-\dd Any user preference about display or UI handled by
-\cw{get_prefs()} and \cw{set_prefs()} will need to live in
-\c{game_ui}, because that's the structure that those functions access.
-
-\H{backend-simple} Simple data in the back end
-
-In this section I begin to discuss each individual element in the
-back end structure. To begin with, here are some simple
-self-contained data elements.
-
-\S{backend-name} \c{name}
-
-\c const char *name;
-
-This is a simple ASCII string giving the name of the puzzle. This
-name will be used in window titles, in game selection menus on
-monolithic platforms, and anywhere else that the front end needs to
-know the name of a game.
-
-\S{backend-winhelp} \c{winhelp_topic} and \c{htmlhelp_topic}
-
-\c const char *winhelp_topic, *htmlhelp_topic;
-
-These members are used on Windows only, to provide online help.
-Although the Windows front end provides a separate binary for each
-puzzle, it has a single monolithic help file; so when a user selects
-\q{Help} from the menu, the program needs to open the help file and
-jump to the chapter describing that particular puzzle.
-
-This code base still supports the legacy \cw{.HLP} Windows Help format
-as well as the less old \cw{.CHM} HTML Help format. The two use
-different methods of identifying topics, so you have to specify both.
-
-Each chapter about a puzzle in \c{puzzles.but} is labelled with a
-\e{help topic} name for Windows Help, which typically appears just
-after the \cw{\\C} chapter title paragraph, similar to this:
-
-\c \C{net} \i{Net}
-\c
-\c \cfg{winhelp-topic}{games.net}
-
-But HTML Help is able to use the Halibut identifier for the chapter
-itself, i.e. the keyword that appears in braces immediatey after the
-\cw{\\C}.
-
-So the corresponding game back end encodes the \c{winhelp-topic}
-string (here \cq{games.net}) in the \c{winhelp_topic} element of the
-game structure, and puts the chapter identifier (here \cq{net}) in the
-\c{htmlhelp_topic} element. For example:
-
-\c const struct game thegame = {
-\c    "Net", "games.net", "net",
-\c    // ...
-\c };
-
-\H{backend-params} Handling game parameter sets
-
-In this section I present the various functions which handle the
-\c{game_params} structure.
-
-\S{backend-default-params} \cw{default_params()}
-
-\c game_params *(*default_params)(void);
-
-This function allocates a new \c{game_params} structure, fills it
-with the default values, and returns a pointer to it.
-
-\S{backend-fetch-preset} \cw{fetch_preset()}
-
-\c bool (*fetch_preset)(int i, char **name, game_params **params);
-
-This function is one of the two APIs a back end can provide to
-populate the \q{Type} menu, which provides a list of conveniently
-accessible preset parameters for most games.
-
-The function is called with \c{i} equal to the index of the preset
-required (numbering from zero). It returns \cw{false} if that preset
-does not exist (if \c{i} is less than zero or greater than the
-largest preset index). Otherwise, it sets \c{*params} to point at a
-newly allocated \c{game_params} structure containing the preset
-information, sets \c{*name} to point at a newly allocated C string
-containing the preset title (to go on the \q{Type} menu), and
-returns \cw{true}.
-
-If the game does not wish to support any presets at all, this
-function is permitted to return \cw{false} always.
-
-If the game wants to return presets in the form of a hierarchical menu
-instead of a flat list (and, indeed, even if it doesn't), then it may
-set this function pointer to \cw{NULL}, and instead fill in the
-alternative function pointer \cw{preset_menu}
-(\k{backend-preset-menu}).
-
-\S{backend-preset-menu} \cw{preset_menu()}
-
-\c struct preset_menu *(*preset_menu)(void);
-
-This function is the more flexible of the two APIs by which a back end
-can define a collection of preset game parameters.
-
-This function simply returns a complete menu hierarchy, in the form of
-a \c{struct preset_menu} (see \k{midend-get-presets}) and further
-submenus (if it wishes) dangling off it. There are utility functions
-described in \k{utils-presets} to make it easy for the back end to
-construct this menu.
-
-If the game has no need to return a hierarchy of menus, it may instead
-opt to implement the \cw{fetch_preset()} function (see
-\k{backend-fetch-preset}).
-
-The game need not fill in the \c{id} fields in the preset menu
-structures. The mid-end will do that after it receives the structure
-from the game, and before passing it on to the front end.
-
-\S{backend-encode-params} \cw{encode_params()}
-
-\c char *(*encode_params)(const game_params *params, bool full);
-
-The job of this function is to take a \c{game_params}, and encode it
-in a printable ASCII string form for use in game IDs. The return value must
-be a newly allocated C string, and \e{must} not contain a colon or a hash
-(since those characters are used to mark the end of the parameter
-section in a game ID).
-
-Ideally, it should also not contain any other potentially
-controversial punctuation; bear in mind when designing a string
-parameter format that it will probably be used on both Windows and
-Unix command lines under a variety of exciting shell quoting and
-metacharacter rules. Sticking entirely to alphanumerics is the
-safest thing; if you really need punctuation, you can probably get
-away with commas, periods or underscores without causing anybody any
-major inconvenience. If you venture far beyond that, you're likely
-to irritate \e{somebody}.
-
-(At the time of writing this, most existing games have purely
-alphanumeric string parameter formats. Usually these involve a
-letter denoting a parameter, followed optionally by a number giving
-the value of that parameter, with a few mandatory parts at the
-beginning such as numeric width and height separated by \cq{x}.)
-
-If the \c{full} parameter is \cw{true}, this function should encode
-absolutely everything in the \c{game_params}, such that a subsequent
-call to \cw{decode_params()} (\k{backend-decode-params}) will yield
-an identical structure. If \c{full} is \cw{false}, however, you
-should leave out anything which is not necessary to describe a
-\e{specific puzzle instance}, i.e. anything which only takes effect
-when a new puzzle is \e{generated}.
-
-For example, the Solo \c{game_params} includes a difficulty rating
-used when constructing new puzzles; but a Solo game ID need not
-explicitly include the difficulty, since to describe a puzzle once
-generated it's sufficient to give the grid dimensions and the location
-and contents of the clue squares. (Indeed, one might very easily type
-in a puzzle out of a newspaper without \e{knowing} what its difficulty
-level is in Solo's terminology.) Therefore, Solo's
-\cw{encode_params()} only encodes the difficulty level if \c{full} is
-set.
-
-\S{backend-decode-params} \cw{decode_params()}
-
-\c void (*decode_params)(game_params *params, char const *string);
-
-This function is the inverse of \cw{encode_params()}
-(\k{backend-encode-params}). It parses the supplied string and fills
-in the supplied \c{game_params} structure. Note that the structure
-will \e{already} have been allocated: this function is not expected
-to create a \e{new} \c{game_params}, but to modify an existing one.
-
-This function can receive a string which only encodes a subset of
-the parameters. The most obvious way in which this can happen is if
-the string was constructed by \cw{encode_params()} with its \c{full}
-parameter set to \cw{false}; however, it could also happen if the
-user typed in a parameter set manually and missed something out. Be
-prepared to deal with a wide range of possibilities.
-
-When dealing with a parameter which is not specified in the input
-string, what to do requires a judgment call on the part of the
-programmer. Sometimes it makes sense to adjust other parameters to
-bring them into line with the new ones. In Mines, for example, you
-would probably not want to keep the same mine count if the user
-dropped the grid size and didn't specify one, since you might easily
-end up with more mines than would actually fit in the grid! On the
-other hand, sometimes it makes sense to leave the parameter alone: a
-Solo player might reasonably expect to be able to configure size and
-difficulty independently of one another.
-
-This function currently has no direct means of returning an error if
-the string cannot be parsed at all. However, the returned
-\c{game_params} is almost always subsequently passed to
-\cw{validate_params()} (\k{backend-validate-params}), so if you
-really want to signal parse errors, you could always have a \c{char
-*} in your parameters structure which stored an error message, and
-have \cw{validate_params()} return it if it is non-\cw{NULL}.
-
-\S{backend-free-params} \cw{free_params()}
-
-\c void (*free_params)(game_params *params);
-
-This function frees a \c{game_params} structure, and any subsidiary
-allocations contained within it.
-
-\S{backend-dup-params} \cw{dup_params()}
-
-\c game_params *(*dup_params)(const game_params *params);
-
-This function allocates a new \c{game_params} structure and
-initialises it with an exact copy of the information in the one
-provided as input. It returns a pointer to the new duplicate.
-
-\S{backend-can-configure} \c{can_configure}
-
-\c bool can_configure;
-
-This data element is set to \cw{true} if the back end supports custom
-parameter configuration via a dialog box. If it is \cw{true}, then the
-functions \cw{configure()} and \cw{custom_params()} are expected to
-work. See \k{backend-configure} and \k{backend-custom-params} for more
-details.
-
-\S{backend-configure} \cw{configure()}
-
-\c config_item *(*configure)(const game_params *params);
-
-This function is called when the user requests a dialog box for
-custom parameter configuration. It returns a newly allocated array
-of \cw{config_item} structures, describing the GUI elements required
-in the dialog box. The array should have one more element than the
-number of controls, since it is terminated with a \cw{C_END} marker
-(see below). Each array element describes the control together with
-its initial value; the front end will modify the value fields and
-return the updated array to \cw{custom_params()} (see
-\k{backend-custom-params}).
-
-The \cw{config_item} structure contains the following elements used by
-this function:
-
-\c const char *name;
-\c int type;
-\c union { /* type-specific fields */ } u;
-\e         iiiiiiiiiiiiiiiiiiiiiiiiii
-
-\c{name} is an ASCII string giving the textual label for a GUI
-control. It is \e{not} expected to be dynamically allocated.
-
-\c{type} contains one of a small number of \c{enum} values defining
-what type of control is being described. The usable member of the
-union field \c{u} depends on \c{type}. The valid type values are:
-
-\dt \c{C_STRING}
-
-\dd Describes a text input box. (This is also used for numeric
-input. The back end does not bother informing the front end that the
-box is numeric rather than textual; some front ends do have the
-capacity to take this into account, but I decided it wasn't worth
-the extra complexity in the interface.)
-
-\lcont{
-
-For controls of this type, \c{u.string} contains a single field
-
-\c char *sval;
-
-which stores a dynamically allocated string representing the contents
-of the input box.
-
-}
-
-\dt \c{C_BOOLEAN}
-
-\dd Describes a simple checkbox.
-
-\lcont{
-
-For controls of this type, \c{u.boolean} contains a single field
-
-\c bool bval;
-
-}
-
-\dt \c{C_CHOICES}
-
-\dd Describes a drop-down list presenting one of a small number of
-fixed choices.
-
-\lcont{
-
-For controls of this type, \c{u.choices} contains two fields:
-
-\c const char *choicenames;
-\c int selected;
-
-\c{choicenames} contains a list of strings describing the choices. The
-very first character of \c{sval} is used as a delimiter when
-processing the rest (so that the strings \cq{:zero:one:two},
-\cq{!zero!one!two} and \cq{xzeroxonextwo} all define a three-element
-list containing \cq{zero}, \cq{one} and \cq{two}).
-
-\c{selected} contains the index of the currently selected element,
-numbering from zero (so that in the above example, 0 would mean
-\cq{zero} and 2 would mean \cq{two}).
-
-Note that \c{u.choices.choicenames} is \e{not} dynamically allocated,
-unlike \c{u.string.sval}.
-
-}
-
-\dt \c{C_END}
-
-\dd Marks the end of the array of \c{config_item}s. There is no
-associated member of the union field \c{u} for this type.
-
-The array returned from this function is expected to have filled in
-the initial values of all the controls according to the input
-\c{game_params} structure.
-
-If the game's \c{can_configure} flag is set to \cw{false}, this
-function is never called and can be \cw{NULL}.
-
-\S{backend-custom-params} \cw{custom_params()}
-
-\c game_params *(*custom_params)(const config_item *cfg);
-
-This function is the counterpart to \cw{configure()}
-(\k{backend-configure}). It receives as input an array of
-\c{config_item}s which was originally created by \cw{configure()},
-but in which the control values have since been changed in
-accordance with user input. Its function is to read the new values
-out of the controls and return a newly allocated \c{game_params}
-structure representing the user's chosen parameter set.
-
-(The front end will have modified the controls' \e{values}, but
-there will still always be the same set of controls, in the same
-order, as provided by \cw{configure()}. It is not necessary to check
-the \c{name} and \c{type} fields, although you could use
-\cw{assert()} if you were feeling energetic.)
-
-This function is not expected to (and indeed \e{must not}) free the
-input \c{config_item} array. (If the parameters fail to validate,
-the dialog box will stay open.)
-
-If the game's \c{can_configure} flag is set to \cw{false}, this
-function is never called and can be \cw{NULL}.
-
-\S{backend-get-prefs} \cw{get_prefs()}
-
-\c config_item *(*get_prefs)(game_ui *ui);
-
-This function works very like \cw{configure()}, but instead of
-receiving a \c{game_params} and returning GUI elements describing the
-data in it, this function receives a \c{game_ui} and returns GUI
-elements describing any user preferences stored in that.
-
-This function should only deal with fields of \c{game_ui} that are
-user-settable preferences. In-game state like cursor position and
-mouse drags, or per-game state like death counters, are nothing to do
-with this function.
-
-If there are no user preferences, you can set both this function
-pointer and \c{set_prefs} to \cw{NULL}.
-
-If you implement these functions, you must also ensure that your
-game's \cw{new_ui()} function can be called with a null \c{game_state}
-pointer. (See \k{backend-new-ui}.)
-
-In every \c{config_item} returned from this function, you must set an
-additional field beyond the ones described in \k{backend-configure}:
-
-\c const char *kw;
-
-This should be an identifying keyword for the user preference in
-question, suitable for use in configuration files. That means it
-should remain stable, even if the user-facing wording in the \c{name}
-field is reworded for clarity. If it doesn't stay stable, old
-configuration files will not be read correctly.
-
-For \c{config_item}s of type \cw{C_CHOICES}, you must also set an
-extra field in \c{u.choices}:
-
-\c const char *choicekws;
-
-This has the same structure as the \c{choicenames} field (a list of
-values delimited by the first character in the whole string), and it
-provides an identifying keyword for each individual choice in the
-list, in the same order as the entries of \c{choicenames}.
-
-\S{backend-set-prefs} \cw{set_prefs()}
-
-\c void (*set_prefs)(game_ui *ui, const config_item *cfg);
-
-This function is the counterpart to \cw{set_prefs()}, as
-\cw{custom_params()} is to \cw{configure()}. It receives an array of
-\c{config_item}s which was originally created by \cw{get_prefs()},
-with the controls' values updated from user input, and it should
-transcribe the new settings into the provided \c{game_ui}.
-
-If there are no user preferences, you can set both this function
-pointer and \c{get_prefs} to \cw{NULL}.
-
-\S{backend-validate-params} \cw{validate_params()}
-
-\c const char *(*validate_params)(const game_params *params,
-\c                                bool full);
-
-This function takes a \c{game_params} structure as input, and checks
-that the parameters described in it fall within sensible limits. (At
-the very least, grid dimensions should almost certainly be strictly
-positive, for example.)
-
-Return value is \cw{NULL} if no problems were found, or
-alternatively a (non-dynamically-allocated) ASCII string describing
-the error in human-readable form.
-
-If the \c{full} parameter is set, full validation should be
-performed: any set of parameters which would not permit generation
-of a sensible puzzle should be faulted. If \c{full} is \e{not} set,
-the implication is that these parameters are not going to be used
-for \e{generating} a puzzle; so parameters which can't even sensibly
-\e{describe} a valid puzzle should still be faulted, but parameters
-which only affect puzzle generation should not be.
-
-(The \c{full} option makes a difference when parameter combinations
-are non-orthogonal. For example, Net has a boolean option
-controlling whether it enforces a unique solution; it turns out that
-it's impossible to generate a uniquely soluble puzzle with wrapping
-walls and width 2, so \cw{validate_params()} will complain if you
-ask for one. However, if the user had just been playing a unique
-wrapping puzzle of a more sensible width, and then pastes in a game
-ID acquired from somebody else which happens to describe a
-\e{non}-unique wrapping width-2 puzzle, then \cw{validate_params()}
-will be passed a \c{game_params} containing the width and wrapping
-settings from the new game ID and the uniqueness setting from the
-old one. This would be faulted, if it weren't for the fact that
-\c{full} is not set during this call, so Net ignores the
-inconsistency. The resulting \c{game_params} is never subsequently
-used to generate a puzzle; this is a promise made by the mid-end
-when it asks for a non-full validation.)
-
-\H{backend-descs} Handling game descriptions
-
-In this section I present the functions that deal with a textual
-description of a puzzle, i.e. the part that comes after the colon in
-a descriptive-format game ID.
-
-\S{backend-new-desc} \cw{new_desc()}
-
-\c char *(*new_desc)(const game_params *params, random_state *rs,
-\c                   char **aux, bool interactive);
-
-This function is where all the really hard work gets done. This is
-the function whose job is to randomly generate a new puzzle,
-ensuring solubility and uniqueness as appropriate.
-
-As input it is given a \c{game_params} structure and a random state
-(see \k{utils-random} for the random number API). It must invent a
-puzzle instance, encode it in printable ASCII string form, and
-return a dynamically allocated C string containing that encoding.
-
-Additionally, it may return a second dynamically allocated string in
-\c{*aux}. (If it doesn't want to, then it can leave that parameter
-completely alone; it isn't required to set it to \cw{NULL}, although
-doing so is harmless.) That string, if present, will be passed to
-\cw{solve()} (\k{backend-solve}) later on; so if the puzzle is
-generated in such a way that a solution is known, then information
-about that solution can be saved in \c{*aux} for \cw{solve()} to
-use.
-
-The \c{interactive} parameter should be ignored by almost all
-puzzles. Its purpose is to distinguish between generating a puzzle
-within a GUI context for immediate play, and generating a puzzle in
-a command-line context for saving to be played later. The only
-puzzle that currently uses this distinction (and, I fervently hope,
-the only one which will \e{ever} need to use it) is Mines, which
-chooses a random first-click location when generating puzzles
-non-interactively, but which waits for the user to place the first
-click when interactive. If you think you have come up with another
-puzzle which needs to make use of this parameter, please think for
-at least ten minutes about whether there is \e{any} alternative!
-
-Note that game description strings are not required to contain an
-encoding of parameters such as grid size; a game description is
-never separated from the \c{game_params} it was generated with, so
-any information contained in that structure need not be encoded
-again in the game description.
-
-\S{backend-validate-desc} \cw{validate_desc()}
-
-\c const char *(*validate_desc)(const game_params *params,
-\c                              const char *desc);
-
-This function is given a game description, and its job is to
-validate that it describes a puzzle which makes sense.
-
-To some extent it's up to the user exactly how far they take the
-phrase \q{makes sense}; there are no particularly strict rules about
-how hard the user is permitted to shoot themself in the foot when
-typing in a bogus game description by hand. (For example, Rectangles
-will not verify that the sum of all the numbers in the grid equals
-the grid's area. So a user could enter a puzzle which was provably
-not soluble, and the program wouldn't complain; there just wouldn't
-happen to be any sequence of moves which solved it.)
-
-The one non-negotiable criterion is that any game description which
-makes it through \cw{validate_desc()} \e{must not} subsequently
-cause a crash or an assertion failure when fed to \cw{new_game()}
-and thence to the rest of the back end.
-
-The return value is \cw{NULL} on success, or a
-non-dynamically-allocated C string containing an error message.
-
-\S{backend-new-game} \cw{new_game()}
-
-\c game_state *(*new_game)(midend *me, const game_params *params,
-\c                         const char *desc);
-
-This function takes a game description as input, together with its
-accompanying \c{game_params}, and constructs a \c{game_state}
-describing the initial state of the puzzle. It returns a newly
-allocated \c{game_state} structure.
-
-Almost all puzzles should ignore the \c{me} parameter. It is
-required by Mines, which needs it for later passing to
-\cw{midend_supersede_game_desc()} (see \k{backend-supersede}) once
-the user has placed the first click. I fervently hope that no other
-puzzle will be awkward enough to require it, so everybody else
-should ignore it. As with the \c{interactive} parameter in
-\cw{new_desc()} (\k{backend-new-desc}), if you think you have a
-reason to need this parameter, please try very hard to think of an
-alternative approach!
-
-\H{backend-states} Handling game states
-
-This section describes the functions which create and destroy
-\c{game_state} structures.
-
-(Well, except \cw{new_game()}, which is in \k{backend-new-game}
-instead of under here; but it deals with game descriptions \e{and}
-game states and it had to go in one section or the other.)
-
-\S{backend-dup-game} \cw{dup_game()}
-
-\c game_state *(*dup_game)(const game_state *state);
-
-This function allocates a new \c{game_state} structure and
-initialises it with an exact copy of the information in the one
-provided as input. It returns a pointer to the new duplicate.
-
-\S{backend-free-game} \cw{free_game()}
-
-\c void (*free_game)(game_state *state);
-
-This function frees a \c{game_state} structure, and any subsidiary
-allocations contained within it.
-
-\H{backend-ui} Handling \c{game_ui}
-
-\S{backend-new-ui} \cw{new_ui()}
-
-\c game_ui *(*new_ui)(const game_state *state);
-
-This function allocates and returns a new \c{game_ui} structure for
-playing a particular puzzle.
-
-Usually, this function is passed a pointer to the initial
-\c{game_state}, in case it needs to refer to that when setting up the
-initial values for the new game.
-
-However, if the puzzle defines \c{get_prefs()} and \c{set_prefs()}
-functions, then this function may also be called with
-\cw{state==NULL}. In this situation it must still allocate a
-\c{game_ui} which can be used by \c{get_prefs()} and \c{set_prefs()},
-although it need not be usable for actually playing a game.
-
-\S{backend-free-ui} \cw{free_ui()}
-
-\c void (*free_ui)(game_ui *ui);
-
-This function frees a \c{game_ui} structure, and any subsidiary
-allocations contained within it.
-
-\S{backend-encode-ui} \cw{encode_ui()}
-
-\c char *(*encode_ui)(const game_ui *ui);
-
-This function encodes any \e{important} data in a \c{game_ui}
-structure in printable ASCII string form. It is only called when
-saving a half-finished game to a file.
-
-It should be used sparingly. Almost all data in a \c{game_ui} is not
-important enough to save. The location of the keyboard-controlled
-cursor, for example, can be reset to a default position on reloading
-the game without impacting the user experience. If the user should
-somehow manage to save a game while a mouse drag was in progress,
-then discarding that mouse drag would be an outright \e{feature}.
-
-A typical thing that \e{would} be worth encoding in this function is
-the Mines death counter: it's in the \c{game_ui} rather than the
-\c{game_state} because it's too important to allow the user to
-revert it by using Undo, and therefore it's also too important to
-allow the user to revert it by saving and reloading. (Of course, the
-user could edit the save file by hand... But if the user is \e{that}
-determined to cheat, they could just as easily modify the game's
-source.)
-
-The \cw{encode_ui()} function is optional.  If a back-end doesn't need
-this function it can just set the pointer to \cw{NULL}.
-
-\S{backend-decode-ui} \cw{decode_ui()}
-
-\c void (*decode_ui)(game_ui *ui, const char *encoding,
-\c                   const game_state *state);
-
-This function parses a string previously output by \cw{encode_ui()},
-and writes the decoded data back into the freshly-created \c{game_ui}
-structure provided.  If the string is invalid, the function should do
-the best it can, which might just mean not changing the \c{game_ui}
-structure at all.  This might happen if a save file is corrupted, or
-simply from a newer version that encodes more \c{game_ui} data.  The
-current \c{game_state} is provided in case the function needs to
-refer to it for validation.
-
-Like \cw{encode_ui()}, \cw{decode_ui()} is optional.  If a back-end
-doesn't need this function it can just set the pointer to \cw{NULL}.
-
-\S{backend-changed-state} \cw{changed_state()}
-
-\c void (*changed_state)(game_ui *ui, const game_state *oldstate,
-\c                       const game_state *newstate);
-
-This function is called by the mid-end whenever the current game
-state changes, for any reason. Those reasons include:
-
-\b a fresh move being made by \cw{interpret_move()} and
-\cw{execute_move()}
-
-\b a solve operation being performed by \cw{solve()} and
-\cw{execute_move()}
-
-\b the user moving back and forth along the undo list by means of
-the Undo and Redo operations
-
-\b the user selecting Restart to go back to the initial game state.
-
-The job of \cw{changed_state()} is to update the \c{game_ui} for
-consistency with the new game state, if any update is necessary. For
-example, Same Game stores data about the currently selected tile
-group in its \c{game_ui}, and this data is intrinsically related to
-the game state it was derived from. So it's very likely to become
-invalid when the game state changes; thus, Same Game's
-\cw{changed_state()} function clears the current selection whenever
-it is called.
-
-When \cw{anim_length()} or \cw{flash_length()} are called, you can
-be sure that there has been a previous call to \cw{changed_state()}.
-So \cw{changed_state()} can set up data in the \c{game_ui} which will
-be read by \cw{anim_length()} and \cw{flash_length()}, and those
-functions will not have to worry about being called without the data
-having been initialised.
-
-\H{backend-moves} Making moves
-
-This section describes the functions which actually make moves in
-the game: that is, the functions which process user input and end up
-producing new \c{game_state}s.
-
-\S{backend-interpret-move} \cw{interpret_move()}
-
-\c char *(*interpret_move)(const game_state *state, game_ui *ui,
-\c                         const game_drawstate *ds,
-\c                         int x, int y, int button);
-
-This function receives user input and processes it. Its input
-parameters are the current \c{game_state}, the current \c{game_ui}
-and the current \c{game_drawstate}, plus details of the input event.
-\c{button} is either an ASCII value or a special code (listed below)
-indicating an arrow or function key or a mouse event; when
-\c{button} is a mouse event, \c{x} and \c{y} contain the pixel
-coordinates of the mouse pointer relative to the top left of the
-puzzle's drawing area.
-
-(The pointer to the \c{game_drawstate} is marked \c{const}, because
-\c{interpret_move} should not write to it. The normal use of that
-pointer will be to read the game's tile size parameter in order to
-divide mouse coordinates by it.)
-
-\cw{interpret_move()} may return in four different ways:
-
-\b Returning \cw{MOVE_UNUSED} or \cw{MOVE_NO_EFFECT} indicates that no
-action whatsoever occurred in response to the input event; the puzzle
-was not interested in it at all.  The distinction between this is that
-\cw{MOVE_NO_EFFECT} implies that the state of the game is what makes
-the event uninteresting, while \cw{MOVE_NO_EFFECT} means that the
-event is intrinsically uninteresting.  For example, a mouse click on
-an already-revealed square in Mines might return \cw{MOVE_NO_EFFECT}
-while a click outside the board would return \cw{MOVE_UNUSED}.
-
-\b Returning the special value \cw{MOVE_UI_UPDATE} indicates that the input
-event has resulted in a change being made to the \c{game_ui} which
-will require a redraw of the game window, but that no actual \e{move}
-was made (i.e. no new \c{game_state} needs to be created).
-
-\b Returning anything else indicates that a move was made and that a
-new \c{game_state} must be created. However, instead of actually
-constructing a new \c{game_state} itself, this function is required
-to return a printable ASCII string description of the details of the
-move. This string will be passed to \cw{execute_move()}
-(\k{backend-execute-move}) to actually create the new
-\c{game_state}. (Encoding moves as strings in this way means that
-the mid-end can keep the strings as well as the game states, and the
-strings can be written to disk when saving the game and fed to
-\cw{execute_move()} again on reloading.)
-
-The return value from \cw{interpret_move()} is expected to be
-dynamically allocated if and only if it is not either \cw{NULL}
-\e{or} one of the special string constants \cw{MOVE_UNUSED},
-\cw{MOVE_NO_EFFECT}, or \cw{MOVE_UI_UPDATE}.
-
-After this function is called, the back end is permitted to rely on
-some subsequent operations happening in sequence:
-
-\b \cw{execute_move()} will be called to convert this move
-description into a new \c{game_state}
-
-\b \cw{changed_state()} will be called with the new \c{game_state}.
-
-This means that if \cw{interpret_move()} needs to do updates to the
-\c{game_ui} which are easier to perform by referring to the new
-\c{game_state}, it can safely leave them to be done in
-\cw{changed_state()} and not worry about them failing to happen.
-
-(Note, however, that \cw{execute_move()} may \e{also} be called in
-other circumstances. It is only \cw{interpret_move()} which can rely
-on a subsequent call to \cw{changed_state()}.)
-
-The special key codes supported by this function are:
-
-\dt \cw{LEFT_BUTTON}, \cw{MIDDLE_BUTTON}, \cw{RIGHT_BUTTON}
-
-\dd Indicate that one of the mouse buttons was pressed down.
-
-\dt \cw{LEFT_DRAG}, \cw{MIDDLE_DRAG}, \cw{RIGHT_DRAG}
-
-\dd Indicate that the mouse was moved while one of the mouse buttons
-was still down. The mid-end guarantees that when one of these events
-is received, it will always have been preceded by a button-down
-event (and possibly other drag events) for the same mouse button,
-and no event involving another mouse button will have appeared in
-between.
-
-\dt \cw{LEFT_RELEASE}, \cw{MIDDLE_RELEASE}, \cw{RIGHT_RELEASE}
-
-\dd Indicate that a mouse button was released.  The mid-end
-guarantees that when one of these events is received, it will always
-have been preceded by a button-down event (and possibly some drag
-events) for the same mouse button, and no event involving another
-mouse button will have appeared in between.
-
-\dt \cw{CURSOR_UP}, \cw{CURSOR_DOWN}, \cw{CURSOR_LEFT},
-\cw{CURSOR_RIGHT}
-
-\dd Indicate that an arrow key was pressed.
-
-\dt \cw{CURSOR_SELECT}, \cw{CURSOR_SELECT2}
-
-\dd On platforms which have one or two prominent \q{select} button
-alongside their cursor keys, indicates that one of those buttons was
-pressed.  On other platforms, these represent the Enter (or Return)
-and Space keys respectively.
-
-In addition, there are some modifiers which can be bitwise-ORed into
-the \c{button} parameter:
-
-\dt \cw{MOD_CTRL}, \cw{MOD_SHFT}
-
-\dd These indicate that the Control or Shift key was pressed alongside
-the key. They only apply to the cursor keys and the ASCII horizontal
-tab character \cw{\\t}, not to mouse buttons or anything else.
-
-\dt \cw{MOD_NUM_KEYPAD}
-
-\dd This applies to some ASCII values, and indicates that the key
-code was input via the numeric keypad rather than the main keyboard.
-Some puzzles may wish to treat this differently (for example, a
-puzzle might want to use the numeric keypad as an eight-way
-directional pad), whereas others might not (a game involving numeric
-input probably just wants to treat the numeric keypad as numbers).
-
-\dt \cw{MOD_MASK}
-
-\dd This mask is the bitwise OR of all the available modifiers; you
-can bitwise-AND with \cw{~MOD_MASK} to strip all the modifiers off any
-input value; as this is a common operation, the
-\cw{STRIP_BUTTON_MODIFIERS()} macro can do this for you (see
-\k{utils-strip-button-modifiers}).
-
-\S{backend-execute-move} \cw{execute_move()}
-
-\c game_state *(*execute_move)(const game_state *state, char *move);
-
-This function takes an input \c{game_state} and a move string as
-output from \cw{interpret_move()}. It returns a newly allocated
-\c{game_state} which contains the result of applying the specified
-move to the input game state.
-
-This function may return \cw{NULL} if it cannot parse the move
-string (and this is definitely preferable to crashing or failing an
-assertion, since one way this can happen is if loading a corrupt
-save file). However, it must not return \cw{NULL} for any move
-string that really was output from \cw{interpret_move()}: this is
-punishable by assertion failure in the mid-end.
-
-\S{backend-can-solve} \c{can_solve}
-
-\c bool can_solve;
-
-This field is set to \cw{true} if the game's \cw{solve()} function
-does something. If it's set to \cw{false}, the game will not even
-offer the \q{Solve} menu option.
-
-\S{backend-solve} \cw{solve()}
-
-\c char *(*solve)(const game_state *orig, const game_state *curr,
-\c                const char *aux, const char **error);
-
-This function is called when the user selects the \q{Solve} option
-from the menu.  If \cw{can_solve} is \cw{false} then it will never
-be called and can be \cw{NULL}.
-
-It is passed two input game states: \c{orig} is the game state from
-the very start of the puzzle, and \c{curr} is the current one.
-(Different games find one or other or both of these convenient.) It
-is also passed the \c{aux} string saved by \cw{new_desc()}
-(\k{backend-new-desc}), in case that encodes important information
-needed to provide the solution.
-
-If this function is unable to produce a solution (perhaps, for
-example, the game has no in-built solver so it can only solve
-puzzles it invented internally and has an \c{aux} string for) then
-it may return \cw{NULL}. If it does this, it must also set
-\c{*error} to an error message to be presented to the user (such as
-\q{Solution not known for this puzzle}); that error message is not
-expected to be dynamically allocated.
-
-If this function \e{does} produce a solution, it returns a printable
-ASCII move string suitable for feeding to \cw{execute_move()}
-(\k{backend-execute-move}). Like a (non-empty) string returned from
-\cw{interpret_move()}, the returned string should be dynamically
-allocated.
-
-\H{backend-drawing} Drawing the game graphics
-
-This section discusses the back end functions that deal with
-drawing.
-
-\S{backend-new-drawstate} \cw{new_drawstate()}
-
-\c game_drawstate *(*new_drawstate)(drawing *dr,
-\c                                  const game_state *state);
-
-This function allocates and returns a new \c{game_drawstate}
-structure for drawing a particular puzzle. It is passed a pointer to
-a \c{game_state}, in case it needs to refer to that when setting up
-any initial data.
-
-This function may not rely on the puzzle having been newly started;
-a new draw state can be constructed at any time if the front end
-requests a forced redraw. For games like Pattern, in which initial
-game states are much simpler than general ones, this might be
-important to keep in mind.
-
-The parameter \c{dr} is a drawing object (see \k{drawing}) which the
-function might need to use to allocate blitters. (However, this
-isn't recommended; it's usually more sensible to wait to allocate a
-blitter until \cw{set_size()} is called, because that way you can
-tailor it to the scale at which the puzzle is being drawn.)
-
-\S{backend-free-drawstate} \cw{free_drawstate()}
-
-\c void (*free_drawstate)(drawing *dr, game_drawstate *ds);
-
-This function frees a \c{game_drawstate} structure, and any
-subsidiary allocations contained within it.
-
-The parameter \c{dr} is a drawing object (see \k{drawing}), which
-might be required if you are freeing a blitter.
-
-\S{backend-preferred-tilesize} \c{preferred_tilesize}
-
-\c int preferred_tilesize;
-
-Each game is required to define a single integer parameter which
-expresses, in some sense, the scale at which it is drawn. This is
-described in the APIs as \cq{tilesize}, since most puzzles are on a
-square (or possibly triangular or hexagonal) grid and hence a
-sensible interpretation of this parameter is to define it as the
-size of one grid tile in pixels; however, there's no actual
-requirement that the \q{tile size} be proportional to the game
-window size. Window size is required to increase monotonically with
-\q{tile size}, however.
-
-The data element \c{preferred_tilesize} indicates the tile size which
-should be used in the absence of a good reason to do otherwise (such
-as the screen being too small to fit the whole puzzle, or the user
-explicitly requesting a resize).
-
-\S{backend-compute-size} \cw{compute_size()}
-
-\c void (*compute_size)(const game_params *params, int tilesize,
-\c                      const game_ui *ui, int *x, int *y);
-
-This function is passed a \c{game_params} structure and a tile size.
-It returns, in \c{*x} and \c{*y}, the size in pixels of the drawing
-area that would be required to render a puzzle with those parameters
-at that tile size.
-
-\S{backend-set-size} \cw{set_size()}
-
-\c void (*set_size)(drawing *dr, game_drawstate *ds,
-\c                  const game_params *params, int tilesize);
-
-This function is responsible for setting up a \c{game_drawstate} to
-draw at a given tile size. Typically this will simply involve
-copying the supplied \c{tilesize} parameter into a \c{tilesize}
-field inside the draw state; for some more complex games it might
-also involve setting up other dimension fields, or possibly
-allocating a blitter (see \k{drawing-blitter}).
-
-The parameter \c{dr} is a drawing object (see \k{drawing}), which is
-required if a blitter needs to be allocated.
-
-Back ends may assume (and may enforce by assertion) that this
-function will be called at most once for any \c{game_drawstate}. If
-a puzzle needs to be redrawn at a different size, the mid-end will
-create a fresh drawstate.
-
-\S{backend-colours} \cw{colours()}
-
-\c float *(*colours)(frontend *fe, int *ncolours);
-
-This function is responsible for telling the front end what colours
-the puzzle will need to draw itself.
-
-It returns the number of colours required in \c{*ncolours}, and the
-return value from the function itself is a dynamically allocated
-array of three times that many \c{float}s, containing the red, green
-and blue components of each colour respectively as numbers in the
-range [0,1].
-
-The second parameter passed to this function is a front end handle.
-The only things it is permitted to do with this handle are to call
-the front-end function called \cw{frontend_default_colour()} (see
-\k{frontend-default-colour}) or the utility function called
-\cw{game_mkhighlight()} (see \k{utils-game-mkhighlight}). (The
-latter is a wrapper on the former, so front end implementors only
-need to provide \cw{frontend_default_colour()}.) This allows
-\cw{colours()} to take local configuration into account when
-deciding on its own colour allocations. Most games use the front
-end's default colour as their background, apart from a few which
-depend on drawing relief highlights so they adjust the background
-colour if it's too light for highlights to show up against it.
-
-The first colour in the list is slightly special. The mid-end fills
-the drawing area with it before the first call to \cw{redraw()} (see
-\k{backend-redraw}).  Some front ends also use it fill the part of the
-puzzle window outside the puzzle.  This means that it is usually
-sensible to make colour 0 the background colour for the puzzle.
-
-Note that the colours returned from this function are for
-\e{drawing}, not for printing. Printing has an entirely different
-colour allocation policy.
-
-\S{backend-anim-length} \cw{anim_length()}
-
-\c float (*anim_length)(const game_state *oldstate,
-\c                      const game_state *newstate,
-\c                      int dir, game_ui *ui);
-
-This function is called when a move is made, undone or redone. It is
-given the old and the new \c{game_state}, and its job is to decide
-whether the transition between the two needs to be animated or can
-be instant.
-
-\c{oldstate} is the state that was current until this call;
-\c{newstate} is the state that will be current after it. \c{dir}
-specifies the chronological order of those states: if it is
-positive, then the transition is the result of a move or a redo (and
-so \c{newstate} is the later of the two moves), whereas if it is
-negative then the transition is the result of an undo (so that
-\c{newstate} is the \e{earlier} move).
-
-If this function decides the transition should be animated, it
-returns the desired length of the animation in seconds. If not, it
-returns zero.
-
-State changes as a result of a Restart operation are never animated;
-the mid-end will handle them internally and never consult this
-function at all. State changes as a result of Solve operations are
-also not animated by default, although you can change this for a
-particular game by setting a flag in \c{flags} (\k{backend-flags}).
-
-The function is also passed a pointer to the local \c{game_ui}. It
-may refer to information in here to help with its decision (see
-\k{writing-conditional-anim} for an example of this), and/or it may
-\e{write} information about the nature of the animation which will
-be read later by \cw{redraw()}.
-
-When this function is called, it may rely on \cw{changed_state()}
-having been called previously, so if \cw{anim_length()} needs to
-refer to information in the \c{game_ui}, then \cw{changed_state()}
-is a reliable place to have set that information up.
-
-Move animations do not inhibit further input events. If the user
-continues playing before a move animation is complete, the animation
-will be abandoned and the display will jump straight to the final
-state.
-
-\S{backend-flash-length} \cw{flash_length()}
-
-\c float (*flash_length)(const game_state *oldstate,
-\c                       const game_state *newstate,
-\c                       int dir, game_ui *ui);
-
-This function is called when a move is completed. (\q{Completed}
-means that not only has the move been made, but any animation which
-accompanied it has finished.) It decides whether the transition from
-\c{oldstate} to \c{newstate} merits a \q{flash}.
-
-A flash is much like a move animation, but it is \e{not} interrupted
-by further user interface activity; it runs to completion in
-parallel with whatever else might be going on on the display. The
-only thing which will rush a flash to completion is another flash.
-
-The purpose of flashes is to indicate that the game has been
-completed. They were introduced as a separate concept from move
-animations because of Net: the habit of most Net players (and
-certainly me) is to rotate a tile into place and immediately lock
-it, then move on to another tile. When you make your last move, at
-the instant the final tile is rotated into place the screen starts
-to flash to indicate victory \dash but if you then press the lock
-button out of habit, then the move animation is cancelled, and the
-victory flash does not complete. (And if you \e{don't} press the
-lock button, the completed grid will look untidy because there will
-be one unlocked square.) Therefore, I introduced a specific concept
-of a \q{flash} which is separate from a move animation and can
-proceed in parallel with move animations and any other display
-activity, so that the victory flash in Net is not cancelled by that
-final locking move.
-
-The input parameters to \cw{flash_length()} are exactly the same as
-the ones to \cw{anim_length()}: see \k{backend-anim-length}.
-
-Just like \cw{anim_length()}, when this function is called, it may
-rely on \cw{changed_state()} having been called previously, so if it
-needs to refer to information in the \c{game_ui} then
-\cw{changed_state()} is a reliable place to have set that
-information up.
-
-(Some games use flashes to indicate defeat as well as victory;
-Mines, for example, flashes in a different colour when you tread on
-a mine from the colour it uses when you complete the game. In order
-to achieve this, its \cw{flash_length()} function has to store a
-flag in the \c{game_ui} to indicate which flash type is required.)
-
-\S{backend-get-cursor-location} \cw{get_cursor_location()}
-
-\c void (*get_cursor_location)(const game_ui *ui,
-\c                             const game_drawstate *ds,
-\c                             const game_state *state,
-\c                             const game_params *params,
-\c                             int *x, int *y,
-\c                             int *w, int *h);
-
-This function queries the backend for the rectangular region
-containing the cursor (in games that have one), or other region of
-interest.
-
-This function is called by only
-\cw{midend_get_cursor_location()} (\k{midend-get-cursor-location}). Its
-purpose is to allow front ends to query the location of the backend's
-cursor. With knowledge of this location, a front end can, for example,
-ensure that the region of interest remains visible if the puzzle is
-too big to fit on the screen at once.
-
-On returning, \cw{*x}, \cw{*y} should be set to the X and Y
-coordinates of the upper-left corner of the rectangular region of
-interest, and \cw{*w} and \cw{*h} should be the width and height of
-that region, respectively. In the event that a cursor is not visible
-on screen, this function should return and leave the return parameters
-untouched \dash the midend will notice this. The backend need not
-bother checking that \cw{x}, \cw{y}, \cw{w} and \cw{h} are
-non-\cw{NULL} \dash the midend guarantees that they will not be.
-
-Defining what constitutes a \q{region of interest} is left up to the
-backend. If a game provides a conventional cursor \dash such as Mines,
-Solo, or any of the other grid-based games \dash the most logical
-choice is of course the location of the cursor itself. However, in
-other cases such as Cube or Inertia, there is no \q{cursor} in the
-conventional sense \dash the player instead controls an object moving
-around the screen. In these cases, it makes sense to define the region
-of interest as the bounding box of the player object or another
-sensible region \dash such as the grid square the player is sitting on
-in Cube.
-
-If a backend does not provide a cursor mechanism at all, the backend
-is free to provide an empty implementation of this function, or a
-\cw{NULL} pointer in the \cw{game} structure \dash the midend will
-notice either of these cases and behave appropriately.
-
-\S{backend-status} \cw{status()}
-
-\c int (*status)(const game_state *state);
-
-This function returns a status value indicating whether the current
-game is still in play, or has been won, or has been conclusively lost.
-The mid-end uses this to implement \cw{midend_status()}
-(\k{midend-status}).
-
-The return value should be +1 if the game has been successfully
-solved. If the game has been lost in a situation where further play is
-unlikely, the return value should be -1. If neither is true (so play
-is still ongoing), return zero.
-
-Front ends may wish to use a non-zero status as a cue to proactively
-offer the option of starting a new game. Therefore, back ends should
-not return -1 if the game has been \e{technically} lost but undoing
-and continuing is still a realistic possibility.
-
-(For instance, games with hidden information such as Guess or Mines
-might well return a non-zero status whenever they reveal the solution,
-whether or not the player guessed it correctly, on the grounds that a
-player would be unlikely to hide the solution and continue playing
-after the answer was spoiled. On the other hand, games where you can
-merely get into a dead end such as Same Game or Inertia might choose
-to return 0 in that situation, on the grounds that the player would
-quite likely press Undo and carry on playing.)
-
-\S{backend-redraw} \cw{redraw()}
-
-\c void (*redraw)(drawing *dr, game_drawstate *ds,
-\c                const game_state *oldstate,
-\c                const game_state *newstate,
-\c                int dir, const game_ui *ui,
-\c                float anim_time, float flash_time);
-
-This function is responsible for actually drawing the contents of
-the game window, and for redrawing every time the game state or the
-\c{game_ui} changes.
-
-The parameter \c{dr} is a drawing object which may be passed to the
-drawing API functions (see \k{drawing} for documentation of the
-drawing API). This function may not save \c{dr} and use it
-elsewhere; it must only use it for calling back to the drawing API
-functions within its own lifetime.
-
-\c{ds} is the local \c{game_drawstate}, of course, and \c{ui} is the
-local \c{game_ui}.
-
-\c{newstate} is the semantically-current game state, and is always
-non-\cw{NULL}. If \c{oldstate} is also non-\cw{NULL}, it means that
-a move has recently been made and the game is still in the process
-of displaying an animation linking the old and new states; in this
-situation, \c{anim_time} will give the length of time (in seconds)
-that the animation has already been running. If \c{oldstate} is
-\cw{NULL}, then \c{anim_time} is unused (and will hopefully be set
-to zero to avoid confusion).
-
-\c{dir} specifies the chronological order of those states: if it is
-positive, then the transition is the result of a move or a redo (and
-so \c{newstate} is the later of the two moves), whereas if it is
-negative then the transition is the result of an undo (so that
-\c{newstate} is the \e{earlier} move). This allows move animations
-that are not time-symmetric (such as Inertia, where gems are consumed
-during the animation) to be drawn the right way round.
-
-\c{flash_time}, if it is is non-zero, denotes that the game is in
-the middle of a flash, and gives the time since the start of the
-flash. See \k{backend-flash-length} for general discussion of
-flashes.
-
-The very first time this function is called for a new
-\c{game_drawstate}, it is expected to redraw the \e{entire} drawing
-area. Since this often involves drawing visual furniture which is
-never subsequently altered, it is often simplest to arrange this by
-having a special \q{first time} flag in the draw state, and
-resetting it after the first redraw.  This function can assume that
-the mid-end has filled the drawing area with colour 0 before the first
-call.
-
-When this function (or any subfunction) calls the drawing API, it is
-expected to pass colour indices which were previously defined by the
-\cw{colours()} function.
-
-\H{backend-printing} Printing functions
-
-This section discusses the back end functions that deal with
-printing puzzles out on paper.
-
-\S{backend-can-print} \c{can_print}
-
-\c bool can_print;
-
-This flag is set to \cw{true} if the puzzle is capable of printing
-itself on paper. (This makes sense for some puzzles, such as Solo,
-which can be filled in with a pencil. Other puzzles, such as
-Twiddle, inherently involve moving things around and so would not
-make sense to print.)
-
-If this flag is \cw{false}, then the functions \cw{print_size()}
-and \cw{print()} will never be called and can be \cw{NULL}.
-
-\S{backend-can-print-in-colour} \c{can_print_in_colour}
-
-\c bool can_print_in_colour;
-
-This flag is set to \cw{true} if the puzzle is capable of printing
-itself differently when colour is available. For example, Map can
-actually print coloured regions in different \e{colours} rather than
-resorting to cross-hatching.
-
-If the \c{can_print} flag is \cw{false}, then this flag will be
-ignored.
-
-\S{backend-print-size} \cw{print_size()}
-
-\c void (*print_size)(const game_params *params, const game_ui *ui,
-\c                    float *x, float *y);
-
-This function is passed a \c{game_params} structure and a tile size.
-It returns, in \c{*x} and \c{*y}, the preferred size in
-\e{millimetres} of that puzzle if it were to be printed out on paper.
-
-If the \c{can_print} flag is \cw{false}, this function will never be
-called.
-
-\S{backend-print} \cw{print()}
-
-\c void (*print)(drawing *dr, const game_state *state,
-\c               const game_ui *ui, int tilesize);
-
-This function is called when a puzzle is to be printed out on paper.
-It should use the drawing API functions (see \k{drawing}) to print
-itself.
-
-This function is separate from \cw{redraw()} because it is often
-very different:
-
-\b The printing function may not depend on pixel accuracy, since
-printer resolution is variable. Draw as if your canvas had infinite
-resolution.
-
-\b The printing function sometimes needs to display things in a
-completely different style. Net, for example, is very different as
-an on-screen puzzle and as a printed one.
-
-\b The printing function is often much simpler since it has no need
-to deal with repeated partial redraws.
-
-However, there's no reason the printing and redraw functions can't
-share some code if they want to.
-
-When this function (or any subfunction) calls the drawing API, the
-colour indices it passes should be colours which have been allocated
-by the \cw{print_*_colour()} functions within this execution of
-\cw{print()}. This is very different from the fixed small number of
-colours used in \cw{redraw()}, because printers do not have a
-limitation on the total number of colours that may be used. Some
-puzzles' printing functions might wish to allocate only one \q{ink}
-colour and use it for all drawing; others might wish to allocate
-\e{more} colours than are used on screen.
-
-One possible colour policy worth mentioning specifically is that a
-puzzle's printing function might want to allocate the \e{same}
-colour indices as are used by the redraw function, so that code
-shared between drawing and printing does not have to keep switching
-its colour indices. In order to do this, the simplest thing is to
-make use of the fact that colour indices returned from
-\cw{print_*_colour()} are guaranteed to be in increasing order from
-zero. So if you have declared an \c{enum} defining three colours
-\cw{COL_BACKGROUND}, \cw{COL_THIS} and \cw{COL_THAT}, you might then
-write
-
-\c int c;
-\c c = print_mono_colour(dr, 1); assert(c == COL_BACKGROUND);
-\c c = print_mono_colour(dr, 0); assert(c == COL_THIS);
-\c c = print_mono_colour(dr, 0); assert(c == COL_THAT);
-
-If the \c{can_print} flag is \cw{false}, this function will never be
-called.
-
-\H{backend-misc} Miscellaneous
-
-\S{backend-can-format-as-text-ever} \c{can_format_as_text_ever}
-
-\c bool can_format_as_text_ever;
-
-This field is \cw{true} if the game supports formatting a
-game state as ASCII text (typically ASCII art) for copying to the
-clipboard and pasting into other applications. If it is \cw{false},
-front ends will not offer the \q{Copy} command at all.
-
-If this field is \cw{true}, the game does not necessarily have to
-support text formatting for \e{all} games: e.g. a game which can be
-played on a square grid or a triangular one might only support copy
-and paste for the former, because triangular grids in ASCII art are
-just too difficult.
-
-If this field is \cw{false}, the functions
-\cw{can_format_as_text_now()} (\k{backend-can-format-as-text-now})
-and \cw{text_format()} (\k{backend-text-format}) are never called
-and can be \cw{NULL}.
-
-\S{backend-can-format-as-text-now} \c{can_format_as_text_now()}
-
-\c bool (*can_format_as_text_now)(const game_params *params);
-
-This function is passed a \c{game_params}, and returns \cw{true} if
-the game can support ASCII text output for this particular game type.
-If it returns \cw{false}, front ends will grey out or otherwise
-disable the \q{Copy} command.
-
-Games may enable and disable the copy-and-paste function for
-different game \e{parameters}, but are currently constrained to
-return the same answer from this function for all game \e{states}
-sharing the same parameters. In other words, the \q{Copy} function
-may enable or disable itself when the player changes game preset,
-but will never change during play of a single game or when another
-game of exactly the same type is generated.
-
-This function should not take into account aspects of the game
-parameters which are not encoded by \cw{encode_params()}
-(\k{backend-encode-params}) when the \c{full} parameter is set to
-\cw{false}. Such parameters will not necessarily match up between a
-call to this function and a subsequent call to \cw{text_format()}
-itself. (For instance, game \e{difficulty} should not affect whether
-the game can be copied to the clipboard. Only the actual visible
-\e{shape} of the game can affect that.)
-
-\S{backend-text-format} \cw{text_format()}
-
-\c char *(*text_format)(const game_state *state);
-
-This function is passed a \c{game_state}, and returns a newly
-allocated C string containing an ASCII representation of that game
-state. It is used to implement the \q{Copy} operation in many front
-ends.
-
-This function will only ever be called if the back end field
-\c{can_format_as_text_ever} (\k{backend-can-format-as-text-ever}) is
-\cw{true} \e{and} the function \cw{can_format_as_text_now()}
-(\k{backend-can-format-as-text-now}) has returned \cw{true} for the
-currently selected game parameters.
-
-The returned string may contain line endings (and will probably want
-to), using the normal C internal \cq{\\n} convention. For
-consistency between puzzles, all multi-line textual puzzle
-representations should \e{end} with a newline as well as containing
-them internally. (There are currently no puzzles which have a
-one-line ASCII representation, so there's no precedent yet for
-whether that should come with a newline or not.)
-
-\S{backend-wants-statusbar} \cw{wants_statusbar}
-
-\c bool wants_statusbar;
-
-This field is set to \cw{true} if the puzzle has a use for a textual
-status line (to display score, completion status, currently active
-tiles, etc). If the \c{redraw()} function ever intends to call
-\c{status_bar()} in the drawing API (\k{drawing-status-bar}), then it
-should set this flag to \c{true}.
-
-\S{backend-is-timed} \c{is_timed}
-
-\c bool is_timed;
-
-This field is \cw{true} if the puzzle is time-critical. If
-so, the mid-end will maintain a game timer while the user plays.
-
-If this field is \cw{false}, then \cw{timing_state()} will never be
-called and can be \cw{NULL}.
-
-\S{backend-timing-state} \cw{timing_state()}
-
-\c bool (*timing_state)(const game_state *state, game_ui *ui);
-
-This function is passed the current \c{game_state} and the local
-\c{game_ui}; it returns \cw{true} if the game timer should currently
-be running.
-
-A typical use for the \c{game_ui} in this function is to note when
-the game was first completed (by setting a flag in
-\cw{changed_state()} \dash see \k{backend-changed-state}), and
-freeze the timer thereafter so that the user can undo back through
-their solution process without altering their time.
-
-\S{backend-request-keys} \cw{request_keys()}
-
-\c key_label *(*request_keys)(const game_params *params, int *nkeys);
-
-This function returns a dynamically allocated array of \cw{key_label}
-items containing the buttons the back end deems absolutely
-\e{necessary} for gameplay, not an exhaustive list of every button the
-back end could accept. For example, Keen only returns the digits up to
-the game size and the backspace character, \cw{\\b}, even though it
-\e{could} accept \cw{M}, as only these buttons are actually needed to
-play the game. Each \cw{key_label} item contains the following fields:
-
-\c struct key_label {
-\c     char *label; /* label for frontend use */
-\c     int button; /* button to pass to midend */
-\c } key_label;
-
-The \cw{label} field of this structure can (and often will) be set by
-the backend to \cw{NULL}, in which case the midend will instead call
-\c{button2label()} (\k{utils-button2label}) and fill in a generic
-label. The \cw{button} field is the associated code that can be passed
-to the midend when the frontend deems appropriate.
-
-If \cw{label} is not \cw{NULL}, then it's a dynamically allocated
-string. Therefore, freeing an array of these structures needs more
-than just a single free operatio. The function \c{free_keys()}
-(\k{utils-free-keys}) can be used to free a whole array of these
-structures conveniently.
-
-The backend should set \cw{*nkeys} to the number of elements in the
-returned array.
-
-The field for this function pointer in the \cw{game} structure might
-be set to \cw{NULL} (and indeed it is for the majority of the games)
-to indicate that no additional buttons (apart from the cursor keys)
-are required to play the game.
-
-This function should not be called directly by frontends. Instead,
-frontends should use \cw{midend_request_keys()}
-(\k{midend-request-keys}).
-
-\S{backend-current-key-label} \cw{current_key_label()}
-
-\c const char *(*current_key_label)(const game_ui *ui,
-\c                                  const game_state *state,
-\c                                  int button);
-
-This function is called to ask the back-end how certain keys should be
-labelled on platforms (such a feature phones) where this is
-conventional.
-These labels are expected to reflect what the keys will do right now,
-so they can change depending on the game and UI state.
-
-The \c{ui} and \c{state} arguments describe the state of the game for
-which key labels are required.
-The \c{button} argument is the same as the one passed to
-\cw{interpret_move()}.
-At present, the only values of \c{button} that can be passed to
-\cw{current_key_label()} are \cw{CURSOR_SELECT} and \cw{CURSOR_SELECT2}.
-The return value is a short string describing what the requested key
-will do if pressed.
-Usually the string should be a static string constant.
-If it's really necessary to use a dynamically-allocated string, it
-should remain valid until the next call to \cw{current_key_label()} or
-\cw{free_ui()} with the same \cw{game_ui} (so it can be referenced from
-the \cw{game_ui} and freed at the next one of those calls).
-
-There's no fixed upper limit on the length of string that this
-function can return, but more than about 12 characters is likely to
-cause problems for front-ends.  If two buttons have the same effect,
-their labels should be identical so that the front end can detect
-this.  Similarly, keys that do different things should have different
-labels.  The label should be an empty string (\cw{""}) if the key does
-nothing.
-
-Like \cw{request_keys()}, the \cw{current_key_label} pointer in the
-\c{game} structure is allowed to be \cw{NULL}, in which case the
-mid-end will treat it as though it always returned \cw{""}.
-
-\S{backend-flags} \c{flags}
-
-\c int flags;
-
-This field contains miscellaneous per-backend flags. It consists of
-the bitwise OR of some combination of the following:
-
-\dt \cw{BUTTON_BEATS(x,y)}
-
-\dd Given any \cw{x} and \cw{y} from the set \{\cw{LEFT_BUTTON},
-\cw{MIDDLE_BUTTON}, \cw{RIGHT_BUTTON}\}, this macro evaluates to a
-bit flag which indicates that when buttons \cw{x} and \cw{y} are
-both pressed simultaneously, the mid-end should consider \cw{x} to
-have priority. (In the absence of any such flags, the mid-end will
-always consider the most recently pressed button to have priority.)
-
-\dt \cw{SOLVE_ANIMATES}
-
-\dd This flag indicates that moves generated by \cw{solve()}
-(\k{backend-solve}) are candidates for animation just like any other
-move. For most games, solve moves should not be animated, so the
-mid-end doesn't even bother calling \cw{anim_length()}
-(\k{backend-anim-length}), thus saving some special-case code in
-each game. On the rare occasion that animated solve moves are
-actually required, you can set this flag.
-
-\dt \cw{REQUIRE_RBUTTON}
-
-\dd This flag indicates that the puzzle cannot be usefully played
-without the use of mouse buttons other than the left one. On some
-PDA platforms, this flag is used by the front end to enable
-right-button emulation through an appropriate gesture. Note that a
-puzzle is not required to set this just because it \e{uses} the
-right button, but only if its use of the right button is critical to
-playing the game. (Slant, for example, uses the right button to
-cycle through the three square states in the opposite order from the
-left button, and hence can manage fine without it.)
-
-\dt \cw{REQUIRE_NUMPAD}
-
-\dd This flag indicates that the puzzle cannot be usefully played
-without the use of number-key input. On some PDA platforms it causes
-an emulated number pad to appear on the screen. Similarly to
-\cw{REQUIRE_RBUTTON}, a puzzle need not specify this simply if its
-use of the number keys is not critical.
-
-\H{backend-initiative} Things a back end may do on its own initiative
-
-This section describes a couple of things that a back end may choose
-to do by calling functions elsewhere in the program, which would not
-otherwise be obvious.
-
-\S{backend-newrs} Create a random state
-
-If a back end needs random numbers at some point during normal play,
-it can create a fresh \c{random_state} by first calling
-\c{get_random_seed} (\k{frontend-get-random-seed}) and then passing
-the returned seed data to \cw{random_new()}.
-
-This is likely not to be what you want. If a puzzle needs randomness
-in the middle of play, it's likely to be more sensible to store some
-sort of random state within the \c{game_state}, so that the random
-numbers are tied to the particular game state and hence the player
-can't simply keep undoing their move until they get numbers they
-like better.
-
-This facility is currently used only in Net, to implement the
-\q{jumble} command, which sets every unlocked tile to a new random
-orientation. This randomness \e{is} a reasonable use of the feature,
-because it's non-adversarial \dash there's no advantage to the user
-in getting different random numbers.
-
-\S{backend-supersede} Supersede its own game description
-
-In response to a move, a back end is (reluctantly) permitted to call
-\cw{midend_supersede_game_desc()}:
-
-\c void midend_supersede_game_desc(midend *me,
-\c                                 char *desc, char *privdesc);
-
-When the user selects \q{New Game}, the mid-end calls
-\cw{new_desc()} (\k{backend-new-desc}) to get a new game
-description, and (as well as using that to generate an initial game
-state) stores it for the save file and for telling to the user. The
-function above overwrites that game description, and also splits it
-in two. \c{desc} becomes the new game description which is provided
-to the user on request, and is also the one used to construct a new
-initial game state if the user selects \q{Restart}. \c{privdesc} is
-a \q{private} game description, used to reconstruct the game's
-initial state when reloading.
-
-The distinction between the two, as well as the need for this
-function at all, comes from Mines. Mines begins with a blank grid
-and no idea of where the mines actually are; \cw{new_desc()} does
-almost no work in interactive mode, and simply returns a string
-encoding the \c{random_state}. When the user first clicks to open a
-tile, \e{then} Mines generates the mine positions, in such a way
-that the game is soluble from that starting point. Then it uses this
-function to supersede the random-state game description with a
-proper one. But it needs two: one containing the initial click
-location (because that's what you want to happen if you restart the
-game, and also what you want to send to a friend so that they play
-\e{the same game} as you), and one without the initial click
-location (because when you save and reload the game, you expect to
-see the same blank initial state as you had before saving).
-
-I should stress again that this function is a horrid hack. Nobody
-should use it if they're not Mines; if you think you need to use it,
-think again repeatedly in the hope of finding a better way to do
-whatever it was you needed to do.
-
-\C{drawing} The drawing API
-
-The back end function \cw{redraw()} (\k{backend-redraw}) is required
-to draw the puzzle's graphics on the window's drawing area. The back
-end function \cw{print()} similarly draws the puzzle on paper, if the
-puzzle is printable. To do this portably, the back end is provided
-with a drawing API allowing it to talk directly to the front end. In
-this chapter I document that API, both for the benefit of back end
-authors trying to use it and for front end authors trying to implement
-it.
-
-The drawing API as seen by the back end is a collection of global
-functions, each of which takes a pointer to a \c{drawing} structure
-(a \q{drawing object}). These objects are supplied as parameters to
-the back end's \cw{redraw()} and \cw{print()} functions.
-
-In fact these global functions are not implemented directly by the
-front end; instead, they are implemented centrally in \c{drawing.c}
-and form a small piece of middleware. The drawing API as supplied by
-the front end is a structure containing a set of function pointers,
-plus a \cq{void *} handle which is passed to each of those
-functions. This enables a single front end to switch between
-multiple implementations of the drawing API if necessary. For
-example, the Windows API supplies a printing mechanism integrated
-into the same GDI which deals with drawing in windows, and therefore
-the same API implementation can handle both drawing and printing;
-but on Unix, the most common way for applications to print is by
-producing PostScript output directly, and although it would be
-\e{possible} to write a single (say) \cw{draw_rect()} function which
-checked a global flag to decide whether to do GTK drawing operations
-or output PostScript to a file, it's much nicer to have two separate
-functions and switch between them as appropriate.
-
-When drawing, the puzzle window is indexed by pixel coordinates,
-with the top left pixel defined as \cw{(0,0)} and the bottom right
-pixel \cw{(w-1,h-1)}, where \c{w} and \c{h} are the width and height
-values returned by the back end function \cw{compute_size()}
-(\k{backend-compute-size}).
-
-When printing, the puzzle's print area is indexed in exactly the
-same way (with an arbitrary tile size provided by the printing
-module \c{printing.c}), to facilitate sharing of code between the
-drawing and printing routines. However, when printing, puzzles may
-no longer assume that the coordinate unit has any relationship to a
-pixel; the printer's actual resolution might very well not even be
-known at print time, so the coordinate unit might be smaller or
-larger than a pixel. Puzzles' print functions should restrict
-themselves to drawing geometric shapes rather than fiddly pixel
-manipulation.
-
-\e{Puzzles' redraw functions may assume that the surface they draw
-on is persistent}. It is the responsibility of every front end to
-preserve the puzzle's window contents in the face of GUI window
-expose issues and similar. It is not permissible to request that the
-back end redraw any part of a window that it has already drawn,
-unless something has actually changed as a result of making moves in
-the puzzle.
-
-Most front ends accomplish this by having the drawing routines draw
-on a stored bitmap rather than directly on the window, and copying
-the bitmap to the window every time a part of the window needs to be
-redrawn. Therefore, it is vitally important that whenever the back
-end does any drawing it informs the front end of which parts of the
-window it has accessed, and hence which parts need repainting. This
-is done by calling \cw{draw_update()} (\k{drawing-draw-update}).
-
-Persistence of old drawing is convenient. However, a puzzle should
-be very careful about how it updates its drawing area. The problem
-is that some front ends do anti-aliased drawing: rather than simply
-choosing between leaving each pixel untouched or painting it a
-specified colour, an antialiased drawing function will \e{blend} the
-original and new colours in pixels at a figure's boundary according
-to the proportion of the pixel occupied by the figure (probably
-modified by some heuristic fudge factors). All of this produces a
-smoother appearance for curves and diagonal lines.
-
-An unfortunate effect of drawing an anti-aliased figure repeatedly
-is that the pixels around the figure's boundary come steadily more
-saturated with \q{ink} and the boundary appears to \q{spread out}.
-Worse, redrawing a figure in a different colour won't fully paint
-over the old boundary pixels, so the end result is a rather ugly
-smudge.
-
-A good strategy to avoid unpleasant anti-aliasing artifacts is to
-identify a number of rectangular areas which need to be redrawn,
-clear them to the background colour, and then redraw their contents
-from scratch, being careful all the while not to stray beyond the
-boundaries of the original rectangles. The \cw{clip()} function
-(\k{drawing-clip}) comes in very handy here. Games based on a square
-grid can often do this fairly easily. Other games may need to be
-somewhat more careful. For example, Loopy's redraw function first
-identifies portions of the display which need to be updated. Then,
-if the changes are fairly well localised, it clears and redraws a
-rectangle containing each changed area. Otherwise, it gives up and
-redraws the entire grid from scratch.
-
-It is possible to avoid clearing to background and redrawing from
-scratch if one is very careful about which drawing functions one
-uses: if a function is documented as not anti-aliasing under some
-circumstances, you can rely on each pixel in a drawing either being
-left entirely alone or being set to the requested colour, with no
-blending being performed.
-
-In the following sections I first discuss the drawing API as seen by
-the back end, and then the \e{almost} identical function-pointer
-form seen by the front end.
-
-\H{drawing-backend} Drawing API as seen by the back end
-
-This section documents the back-end drawing API, in the form of
-functions which take a \c{drawing} object as an argument.
-
-\S{drawing-draw-rect} \cw{draw_rect()}
-
-\c void draw_rect(drawing *dr, int x, int y, int w, int h,
-\c                int colour);
-
-Draws a filled rectangle in the puzzle window.
-
-\c{x} and \c{y} give the coordinates of the top left pixel of the
-rectangle. \c{w} and \c{h} give its width and height. Thus, the
-horizontal extent of the rectangle runs from \c{x} to \c{x+w-1}
-inclusive, and the vertical extent from \c{y} to \c{y+h-1}
-inclusive.
-
-\c{colour} is an integer index into the colours array returned by
-the back end function \cw{colours()} (\k{backend-colours}).
-
-There is no separate pixel-plotting function. If you want to plot a
-single pixel, the approved method is to use \cw{draw_rect()} with
-width and height set to 1.
-
-Unlike many of the other drawing functions, this function is
-guaranteed to be pixel-perfect: the rectangle will be sharply
-defined and not anti-aliased or anything like that.
-
-This function may be used for both drawing and printing.
-
-\S{drawing-draw-rect-outline} \cw{draw_rect_outline()}
-
-\c void draw_rect_outline(drawing *dr, int x, int y, int w, int h,
-\c                        int colour);
-
-Draws an outline rectangle in the puzzle window.
-
-\c{x} and \c{y} give the coordinates of the top left pixel of the
-rectangle. \c{w} and \c{h} give its width and height. Thus, the
-horizontal extent of the rectangle runs from \c{x} to \c{x+w-1}
-inclusive, and the vertical extent from \c{y} to \c{y+h-1}
-inclusive.
-
-\c{colour} is an integer index into the colours array returned by
-the back end function \cw{colours()} (\k{backend-colours}).
-
-From a back end perspective, this function may be considered to be
-part of the drawing API. However, front ends are not required to
-implement it, since it is actually implemented centrally (in
-\cw{misc.c}) as a wrapper on \cw{draw_polygon()}.
-
-This function may be used for both drawing and printing.
-
-\S{drawing-draw-rect-corner} \cw{draw_rect_corners()}
-
-\c void draw_rect_corners(drawing *dr, int cx, int cy, int r, int col);
-
-Draws four L-shapes at the corners of a square, in the manner of a
-target reticule. This is a convenience function for back ends to use
-to display a keyboard cursor (if they want one in that style).
-
-\c{cx} and \c{cy} give the coordinates of the centre of the square.
-\c{r} is half the side length of the square, so that the corners are
-at \cw{(cx-r,cy-r)}, \cw{(cx+r,cy-r)}, \cw{(cx-r,cy+r)} and
-\cw{(cx+r,cy+r)}.
-
-\c{colour} is an integer index into the colours array returned by
-the back end function \cw{colours()} (\k{backend-colours}).
-
-\S{drawing-draw-line} \cw{draw_line()}
-
-\c void draw_line(drawing *dr, int x1, int y1, int x2, int y2,
-\c                int colour);
-
-Draws a straight line in the puzzle window.
-
-\c{x1} and \c{y1} give the coordinates of one end of the line.
-\c{x2} and \c{y2} give the coordinates of the other end. The line
-drawn includes both those points.
-
-\c{colour} is an integer index into the colours array returned by
-the back end function \cw{colours()} (\k{backend-colours}).
-
-Some platforms may perform anti-aliasing on this function.
-Therefore, do not assume that you can erase a line by drawing the
-same line over it in the background colour; anti-aliasing might lead
-to perceptible ghost artefacts around the vanished line. Horizontal
-and vertical lines, however, are pixel-perfect and not anti-aliased.
-
-This function may be used for both drawing and printing.
-
-\S{drawing-draw-polygon} \cw{draw_polygon()}
-
-\c void draw_polygon(drawing *dr, const int *coords, int npoints,
-\c                   int fillcolour, int outlinecolour);
-
-Draws an outlined or filled polygon in the puzzle window.
-
-\c{coords} is an array of \cw{(2*npoints)} integers, containing the
-\c{x} and \c{y} coordinates of \c{npoints} vertices.
-
-\c{fillcolour} and \c{outlinecolour} are integer indices into the
-colours array returned by the back end function \cw{colours()}
-(\k{backend-colours}). \c{fillcolour} may also be \cw{-1} to
-indicate that the polygon should be outlined only.
-
-The polygon defined by the specified list of vertices is first
-filled in \c{fillcolour}, if specified, and then outlined in
-\c{outlinecolour}.
-
-\c{outlinecolour} may \e{not} be \cw{-1}; it must be a valid colour
-(and front ends are permitted to enforce this by assertion). This is
-because different platforms disagree on whether a filled polygon
-should include its boundary line or not, so drawing \e{only} a
-filled polygon would have non-portable effects. If you want your
-filled polygon not to have a visible outline, you must set
-\c{outlinecolour} to the same as \c{fillcolour}.
-
-Some platforms may perform anti-aliasing on this function.
-Therefore, do not assume that you can erase a polygon by drawing the
-same polygon over it in the background colour. Also, be prepared for
-the polygon to extend a pixel beyond its obvious bounding box as a
-result of this; if you really need it not to do this to avoid
-interfering with other delicate graphics, you should probably use
-\cw{clip()} (\k{drawing-clip}). You can rely on horizontal and
-vertical lines not being anti-aliased.
-
-This function may be used for both drawing and printing.
-
-\S{drawing-draw-circle} \cw{draw_circle()}
-
-\c void draw_circle(drawing *dr, int cx, int cy, int radius,
-\c                  int fillcolour, int outlinecolour);
-
-Draws an outlined or filled circle in the puzzle window.
-
-\c{cx} and \c{cy} give the coordinates of the centre of the circle.
-\c{radius} gives its radius. The total horizontal pixel extent of
-the circle is from \c{cx-radius+1} to \c{cx+radius-1} inclusive, and
-the vertical extent similarly around \c{cy}.
-
-\c{fillcolour} and \c{outlinecolour} are integer indices into the
-colours array returned by the back end function \cw{colours()}
-(\k{backend-colours}). \c{fillcolour} may also be \cw{-1} to
-indicate that the circle should be outlined only.
-
-The circle is first filled in \c{fillcolour}, if specified, and then
-outlined in \c{outlinecolour}.
-
-\c{outlinecolour} may \e{not} be \cw{-1}; it must be a valid colour
-(and front ends are permitted to enforce this by assertion). This is
-because different platforms disagree on whether a filled circle
-should include its boundary line or not, so drawing \e{only} a
-filled circle would have non-portable effects. If you want your
-filled circle not to have a visible outline, you must set
-\c{outlinecolour} to the same as \c{fillcolour}.
-
-Some platforms may perform anti-aliasing on this function.
-Therefore, do not assume that you can erase a circle by drawing the
-same circle over it in the background colour. Also, be prepared for
-the circle to extend a pixel beyond its obvious bounding box as a
-result of this; if you really need it not to do this to avoid
-interfering with other delicate graphics, you should probably use
-\cw{clip()} (\k{drawing-clip}).
-
-This function may be used for both drawing and printing.
-
-\S{drawing-draw-thick-line} \cw{draw_thick_line()}
-
-\c void draw_thick_line(drawing *dr, float thickness,
-\c                      float x1, float y1, float x2, float y2,
-\c                      int colour)
-
-Draws a line in the puzzle window, giving control over the line's
-thickness.
-
-\c{x1} and \c{y1} give the coordinates of one end of the line.
-\c{x2} and \c{y2} give the coordinates of the other end.
-\c{thickness} gives the thickness of the line, in pixels.
-
-Note that the coordinates and thickness are floating-point: the
-continuous coordinate system is in effect here. It's important to
-be able to address points with better-than-pixel precision in this
-case, because one can't otherwise properly express the endpoints of
-lines with both odd and even thicknesses.
-
-Some platforms may perform anti-aliasing on this function. The
-precise pixels affected by a thick-line drawing operation may vary
-between platforms, and no particular guarantees are provided.
-Indeed, even horizontal or vertical lines may be anti-aliased.
-
-This function may be used for both drawing and printing.
-
-If the specified thickness is less than 1.0, 1.0 is used.
-This ensures that thin lines are visible even at small scales.
-
-\S{drawing-draw-text} \cw{draw_text()}
-
-\c void draw_text(drawing *dr, int x, int y, int fonttype,
-\c                int fontsize, int align, int colour,
-\c                const char *text);
-
-Draws text in the puzzle window.
-
-\c{x} and \c{y} give the coordinates of a point. The relation of
-this point to the location of the text is specified by \c{align},
-which is a bitwise OR of horizontal and vertical alignment flags:
-
-\dt \cw{ALIGN_VNORMAL}
-
-\dd Indicates that \c{y} is aligned with the baseline of the text.
-
-\dt \cw{ALIGN_VCENTRE}
-
-\dd Indicates that \c{y} is aligned with the vertical centre of the
-text. (In fact, it's aligned with the vertical centre of normal
-\e{capitalised} text: displaying two pieces of text with
-\cw{ALIGN_VCENTRE} at the same \cw{y}-coordinate will cause their
-baselines to be aligned with one another, even if one is an ascender
-and the other a descender.)
-
-\dt \cw{ALIGN_HLEFT}
-
-\dd Indicates that \c{x} is aligned with the left-hand end of the
-text.
-
-\dt \cw{ALIGN_HCENTRE}
-
-\dd Indicates that \c{x} is aligned with the horizontal centre of
-the text.
-
-\dt \cw{ALIGN_HRIGHT}
-
-\dd Indicates that \c{x} is aligned with the right-hand end of the
-text.
-
-\c{fonttype} is either \cw{FONT_FIXED} or \cw{FONT_VARIABLE}, for a
-monospaced or proportional font respectively. (No more detail than
-that may be specified; it would only lead to portability issues
-between different platforms.)
-
-\c{fontsize} is the desired size, in pixels, of the text. This size
-corresponds to the overall point size of the text, not to any
-internal dimension such as the cap-height.
-
-\c{colour} is an integer index into the colours array returned by
-the back end function \cw{colours()} (\k{backend-colours}).
-
-This function may be used for both drawing and printing.
-
-The character set used to encode the text passed to this function is
-specified \e{by the drawing object}, although it must be a superset
-of ASCII. If a puzzle wants to display text that is not contained in
-ASCII, it should use the \cw{text_fallback()} function
-(\k{drawing-text-fallback}) to query the drawing object for an
-appropriate representation of the characters it wants.
-
-\S{drawing-text-fallback} \cw{text_fallback()}
-
-\c char *text_fallback(drawing *dr, const char *const *strings,
-\c                     int nstrings);
-
-This function is used to request a translation of UTF-8 text into
-whatever character encoding is expected by the drawing object's
-implementation of \cw{draw_text()}.
-
-The input is a list of strings encoded in UTF-8: \cw{nstrings} gives
-the number of strings in the list, and \cw{strings[0]},
-\cw{strings[1]}, ..., \cw{strings[nstrings-1]} are the strings
-themselves.
-
-The returned string (which is dynamically allocated and must be
-freed when finished with) is derived from the first string in the
-list that the drawing object expects to be able to display reliably;
-it will consist of that string translated into the character set
-expected by \cw{draw_text()}.
-
-Drawing implementations are not required to handle anything outside
-ASCII, but are permitted to assume that \e{some} string will be
-successfully translated. So every call to this function must include
-a string somewhere in the list (presumably the last element) which
-consists of nothing but ASCII, to be used by any front end which
-cannot handle anything else.
-
-For example, if a puzzle wished to display a string including a
-multiplication sign (U+00D7 in Unicode, represented by the bytes C3
-97 in UTF-8), it might do something like this:
-
-\c static const char *const times_signs[] = { "\xC3\x97", "x" };
-\c char *times_sign = text_fallback(dr, times_signs, 2);
-\c sprintf(buffer, "%d%s%d", width, times_sign, height);
-\c sfree(times_sign);
-\c draw_text(dr, x, y, font, size, align, colour, buffer);
-\c sfree(buffer);
-
-which would draw a string with a times sign in the middle on
-platforms that support it, and fall back to a simple ASCII \cq{x}
-where there was no alternative.
-
-\S{drawing-clip} \cw{clip()}
-
-\c void clip(drawing *dr, int x, int y, int w, int h);
-
-Establishes a clipping rectangle in the puzzle window.
-
-\c{x} and \c{y} give the coordinates of the top left pixel of the
-clipping rectangle. \c{w} and \c{h} give its width and height. Thus,
-the horizontal extent of the rectangle runs from \c{x} to \c{x+w-1}
-inclusive, and the vertical extent from \c{y} to \c{y+h-1}
-inclusive. (These are exactly the same semantics as
-\cw{draw_rect()}.)
-
-After this call, no drawing operation will affect anything outside
-the specified rectangle. The effect can be reversed by calling
-\cw{unclip()} (\k{drawing-unclip}). The clipping rectangle is
-pixel-perfect: pixels within the rectangle are affected as usual by
-drawing functions; pixels outside are completely untouched.
-
-Back ends should not assume that a clipping rectangle will be
-automatically cleared up by the front end if it's left lying around;
-that might work on current front ends, but shouldn't be relied upon.
-Always explicitly call \cw{unclip()}.
-
-This function may be used for both drawing and printing.
-
-\S{drawing-unclip} \cw{unclip()}
-
-\c void unclip(drawing *dr);
-
-Reverts the effect of a previous call to \cw{clip()}. After this
-call, all drawing operations will be able to affect the entire
-puzzle window again.
-
-This function may be used for both drawing and printing.
-
-\S{drawing-draw-update} \cw{draw_update()}
-
-\c void draw_update(drawing *dr, int x, int y, int w, int h);
-
-Informs the front end that a rectangular portion of the puzzle
-window has been drawn on and needs to be updated.
-
-\c{x} and \c{y} give the coordinates of the top left pixel of the
-update rectangle. \c{w} and \c{h} give its width and height. Thus,
-the horizontal extent of the rectangle runs from \c{x} to \c{x+w-1}
-inclusive, and the vertical extent from \c{y} to \c{y+h-1}
-inclusive. (These are exactly the same semantics as
-\cw{draw_rect()}.)
-
-The back end redraw function \e{must} call this function to report
-any changes it has made to the window. Otherwise, those changes may
-not become immediately visible, and may then appear at an
-unpredictable subsequent time such as the next time the window is
-covered and re-exposed.
-
-This function is only important when drawing. It may be called when
-printing as well, but doing so is not compulsory, and has no effect.
-(So if you have a shared piece of code between the drawing and
-printing routines, that code may safely call \cw{draw_update()}.)
-
-\S{drawing-status-bar} \cw{status_bar()}
-
-\c void status_bar(drawing *dr, const char *text);
-
-Sets the text in the game's status bar to \c{text}. The text is copied
-from the supplied buffer, so the caller is free to deallocate or
-modify the buffer after use.
-
-(This function is not exactly a \e{drawing} function, but it shares
-with the drawing API the property that it may only be called from
-within the back end redraw function. And it's implemented by front
-ends via the \c{drawing_api} function pointer table. So this is the
-best place to document it.)
-
-The supplied text is filtered through the mid-end for optional
-rewriting before being passed on to the front end; the mid-end will
-prepend the current game time if the game is timed (and may in
-future perform other rewriting if it seems like a good idea).
-
-This function is for drawing only; it must never be called during
-printing.
-
-\S{drawing-blitter} Blitter functions
-
-This section describes a group of related functions which save and
-restore a section of the puzzle window. This is most commonly used
-to implement user interfaces involving dragging a puzzle element
-around the window: at the end of each call to \cw{redraw()}, if an
-object is currently being dragged, the back end saves the window
-contents under that location and then draws the dragged object, and
-at the start of the next \cw{redraw()} the first thing it does is to
-restore the background.
-
-The front end defines an opaque type called a \c{blitter}, which is
-capable of storing a rectangular area of a specified size.
-
-Blitter functions are for drawing only; they must never be called
-during printing.
-
-\S2{drawing-blitter-new} \cw{blitter_new()}
-
-\c blitter *blitter_new(drawing *dr, int w, int h);
-
-Creates a new blitter object which stores a rectangle of size \c{w}
-by \c{h} pixels. Returns a pointer to the blitter object.
-
-Blitter objects are best stored in the \c{game_drawstate}. A good
-time to create them is in the \cw{set_size()} function
-(\k{backend-set-size}), since it is at this point that you first
-know how big a rectangle they will need to save.
-
-\S2{drawing-blitter-free} \cw{blitter_free()}
-
-\c void blitter_free(drawing *dr, blitter *bl);
-
-Disposes of a blitter object. Best called in \cw{free_drawstate()}.
-(However, check that the blitter object is not \cw{NULL} before
-attempting to free it; it is possible that a draw state might be
-created and freed without ever having \cw{set_size()} called on it
-in between.)
-
-\S2{drawing-blitter-save} \cw{blitter_save()}
-
-\c void blitter_save(drawing *dr, blitter *bl, int x, int y);
-
-This is a true drawing API function, in that it may only be called
-from within the game redraw routine. It saves a rectangular portion
-of the puzzle window into the specified blitter object.
-
-\c{x} and \c{y} give the coordinates of the top left corner of the
-saved rectangle. The rectangle's width and height are the ones
-specified when the blitter object was created.
-
-This function is required to cope and do the right thing if \c{x}
-and \c{y} are out of range. (The right thing probably means saving
-whatever part of the blitter rectangle overlaps with the visible
-area of the puzzle window.)
-
-\S2{drawing-blitter-load} \cw{blitter_load()}
-
-\c void blitter_load(drawing *dr, blitter *bl, int x, int y);
-
-This is a true drawing API function, in that it may only be called
-from within the game redraw routine. It restores a rectangular
-portion of the puzzle window from the specified blitter object.
-
-\c{x} and \c{y} give the coordinates of the top left corner of the
-rectangle to be restored. The rectangle's width and height are the
-ones specified when the blitter object was created.
-
-Alternatively, you can specify both \c{x} and \c{y} as the special
-value \cw{BLITTER_FROMSAVED}, in which case the rectangle will be
-restored to exactly where it was saved from. (This is probably what
-you want to do almost all the time, if you're using blitters to
-implement draggable puzzle elements.)
-
-This function is required to cope and do the right thing if \c{x}
-and \c{y} (or the equivalent ones saved in the blitter) are out of
-range. (The right thing probably means restoring whatever part of
-the blitter rectangle overlaps with the visible area of the puzzle
-window.)
-
-If this function is called on a blitter which had previously been
-saved from a partially out-of-range rectangle, then the parts of the
-saved bitmap which were not visible at save time are undefined. If
-the blitter is restored to a different position so as to make those
-parts visible, the effect on the drawing area is undefined.
-
-\S{print-mono-colour} \cw{print_mono_colour()}
-
-\c int print_mono_colour(drawing *dr, int grey);
-
-This function allocates a colour index for a simple monochrome
-colour during printing.
-
-\c{grey} must be 0 or 1. If \c{grey} is 0, the colour returned is
-black; if \c{grey} is 1, the colour is white.
-
-\S{print-grey-colour} \cw{print_grey_colour()}
-
-\c int print_grey_colour(drawing *dr, float grey);
-
-This function allocates a colour index for a grey-scale colour
-during printing.
-
-\c{grey} may be any number between 0 (black) and 1 (white); for
-example, 0.5 indicates a medium grey.
-
-The chosen colour will be rendered to the limits of the printer's
-halftoning capability.
-
-\S{print-hatched-colour} \cw{print_hatched_colour()}
-
-\c int print_hatched_colour(drawing *dr, int hatch);
-
-This function allocates a colour index which does not represent a
-literal \e{colour}. Instead, regions shaded in this colour will be
-hatched with parallel lines. The \c{hatch} parameter defines what
-type of hatching should be used in place of this colour:
-
-\dt \cw{HATCH_SLASH}
-
-\dd This colour will be hatched by lines slanting to the right at 45
-degrees. 
-
-\dt \cw{HATCH_BACKSLASH}
-
-\dd This colour will be hatched by lines slanting to the left at 45
-degrees.
-
-\dt \cw{HATCH_HORIZ}
-
-\dd This colour will be hatched by horizontal lines.
-
-\dt \cw{HATCH_VERT}
-
-\dd This colour will be hatched by vertical lines.
-
-\dt \cw{HATCH_PLUS}
-
-\dd This colour will be hatched by criss-crossing horizontal and
-vertical lines.
-
-\dt \cw{HATCH_X}
-
-\dd This colour will be hatched by criss-crossing diagonal lines.
-
-Colours defined to use hatching may not be used for drawing lines or
-text; they may only be used for filling areas. That is, they may be
-used as the \c{fillcolour} parameter to \cw{draw_circle()} and
-\cw{draw_polygon()}, and as the colour parameter to
-\cw{draw_rect()}, but may not be used as the \c{outlinecolour}
-parameter to \cw{draw_circle()} or \cw{draw_polygon()}, or with
-\cw{draw_line()} or \cw{draw_text()}.
-
-\S{print-rgb-mono-colour} \cw{print_rgb_mono_colour()}
-
-\c int print_rgb_mono_colour(drawing *dr, float r, float g,
-\c                           float b, float grey);
-
-This function allocates a colour index for a fully specified RGB
-colour during printing.
-
-\c{r}, \c{g} and \c{b} may each be anywhere in the range from 0 to 1.
-
-If printing in black and white only, these values will be ignored,
-and either pure black or pure white will be used instead, according
-to the \q{grey} parameter. (The fallback colour is the same as the
-one which would be allocated by \cw{print_mono_colour(grey)}.)
-
-\S{print-rgb-grey-colour} \cw{print_rgb_grey_colour()}
-
-\c int print_rgb_grey_colour(drawing *dr, float r, float g,
-\c                           float b, float grey);
-
-This function allocates a colour index for a fully specified RGB
-colour during printing.
-
-\c{r}, \c{g} and \c{b} may each be anywhere in the range from 0 to 1.
-
-If printing in black and white only, these values will be ignored,
-and a shade of grey given by the \c{grey} parameter will be used
-instead. (The fallback colour is the same as the one which would be
-allocated by \cw{print_grey_colour(grey)}.)
-
-\S{print-rgb-hatched-colour} \cw{print_rgb_hatched_colour()}
-
-\c int print_rgb_hatched_colour(drawing *dr, float r, float g,
-\c                              float b, float hatched);
-
-This function allocates a colour index for a fully specified RGB
-colour during printing.
-
-\c{r}, \c{g} and \c{b} may each be anywhere in the range from 0 to 1.
-
-If printing in black and white only, these values will be ignored,
-and a form of cross-hatching given by the \c{hatch} parameter will
-be used instead; see \k{print-hatched-colour} for the possible
-values of this parameter. (The fallback colour is the same as the
-one which would be allocated by \cw{print_hatched_colour(hatch)}.)
-
-\S{print-line-width} \cw{print_line_width()}
-
-\c void print_line_width(drawing *dr, int width);
-
-This function is called to set the thickness of lines drawn during
-printing. It is meaningless in drawing: all lines drawn by
-\cw{draw_line()}, \cw{draw_circle} and \cw{draw_polygon()} are one
-pixel in thickness. However, in printing there is no clear
-definition of a pixel and so line widths must be explicitly
-specified.
-
-The line width is specified in the usual coordinate system. Note,
-however, that it is a hint only: the central printing system may
-choose to vary line thicknesses at user request or due to printer
-capabilities.
-
-\S{print-line-dotted} \cw{print_line_dotted()}
-
-\c void print_line_dotted(drawing *dr, bool dotted);
-
-This function is called to toggle the drawing of dotted lines during
-printing. It is not supported during drawing.
-
-Setting \cq{dotted} to \cw{true} means that future lines drawn by
-\cw{draw_line()}, \cw{draw_circle} and \cw{draw_polygon()} will be
-dotted. Setting it to \cw{false} means that they will be solid.
-
-Some front ends may impose restrictions on the width of dotted
-lines. Asking for a dotted line via this front end will override any
-line width request if the front end requires it.
-
-\H{drawing-frontend} The drawing API as implemented by the front end
-
-This section describes the drawing API in the function-pointer form
-in which it is implemented by a front end.
-
-(It isn't only platform-specific front ends which implement this
-API; the platform-independent module \c{ps.c} also provides an
-implementation of it which outputs PostScript. Thus, any platform
-which wants to do PS printing can do so with minimum fuss.)
-
-The following entries all describe function pointer fields in a
-structure called \c{drawing_api}. Each of the functions takes a
-\cq{void *} context pointer, which it should internally cast back to
-a more useful type. Thus, a drawing \e{object} (\c{drawing *)}
-suitable for passing to the back end redraw or printing functions
-is constructed by passing a \c{drawing_api} and a \cq{void *} to the
-function \cw{drawing_new()} (see \k{drawing-new}).
-
-\S{drawingapi-draw-text} \cw{draw_text()}
-
-\c void (*draw_text)(void *handle, int x, int y, int fonttype,
-\c                   int fontsize, int align, int colour,
-\c                   const char *text);
-
-This function behaves exactly like the back end \cw{draw_text()}
-function; see \k{drawing-draw-text}.
-
-\S{drawingapi-draw-rect} \cw{draw_rect()}
-
-\c void (*draw_rect)(void *handle, int x, int y, int w, int h,
-\c                   int colour);
-
-This function behaves exactly like the back end \cw{draw_rect()}
-function; see \k{drawing-draw-rect}.
-
-\S{drawingapi-draw-line} \cw{draw_line()}
-
-\c void (*draw_line)(void *handle, int x1, int y1, int x2, int y2,
-\c                   int colour);
-
-This function behaves exactly like the back end \cw{draw_line()}
-function; see \k{drawing-draw-line}.
-
-\S{drawingapi-draw-polygon} \cw{draw_polygon()}
-
-\c void (*draw_polygon)(void *handle, const int *coords, int npoints,
-\c                      int fillcolour, int outlinecolour);
-
-This function behaves exactly like the back end \cw{draw_polygon()}
-function; see \k{drawing-draw-polygon}.
-
-\S{drawingapi-draw-circle} \cw{draw_circle()}
-
-\c void (*draw_circle)(void *handle, int cx, int cy, int radius,
-\c                     int fillcolour, int outlinecolour);
-
-This function behaves exactly like the back end \cw{draw_circle()}
-function; see \k{drawing-draw-circle}.
-
-\S{drawingapi-draw-thick-line} \cw{draw_thick_line()}
-
-\c void draw_thick_line(drawing *dr, float thickness,
-\c                      float x1, float y1, float x2, float y2,
-\c                      int colour)
-
-This function behaves exactly like the back end
-\cw{draw_thick_line()} function; see \k{drawing-draw-thick-line}.
-
-An implementation of this API which doesn't provide high-quality
-rendering of thick lines is permitted to define this function
-pointer to be \cw{NULL}. The middleware in \cw{drawing.c} will notice
-and provide a low-quality alternative using \cw{draw_polygon()}.
-
-\S{drawingapi-draw-update} \cw{draw_update()}
-
-\c void (*draw_update)(void *handle, int x, int y, int w, int h);
-
-This function behaves exactly like the back end \cw{draw_update()}
-function; see \k{drawing-draw-update}.
-
-An implementation of this API which only supports printing is
-permitted to define this function pointer to be \cw{NULL} rather
-than bothering to define an empty function. The middleware in
-\cw{drawing.c} will notice and avoid calling it.
-
-\S{drawingapi-clip} \cw{clip()}
-
-\c void (*clip)(void *handle, int x, int y, int w, int h);
-
-This function behaves exactly like the back end \cw{clip()}
-function; see \k{drawing-clip}.
-
-\S{drawingapi-unclip} \cw{unclip()}
-
-\c void (*unclip)(void *handle);
-
-This function behaves exactly like the back end \cw{unclip()}
-function; see \k{drawing-unclip}.
-
-\S{drawingapi-start-draw} \cw{start_draw()}
-
-\c void (*start_draw)(void *handle);
-
-This function is called at the start of drawing. It allows the front
-end to initialise any temporary data required to draw with, such as
-device contexts.
-
-Implementations of this API which do not provide drawing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless drawing is attempted.
-
-\S{drawingapi-end-draw} \cw{end_draw()}
-
-\c void (*end_draw)(void *handle);
-
-This function is called at the end of drawing. It allows the front
-end to do cleanup tasks such as deallocating device contexts and
-scheduling appropriate GUI redraw events.
-
-Implementations of this API which do not provide drawing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless drawing is attempted.
-
-\S{drawingapi-status-bar} \cw{status_bar()}
-
-\c void (*status_bar)(void *handle, const char *text);
-
-This function behaves exactly like the back end \cw{status_bar()}
-function; see \k{drawing-status-bar}.
-
-Front ends implementing this function need not worry about it being
-called repeatedly with the same text; the middleware code in
-\cw{status_bar()} will take care of this.
-
-Implementations of this API which do not provide drawing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless drawing is attempted.
-
-\S{drawingapi-blitter-new} \cw{blitter_new()}
-
-\c blitter *(*blitter_new)(void *handle, int w, int h);
-
-This function behaves exactly like the back end \cw{blitter_new()}
-function; see \k{drawing-blitter-new}.
-
-Implementations of this API which do not provide drawing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless drawing is attempted.
-
-\S{drawingapi-blitter-free} \cw{blitter_free()}
-
-\c void (*blitter_free)(void *handle, blitter *bl);
-
-This function behaves exactly like the back end \cw{blitter_free()}
-function; see \k{drawing-blitter-free}.
-
-Implementations of this API which do not provide drawing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless drawing is attempted.
-
-\S{drawingapi-blitter-save} \cw{blitter_save()}
-
-\c void (*blitter_save)(void *handle, blitter *bl, int x, int y);
-
-This function behaves exactly like the back end \cw{blitter_save()}
-function; see \k{drawing-blitter-save}.
-
-Implementations of this API which do not provide drawing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless drawing is attempted.
-
-\S{drawingapi-blitter-load} \cw{blitter_load()}
-
-\c void (*blitter_load)(void *handle, blitter *bl, int x, int y);
-
-This function behaves exactly like the back end \cw{blitter_load()}
-function; see \k{drawing-blitter-load}.
-
-Implementations of this API which do not provide drawing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless drawing is attempted.
-
-\S{drawingapi-begin-doc} \cw{begin_doc()}
-
-\c void (*begin_doc)(void *handle, int pages);
-
-This function is called at the beginning of a printing run. It gives
-the front end an opportunity to initialise any required printing
-subsystem. It also provides the number of pages in advance.
-
-Implementations of this API which do not provide printing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless printing is attempted.
-
-\S{drawingapi-begin-page} \cw{begin_page()}
-
-\c void (*begin_page)(void *handle, int number);
-
-This function is called during printing, at the beginning of each
-page. It gives the page number (numbered from 1 rather than 0, so
-suitable for use in user-visible contexts).
-
-Implementations of this API which do not provide printing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless printing is attempted.
-
-\S{drawingapi-begin-puzzle} \cw{begin_puzzle()}
-
-\c void (*begin_puzzle)(void *handle, float xm, float xc,
-\c                      float ym, float yc, int pw, int ph, float wmm);
-
-This function is called during printing, just before printing a
-single puzzle on a page. It specifies the size and location of the
-puzzle on the page.
-
-\c{xm} and \c{xc} specify the horizontal position of the puzzle on
-the page, as a linear function of the page width. The front end is
-expected to multiply the page width by \c{xm}, add \c{xc} (measured
-in millimetres), and use the resulting x-coordinate as the left edge
-of the puzzle.
-
-Similarly, \c{ym} and \c{yc} specify the vertical position of the
-puzzle as a function of the page height: the page height times
-\c{ym}, plus \c{yc} millimetres, equals the desired distance from
-the top of the page to the top of the puzzle.
-
-(This unwieldy mechanism is required because not all printing
-systems can communicate the page size back to the software. The
-PostScript back end, for example, writes out PS which determines the
-page size at print time by means of calling \cq{clippath}, and
-centres the puzzles within that. Thus, exactly the same PS file
-works on A4 or on US Letter paper without needing local
-configuration, which simplifies matters.)
-
-\cw{pw} and \cw{ph} give the size of the puzzle in drawing API
-coordinates. The printing system will subsequently call the puzzle's
-own print function, which will in turn call drawing API functions in
-the expectation that an area \cw{pw} by \cw{ph} units is available
-to draw the puzzle on.
-
-Finally, \cw{wmm} gives the desired width of the puzzle in
-millimetres. (The aspect ratio is expected to be preserved, so if
-the desired puzzle height is also needed then it can be computed as
-\cw{wmm*ph/pw}.)
-
-Implementations of this API which do not provide printing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless printing is attempted.
-
-\S{drawingapi-end-puzzle} \cw{end_puzzle()}
-
-\c void (*end_puzzle)(void *handle);
-
-This function is called after the printing of a specific puzzle is
-complete.
-
-Implementations of this API which do not provide printing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless printing is attempted.
-
-\S{drawingapi-end-page} \cw{end_page()}
-
-\c void (*end_page)(void *handle, int number);
-
-This function is called after the printing of a page is finished.
-
-Implementations of this API which do not provide printing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless printing is attempted.
-
-\S{drawingapi-end-doc} \cw{end_doc()}
-
-\c void (*end_doc)(void *handle);
-
-This function is called after the printing of the entire document is
-finished. This is the moment to close files, send things to the
-print spooler, or whatever the local convention is.
-
-Implementations of this API which do not provide printing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless printing is attempted.
-
-\S{drawingapi-line-width} \cw{line_width()}
-
-\c void (*line_width)(void *handle, float width);
-
-This function is called to set the line thickness, during printing
-only. Note that the width is a \cw{float} here, where it was an
-\cw{int} as seen by the back end. This is because \cw{drawing.c} may
-have scaled it on the way past.
-
-However, the width is still specified in the same coordinate system
-as the rest of the drawing.
-
-Implementations of this API which do not provide printing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless printing is attempted.
-
-\S{drawingapi-line-dotted} \cw{line_dotted()}
-
-\c void (*line_dotted)(void *handle, bool dotted);
-
-This function is called to toggle drawing of dotted lines, during
-printing only.
-
-Implementations of this API which do not provide printing services
-may define this function pointer to be \cw{NULL}; it will never be
-called unless printing is attempted.
-
-\S{drawingapi-text-fallback} \cw{text_fallback()}
-
-\c char *(*text_fallback)(void *handle, const char *const *strings,
-\c                        int nstrings);
-
-This function behaves exactly like the back end \cw{text_fallback()}
-function; see \k{drawing-text-fallback}.
-
-Implementations of this API which do not support any characters
-outside ASCII may define this function pointer to be \cw{NULL}, in
-which case the central code in \cw{drawing.c} will provide a default
-implementation.
-
-\H{drawingapi-frontend} The drawing API as called by the front end
-
-There are a small number of functions provided in \cw{drawing.c}
-which the front end needs to \e{call}, rather than helping to
-implement. They are described in this section.
-
-\S{drawing-new} \cw{drawing_new()}
-
-\c drawing *drawing_new(const drawing_api *api, midend *me,
-\c                      void *handle);
-
-This function creates a drawing object. It is passed a
-\c{drawing_api}, which is a structure containing nothing but
-function pointers; and also a \cq{void *} handle. The handle is
-passed back to each function pointer when it is called.
-
-The \c{midend} parameter is used for rewriting the status bar
-contents: \cw{status_bar()} (see \k{drawing-status-bar}) has to call
-a function in the mid-end which might rewrite the status bar text.
-If the drawing object is to be used only for printing, or if the
-game is known not to call \cw{status_bar()}, this parameter may be
-\cw{NULL}.
-
-\S{drawing-free} \cw{drawing_free()}
-
-\c void drawing_free(drawing *dr);
-
-This function frees a drawing object. Note that the \cq{void *}
-handle is not freed; if that needs cleaning up it must be done by
-the front end.
-
-\S{drawing-print-get-colour} \cw{print_get_colour()}
-
-\c void print_get_colour(drawing *dr, int colour,
-\c                       bool printing_in_colour,
-\c                       int *hatch, float *r, float *g, float *b);
-
-This function is called by the implementations of the drawing API
-functions when they are called in a printing context. It takes a
-colour index as input, and returns the description of the colour as
-requested by the back end.
-
-\c{printing_in_colour} is \cw{true} iff the implementation is printing
-in colour. This will alter the results returned if the colour in
-question was specified with a black-and-white fallback value.
-
-If the colour should be rendered by hatching, \c{*hatch} is filled
-with the type of hatching desired. See \k{print-grey-colour} for
-details of the values this integer can take.
-
-If the colour should be rendered as solid colour, \c{*hatch} is
-given a negative value, and \c{*r}, \c{*g} and \c{*b} are filled
-with the RGB values of the desired colour (if printing in colour),
-or all filled with the grey-scale value (if printing in black and
-white).
-
-\C{midend} The API provided by the mid-end
-
-This chapter documents the API provided by the mid-end to be called
-by the front end. You probably only need to read this if you are a
-front end implementor, i.e. you are porting Puzzles to a new
-platform. If you're only interested in writing new puzzles, you can
-safely skip this chapter.
-
-All the persistent state in the mid-end is encapsulated within a
-\c{midend} structure, to facilitate having multiple mid-ends in any
-port which supports multiple puzzle windows open simultaneously.
-Each \c{midend} is intended to handle the contents of a single
-puzzle window.
-
-\H{midend-new} \cw{midend_new()}
-
-\c midend *midend_new(frontend *fe, const game *ourgame,
-\c                    const drawing_api *drapi, void *drhandle);
-
-Allocates and returns a new mid-end structure.
-
-The \c{fe} argument is stored in the mid-end. It will be used when
-calling back to functions such as \cw{activate_timer()}
-(\k{frontend-activate-timer}), and will be passed on to the back end
-function \cw{colours()} (\k{backend-colours}).
-
-The parameters \c{drapi} and \c{drhandle} are passed to
-\cw{drawing_new()} (\k{drawing-new}) to construct a drawing object
-which will be passed to the back end function \cw{redraw()}
-(\k{backend-redraw}). Hence, all drawing-related function pointers
-defined in \c{drapi} can expect to be called with \c{drhandle} as
-their first argument.
-
-The \c{ourgame} argument points to a container structure describing
-a game back end. The mid-end thus created will only be capable of
-handling that one game. (So even in a monolithic front end
-containing all the games, this imposes the constraint that any
-individual puzzle window is tied to a single game. Unless, of
-course, you feel brave enough to change the mid-end for the window
-without closing the window...)
-
-\H{midend-free} \cw{midend_free()}
-
-\c void midend_free(midend *me);
-
-Frees a mid-end structure and all its associated data.
-
-\H{midend-tilesize} \cw{midend_tilesize()}
-
-\c int midend_tilesize(midend *me);
-
-Returns the \cq{tilesize} parameter being used to display the
-current puzzle (\k{backend-preferred-tilesize}).
-
-\H{midend-set-params} \cw{midend_set_params()}
-
-\c void midend_set_params(midend *me, game_params *params);
-
-Sets the current game parameters for a mid-end. Subsequent games
-generated by \cw{midend_new_game()} (\k{midend-new-game}) will use
-these parameters until further notice.
-
-The usual way in which the front end will have an actual
-\c{game_params} structure to pass to this function is if it had
-previously got it from \cw{midend_get_presets()}
-(\k{midend-get-presets}). Thus, this function is usually called in
-response to the user making a selection from the presets menu.
-
-\H{midend-get-params} \cw{midend_get_params()}
-
-\c game_params *midend_get_params(midend *me);
-
-Returns the current game parameters stored in this mid-end.
-
-The returned value is dynamically allocated, and should be freed
-when finished with by passing it to the game's own
-\cw{free_params()} function (see \k{backend-free-params}).
-
-\H{midend-size} \cw{midend_size()}
-
-\c void midend_size(midend *me, int *x, int *y,
-\c                  bool user_size, double device_pixel_ratio);
-
-Tells the mid-end to figure out its window size.
-
-On input, \c{*x} and \c{*y} should contain the maximum or requested
-size for the window. (Typically this will be the size of the screen
-that the window has to fit on, or similar.) The mid-end will
-repeatedly call the back end function \cw{compute_size()}
-(\k{backend-compute-size}), searching for a tile size that best
-satisfies the requirements. On exit, \c{*x} and \c{*y} will contain
-the size needed for the puzzle window's drawing area. (It is of
-course up to the front end to adjust this for any additional window
-furniture such as menu bars and window borders, if necessary. The
-status bar is also not included in this size.)
-
-Use \c{user_size} to indicate whether \c{*x} and \c{*y} are a
-requested size, or just a maximum size.
-
-If \c{user_size} is set to \cw{true}, the mid-end will treat the
-input size as a request, and will pick a tile size which
-approximates it \e{as closely as possible}, going over the game's
-preferred tile size if necessary to achieve this. The mid-end will
-also use the resulting tile size as its preferred one until further
-notice, on the assumption that this size was explicitly requested
-by the user. Use this option if you want your front end to support
-dynamic resizing of the puzzle window with automatic scaling of the
-puzzle to fit.
-
-If \c{user_size} is set to \cw{false}, then the game's tile size
-will never go over its preferred one, although it may go under in
-order to fit within the maximum bounds specified by \c{*x} and
-\c{*y}. This is the recommended approach when opening a new window
-at default size: the game will use its preferred size unless it has
-to use a smaller one to fit on the screen. If the tile size is
-shrunk for this reason, the change will not persist; if a smaller
-grid is subsequently chosen, the tile size will recover.
-
-The mid-end will try as hard as it can to return a size which is
-less than or equal to the input size, in both dimensions. In extreme
-circumstances it may fail (if even the lowest possible tile size
-gives window dimensions greater than the input), in which case it
-will return a size greater than the input size. Front ends should be
-prepared for this to happen (i.e. don't crash or fail an assertion),
-but may handle it in any way they see fit: by rejecting the game
-parameters which caused the problem, by opening a window larger than
-the screen regardless of inconvenience, by introducing scroll bars
-on the window, by drawing on a large bitmap and scaling it into a
-smaller window, or by any other means you can think of. It is likely
-that when the tile size is that small the game will be unplayable
-anyway, so don't put \e{too} much effort into handling it
-creatively.
-
-If your platform has no limit on window size (or if you're planning
-to use scroll bars for large puzzles), you can pass dimensions of
-\cw{INT_MAX} as input to this function. You should probably not do
-that \e{and} set the \c{user_size} flag, though!
-
-The \cw{device_pixel_ratio} allows the front end to specify that its
-pixels are unusually large or small (or should be treated as such).
-The mid-end uses this to adjust the tile size, both at startup (if the
-ratio is not 1) and if the ratio changes.
-
-A \cw{device_pixel_ratio} of 1 indicates normal-sized pixels.
-\q{Normal} is not precisely defined, but it's about 4 pixels per
-millimetre on a screen designed to be viewed from a metre away, or a
-size such that text 15 pixels high is comfortably readable.  Some
-platforms have a concept of a logical pixel that this can be mapped
-onto.  For instance, Cascading Style Sheets (CSS) has a unit called
-\cq{px} that only matches physical pixels at a \cw{device_pixel_ratio}
-of 1.
-
-The \cw{device_pixel_ratio} indicates the number of physical pixels in
-a normal-sized pixel, so values less than 1 indicate unusually large
-pixels and values greater than 1 indicate unusually small pixels.
-
-The midend relies on the frontend calling \cw{midend_new_game()}
-(\k{midend-new-game}) before calling \cw{midend_size()}.
-
-\H{midend-reset-tilesize} \cw{midend_reset_tilesize()}
-
-\c void midend_reset_tilesize(midend *me);
-
-This function resets the midend's preferred tile size to that of the
-standard puzzle.
-
-As discussed in \k{midend-size}, puzzle resizes are typically
-'sticky', in that once the user has dragged the puzzle to a different
-window size, the resulting tile size will be remembered and used when
-the puzzle configuration changes. If you \e{don't} want that, e.g. if
-you want to provide a command to explicitly reset the puzzle size back
-to its default, then you can call this just before calling
-\cw{midend_size()} (which, in turn, you would probably call with
-\c{user_size} set to \cw{false}).
-
-\H{midend-new-game} \cw{midend_new_game()}
-
-\c void midend_new_game(midend *me);
-
-Causes the mid-end to begin a new game. Normally the game will be a
-new randomly generated puzzle. However, if you have previously
-called \cw{midend_game_id()} or \cw{midend_set_config()}, the game
-generated might be dictated by the results of those functions. (In
-particular, you \e{must} call \cw{midend_new_game()} after calling
-either of those functions, or else no immediate effect will be
-visible.)
-
-You will probably need to call \cw{midend_size()} after calling this
-function, because if the game parameters have been changed since the
-last new game then the window size might need to change. (If you
-know the parameters \e{haven't} changed, you don't need to do this.)
-
-This function will create a new \c{game_drawstate}, but does not
-actually perform a redraw (since you often need to call
-\cw{midend_size()} before the redraw can be done). So after calling
-this function and after calling \cw{midend_size()}, you should then
-call \cw{midend_redraw()}. (It is not necessary to call
-\cw{midend_force_redraw()}; that will discard the draw state and
-create a fresh one, which is unnecessary in this case since there's
-a fresh one already. It would work, but it's usually excessive.)
-
-\H{midend-restart-game} \cw{midend_restart_game()}
-
-\c void midend_restart_game(midend *me);
-
-This function causes the current game to be restarted. This is done
-by placing a new copy of the original game state on the end of the
-undo list (so that an accidental restart can be undone).
-
-This function automatically causes a redraw, i.e. the front end can
-expect its drawing API to be called from \e{within} a call to this
-function. Some back ends require that \cw{midend_size()}
-(\k{midend-size}) is called before \cw{midend_restart_game()}.
-
-\H{midend-force-redraw} \cw{midend_force_redraw()}
-
-\c void midend_force_redraw(midend *me);
-
-Forces a complete redraw of the puzzle window, by means of
-discarding the current \c{game_drawstate} and creating a new one
-from scratch before calling the game's \cw{redraw()} function.
-
-The front end can expect its drawing API to be called from within a
-call to this function. Some back ends require that \cw{midend_size()}
-(\k{midend-size}) is called before \cw{midend_force_redraw()}.
-
-\H{midend-redraw} \cw{midend_redraw()}
-
-\c void midend_redraw(midend *me);
-
-Causes a partial redraw of the puzzle window, by means of simply
-calling the game's \cw{redraw()} function. (That is, the only things
-redrawn will be things that have changed since the last redraw.)
-
-The front end can expect its drawing API to be called from within a
-call to this function. Some back ends require that \cw{midend_size()}
-(\k{midend-size}) is called before \cw{midend_redraw()}.
-
-\H{midend-process-key} \cw{midend_process_key()}
-
-\c int midend_process_key(midend *me, int x, int y, int button)
-
-The front end calls this function to report a mouse or keyboard event.
-The parameters \c{x} and \c{y} are identical to the ones passed to the
-back end function \cw{interpret_move()} (\k{backend-interpret-move}).
-
-\c{button} is similar to the parameter passed to
-\cw{interpret_move()}. However, the midend is more relaxed about
-values passed to in, and some additional special button values
-are defined for the front end to pass to the midend (see below).
-
-Also, the front end is \e{not} required to provide guarantees about
-mouse event ordering. The mid-end will sort out multiple simultaneous
-button presses and changes of button; the front end's responsibility
-is simply to pass on the mouse events it receives as accurately as
-possible.
-
-(Some platforms may need to emulate absent mouse buttons by means of
-using a modifier key such as Shift with another mouse button. This
-tends to mean that if Shift is pressed or released in the middle of
-a mouse drag, the mid-end will suddenly stop receiving, say,
-\cw{LEFT_DRAG} events and start receiving \cw{RIGHT_DRAG}s, with no
-intervening button release or press events. This too is something
-which the mid-end will sort out for you; the front end has no
-obligation to maintain sanity in this area.)
-
-The front end \e{should}, however, always eventually send some kind
-of button release. On some platforms this requires special effort:
-Windows, for example, requires a call to the system API function
-\cw{SetCapture()} in order to ensure that your window receives a
-mouse-up event even if the pointer has left the window by the time
-the mouse button is released. On any platform that requires this
-sort of thing, the front end \e{is} responsible for doing it.
-
-Calling this function is very likely to result in calls back to the
-front end's drawing API and/or \cw{activate_timer()}
-(\k{frontend-activate-timer}).
-
-The return value from \cw{midend_process_key()} is one of the
-following constants:
-
-\dt \cw{PKR_QUIT}
-
-\dd Means that the effect of the keypress was to request termination
-of the program.  A front end should shut down the puzzle in response
-to a \cw{PKR_QUIT} return.
-
-\dt \cw{PKR_SOME_EFFECT}
-
-\dd The keypress had some other effect, either in the mid-end or in
-the puzzle itself.
-
-\dt \cw{PKR_NO_EFFECT}
-
-\dd The keypress had no effect, but might have had an effect in
-slightly different circumstances.  For instance it requested a move
-that wasn't possible.
-
-\dt \cw{PKR_UNUSED}
-
-\dd The key was one that neither the mid-end nor the back-end has any
-use for at all.
-
-A front end might respond to the last value by passing the key on to
-something else that might be interested in it.
-
-The following additional values of \c{button} are permitted to be
-passed to this function by the front end, but are never passed on to
-the back end. They indicate front-end specific UI operations, such as
-selecting an option from a drop-down menu. (Otherwise the front end
-would have to translate the \q{New Game} menu item into an \cq{n}
-keypress, for example.)
-
-\dt \cw{UI_NEWGAME}
-
-\dd Indicates that the user requested a new game, similar to pressing
-\cq{n}.
-
-\dt \cw{UI_SOLVE}
-
-\dd Indicates that the user requested the solution of the current game.
-
-\dt \cw{UI_UNDO}
-
-\dd Indicates that the user attempted to undo a move.
-
-\dt \cw{UI_REDO}
-
-\dd Indicates that the user attempted to redo an undone move.
-
-\dt \cw{UI_QUIT}
-
-\dd Indicates that the user asked to quit the game. (Of course, a
-front end might perfectly well handle this on its own. But including
-it in this enumeration allows the front end to treat all these menu
-items the same, by translating each of them into a button code passed
-to the midend, and handle quitting by noticing the \c{false} return
-value from \cw{midend_process_key()}.)
-
-The midend tolerates any modifier being set on any key and removes
-them as necessary before passing the key on to the backend.  It will
-also handle translating printable characters combined with
-\cw{MOD_CTRL} into control characters.
-
-\H{midend-request-keys} \cw{midend_request_keys()}
-
-\c key_label *midend_request_keys(midend *me, int *nkeys);
-
-This function behaves similarly to the backend's \cw{request_keys()}
-function (\k{backend-request-keys}). If the backend does not provide
-\cw{request_keys()}, this function will return \cw{NULL} and set
-\cw{*nkeys} to zero. Otherwise, this function will fill in the generic
-labels (i.e. the \cw{key_label} items that have their \cw{label}
-fields set to \cw{NULL}) by using \cw{button2label()}
-(\k{utils-button2label}).
-
-\H{midend-current-key-label} \cw{midend_current_key_label()}
-
-\c const char *midend_current_key_label(midend *me, int button);
-
-This is a thin wrapper around the backend's \cw{current_key_label()}
-function (\k{backend-current-key-label}).  Front ends that need to
-label \cw{CURSOR_SELECT} or \cw{CURSOR_SELECT2} should call this
-function after each move (at least after each call to
-\cw{midend_process_key()}) to get the current labels.  The front end
-should arrange to copy the returned string somewhere before the next
-call to the mid-end, just in case it's dynamically allocated.  If the
-button supplied does nothing, the label returned will be an empty
-string.
-
-\H{midend-colours} \cw{midend_colours()}
-
-\c float *midend_colours(midend *me, int *ncolours);
-
-Returns an array of the colours required by the game, in exactly the
-same format as that returned by the back end function \cw{colours()}
-(\k{backend-colours}). Front ends should call this function rather
-than calling the back end's version directly, since the mid-end adds
-standard customisation facilities. (At the time of writing, those
-customisation facilities are implemented hackily by means of
-environment variables, but it's not impossible that they may become
-more full and formal in future.)
-
-\H{midend-timer} \cw{midend_timer()}
-
-\c void midend_timer(midend *me, float tplus);
-
-If the mid-end has called \cw{activate_timer()}
-(\k{frontend-activate-timer}) to request regular callbacks for
-purposes of animation or timing, this is the function the front end
-should call on a regular basis. The argument \c{tplus} gives the
-time, in seconds, since the last time either this function was
-called or \cw{activate_timer()} was invoked.
-
-One of the major purposes of timing in the mid-end is to perform
-move animation. Therefore, calling this function is very likely to
-result in calls back to the front end's drawing API.
-
-\H{midend-get-presets} \cw{midend_get_presets()}
-
-\c struct preset_menu *midend_get_presets(midend *me, int *id_limit);
-
-Returns a data structure describing this game's collection of preset
-game parameters, organised into a hierarchical structure of menus and
-submenus.
-
-The return value is a pointer to a data structure containing the
-following fields (among others, which are not intended for front end
-use):
-
-\c struct preset_menu {
-\c     int n_entries;
-\c     struct preset_menu_entry *entries;
-\c     /* and other things */
-\e     iiiiiiiiiiiiiiiiiiiiii
-\c };
-
-Those fields describe the intended contents of one particular menu in
-the hierarchy. \cq{entries} points to an array of \cq{n_entries}
-items, each of which is a structure containing the following fields:
-
-\c struct preset_menu_entry {
-\c     char *title;
-\c     game_params *params;
-\c     struct preset_menu *submenu;
-\c     int id;
-\c };
-
-Of these fields, \cq{title} and \cq{id} are present in every entry,
-giving (respectively) the textual name of the menu item and an integer
-identifier for it. The integer id will correspond to the one returned
-by \c{midend_which_preset} (\k{midend-which-preset}), when that preset
-is the one selected.
-
-The other two fields are mutually exclusive. Each \c{struct
-preset_menu_entry} will have one of those fields \cw{NULL} and the
-other one non-null. If the menu item is an actual preset, then
-\cq{params} will point to the set of game parameters that go with the
-name; if it's a submenu, then \cq{submenu} instead will be non-null,
-and will point at a subsidiary \c{struct preset_menu}.
-
-The complete hierarchy of these structures is owned by the mid-end,
-and will be freed when the mid-end is freed. The front end should not
-attempt to free any of it.
-
-The integer identifiers will be allocated densely from 0 upwards, so
-that it's reasonable for the front end to allocate an array which uses
-them as indices, if it needs to store information per preset menu
-item. For this purpose, the front end may pass the second parameter
-\cq{id_limit} to \cw{midend_get_presets} as the address of an \c{int}
-variable, into which \cw{midend_get_presets} will write an integer one
-larger than the largest id number actually used (i.e. the number of
-elements the front end would need in the array).
-
-Submenu-type entries also have integer identifiers.
-
-\H{midend-which-preset} \cw{midend_which_preset()}
-
-\c int midend_which_preset(midend *me);
-
-Returns the numeric index of the preset game parameter structure
-which matches the current game parameters, or a negative number if
-no preset matches. Front ends could use this to maintain a tick
-beside one of the items in the menu (or tick the \q{Custom} option
-if the return value is less than zero).
-
-The returned index value (if non-negative) will match the \c{id} field
-of the corresponding \cw{struct preset_menu_entry} returned by
-\c{midend_get_presets()} (\k{midend-get-presets}).
-
-\H{midend-wants-statusbar} \cw{midend_wants_statusbar()}
-
-\c bool midend_wants_statusbar(midend *me);
-
-This function returns \cw{true} if the puzzle has a use for a
-textual status line (to display score, completion status, currently
-active tiles, time, or anything else).
-
-Front ends should call this function rather than talking directly to
-the back end.
-
-\H{midend-get-config} \cw{midend_get_config()}
-
-\c config_item *midend_get_config(midend *me, int which,
-\c                                char **wintitle);
-
-Returns a dialog box description for user configuration.
-
-On input, \cw{which} should be set to one of three values, which
-select which of the various dialog box descriptions is returned:
-
-\dt \cw{CFG_SETTINGS}
-
-\dd Requests the GUI parameter configuration box generated by the
-puzzle itself. This should be used when the user selects \q{Custom}
-from the game types menu (or equivalent). The mid-end passes this
-request on to the back end function \cw{configure()}
-(\k{backend-configure}).
-
-\dt \cw{CFG_DESC}
-
-\dd Requests a box suitable for entering a descriptive game ID (and
-viewing the existing one). The mid-end generates this dialog box
-description itself. This should be used when the user selects
-\q{Specific} from the game menu (or equivalent).
-
-\dt \cw{CFG_SEED}
-
-\dd Requests a box suitable for entering a random-seed game ID (and
-viewing the existing one). The mid-end generates this dialog box
-description itself. This should be used when the user selects
-\q{Random Seed} from the game menu (or equivalent).
-
-\dt \cw{CFG_PREFS}
-
-\dd Requests a box suitable for configuring user preferences.
-
-(An additional value \cw{CFG_FRONTEND_SPECIFIC} is provided in this
-enumeration, so that frontends can extend it for their own internal
-use. For example, you might wrap this function with a
-\cw{frontend_get_config} which handles some values of \c{which} itself
-and hands others on to the midend, depending on whether \cw{which <
-CFG_FRONTEND_SPECIFIC}.)
-
-The returned value is an array of \cw{config_item}s, exactly as
-described in \k{backend-configure}. Another returned value is an
-ASCII string giving a suitable title for the configuration window,
-in \c{*wintitle}.
-
-Both returned values are dynamically allocated and will need to be
-freed. The window title can be freed in the obvious way; the
-\cw{config_item} array is a slightly complex structure, so a utility
-function \cw{free_cfg()} is provided to free it for you. See
-\k{utils-free-cfg}.
-
-(Of course, you will probably not want to free the \cw{config_item}
-array until the dialog box is dismissed, because before then you
-will probably need to pass it to \cw{midend_set_config}.)
-
-\H{midend-set-config} \cw{midend_set_config()}
-
-\c const char *midend_set_config(midend *me, int which,
-\c                               config_item *cfg);
-
-Passes the mid-end the results of a configuration dialog box.
-\c{which} should have the same value which it had when
-\cw{midend_get_config()} was called; \c{cfg} should be the array of
-\c{config_item}s returned from \cw{midend_get_config()}, modified to
-contain the results of the user's editing operations.
-
-This function returns \cw{NULL} on success, or otherwise (if the
-configuration data was in some way invalid) an ASCII string
-containing an error message suitable for showing to the user.
-
-If the function succeeds, it is likely that the game parameters will
-have been changed and it is certain that a new game will be
-requested. The front end should therefore call
-\cw{midend_new_game()}, and probably also re-think the window size
-using \cw{midend_size()} and eventually perform a refresh using
-\cw{midend_redraw()}.
-
-\H{midend-game-id} \cw{midend_game_id()}
-
-\c const char *midend_game_id(midend *me, const char *id);
-
-Passes the mid-end a string game ID (of any of the valid forms
-\cq{params}, \cq{params:description} or \cq{params#seed}) which the
-mid-end will process and use for the next generated game.
-
-This function returns \cw{NULL} on success, or otherwise (if the
-configuration data was in some way invalid) an ASCII string
-containing an error message (not dynamically allocated) suitable for
-showing to the user. In the event of an error, the mid-end's
-internal state will be left exactly as it was before the call.
-
-If the function succeeds, it is likely that the game parameters will
-have been changed and it is certain that a new game will be
-requested. The front end should therefore call
-\cw{midend_new_game()}, and probably also re-think the window size
-using \cw{midend_size()} and eventually case a refresh using
-\cw{midend_redraw()}.
-
-\H{midend-get-game-id} \cw{midend_get_game_id()}
-
-\c char *midend_get_game_id(midend *me);
-
-Returns a descriptive game ID (i.e. one in the form
-\cq{params:description}) describing the game currently active in the
-mid-end. The returned string is dynamically allocated.
-
-\H{midend-get-random-seed} \cw{midend_get_random_seed()}
-
-\c char *midend_get_random_seed(midend *me);
-
-Returns a random game ID (i.e. one in the form \cq{params#seedstring})
-describing the game currently active in the mid-end, if there is one.
-If the game was created by entering a description, no random seed will
-currently exist and this function will return \cw{NULL}.
-
-The returned string, if it is non-\cw{NULL}, is dynamically allocated.
-
-Unlike the descriptive game ID, the random seed can contain characters
-outside the printable ASCII set.
-
-\H{midend-can-format-as-text-now} \cw{midend_can_format_as_text_now()}
-
-\c bool midend_can_format_as_text_now(midend *me);
-
-Returns \cw{true} if the game code is capable of formatting puzzles
-of the currently selected game type as ASCII.
-
-If this returns \cw{false}, then \cw{midend_text_format()}
-(\k{midend-text-format}) will return \cw{NULL}.
-
-\H{midend-text-format} \cw{midend_text_format()}
-
-\c char *midend_text_format(midend *me);
-
-Formats the current game's current state as ASCII text suitable for
-copying to the clipboard. The returned string is dynamically
-allocated.
-
-If the game's \c{can_format_as_text_ever} flag is \cw{false}, or if
-its \cw{can_format_as_text_now()} function returns \cw{false}, then
-this function will return \cw{NULL}.
-
-If the returned string contains multiple lines (which is likely), it
-will use the normal C line ending convention (\cw{\\n} only). On
-platforms which use a different line ending convention for data in
-the clipboard, it is the front end's responsibility to perform the
-conversion.
-
-\H{midend-solve} \cw{midend_solve()}
-
-\c const char *midend_solve(midend *me);
-
-Requests the mid-end to perform a Solve operation.
-
-On success, \cw{NULL} is returned. On failure, an error message (not
-dynamically allocated) is returned, suitable for showing to the
-user.
-
-The front end can expect its drawing API and/or
-\cw{activate_timer()} to be called from within a call to this
-function.  Some back ends require that \cw{midend_size()}
-(\k{midend-size}) is called before \cw{midend_solve()}.
-
-\H{midend-get-cursor-location} \cw{midend_get_cursor_location()}
-
-\c bool midend_get_cursor_location(midend *me,
-\c                                 int *x, int *y,
-\c                                 int *w, int *h);
-
-This function requests the location of the back end's on-screen cursor
-or other region of interest.
-
-What exactly this region contains is up to the backend, but in general
-the region will be an area that the player is controlling with the
-cursor keys \dash such as the player location in Cube and Inertia, or
-the cursor in any of the conventional grid-based games. With knowledge
-of this location, a front end can, for example, ensure that the region
-of interest remains visible even if the entire puzzle is too big to
-fit on the screen.
-
-On success, this function returns \cw{true}, and the locations pointed
-to by \cw{x}, \cw{y}, \cw{w} and \cw{h} are updated to describe the
-cursor region, which has an upper-left corner located at \cw{(*x,*y)}
-and a size of \cw{*w} pixels wide by \cw{*h} pixels tall. The caller
-may pass \cw{NULL} for any number of these pointers, which will be
-ignored.
-
-On failure, this function returns \cw{false}. Failure can occur if
-there is currently no active cursor region, or if the back end lacks
-cursor support.
-
-\H{midend-status} \cw{midend_status()}
-
-\c int midend_status(midend *me);
-
-This function returns +1 if the midend is currently displaying a game
-in a solved state, -1 if the game is in a permanently lost state, or 0
-otherwise. This function just calls the back end's \cw{status()}
-function. Front ends may wish to use this as a cue to proactively
-offer the option of starting a new game.
-
-(See \k{backend-status} for more detail about the back end's
-\cw{status()} function and discussion of what should count as which
-status code.)
-
-\H{midend-can-undo} \cw{midend_can_undo()}
-
-\c bool midend_can_undo(midend *me);
-
-Returns \cw{true} if the midend is currently in a state where the undo
-operation is meaningful (i.e. at least one position exists on the undo
-chain before the present one). Front ends may wish to use this to
-visually activate and deactivate an undo button.
-
-\H{midend-can-redo} \cw{midend_can_redo()}
-
-\c bool midend_can_redo(midend *me);
-
-Returns \cw{true} if the midend is currently in a state where the redo
-operation is meaningful (i.e. at least one position exists on the redo
-chain after the present one). Front ends may wish to use this to
-visually activate and deactivate a redo button.
-
-\H{midend-serialise} \cw{midend_serialise()}
-
-\c void midend_serialise(midend *me,
-\c     void (*write)(void *ctx, const void *buf, int len), void *wctx);
-
-Calling this function causes the mid-end to convert its entire
-internal state into a long ASCII text string, and to pass that
-string (piece by piece) to the supplied \c{write} function.
-The string will consist of printable ASCII characters and line
-feeds.
-
-Desktop implementations can use this function to save a game in any
-state (including half-finished) to a disk file, by supplying a
-\c{write} function which is a wrapper on \cw{fwrite()} (or local
-equivalent). Other implementations may find other uses for it, such
-as compressing the large and sprawling mid-end state into a
-manageable amount of memory when a palmtop application is suspended
-so that another one can run; in this case \cw{write} might want to
-write to a memory buffer rather than a file. There may be other uses
-for it as well.
-
-This function will call back to the supplied \c{write} function a
-number of times, with the first parameter (\c{ctx}) equal to
-\c{wctx}, and the other two parameters pointing at a piece of the
-output string.
-
-\H{midend-deserialise} \cw{midend_deserialise()}
-
-\c const char *midend_deserialise(midend *me,
-\c     bool (*read)(void *ctx, void *buf, int len), void *rctx);
-
-This function is the counterpart to \cw{midend_serialise()}. It
-calls the supplied \cw{read} function repeatedly to read a quantity
-of data, and attempts to interpret that data as a serialised mid-end
-as output by \cw{midend_serialise()}.
-
-The \cw{read} function is called with the first parameter (\c{ctx})
-equal to \c{rctx}, and should attempt to read \c{len} bytes of data
-into the buffer pointed to by \c{buf}. It should return \cw{false}
-on failure or \cw{true} on success. It should not report success
-unless it has filled the entire buffer; on platforms which might be
-reading from a pipe or other blocking data source, \c{read} is
-responsible for looping until the whole buffer has been filled.
-
-If the de-serialisation operation is successful, the mid-end's
-internal data structures will be replaced by the results of the
-load, and \cw{NULL} will be returned. Otherwise, the mid-end's state
-will be completely unchanged and an error message (typically some
-variation on \q{save file is corrupt}) will be returned. As usual,
-the error message string is not dynamically allocated.
-
-If this function succeeds, it is likely that the game parameters
-will have been changed. The front end should therefore probably
-re-think the window size using \cw{midend_size()}, and probably
-cause a refresh using \cw{midend_redraw()}.
-
-Because each mid-end is tied to a specific game back end, this
-function will fail if you attempt to read in a save file generated by
-a different game from the one configured in this mid-end, even if your
-application is a monolithic one containing all the puzzles. See
-\k{identify-game} for a helper function which will allow you to
-identify a save file before you instantiate your mid-end in the first
-place.
-
-\H{midend-save-prefs} \cw{midend_save_prefs()}
-
-\c void midend_save_prefs(
-\c     midend *me, void (*write)(void *ctx, const void *buf, int len),
-\c     void *wctx);
-
-Calling this function causes the mid-end to write out the states of
-all user-settable preference options, including its own cross-platform
-preferences and ones exported by a particular game via
-\cw{get_prefs()} and \cw{set_prefs()} (\k{backend-get-prefs},
-\k{backend-set-prefs}). The output is a textual format suitable for
-writing into a configuration file on disk.
-
-The \c{write} and \c{wctx} parameters have the same semantics as for
-\cw{midend_serialise()} (\k{midend-serialise}).
-
-\H{midend-load-prefs} \cw{midend_load_prefs()}
-
-\c const char *midend_load_prefs(
-\c     midend *me, bool (*read)(void *ctx, void *buf, int len),
-\c     void *rctx);
-
-This function is used to load a configuration file in the same format
-emitted by \cw{midend_save_prefs()}, and import all the preferences
-described in the file into the current mid-end.
-
-\H{identify-game} \cw{identify_game()}
-
-\c const char *identify_game(char **name,
-\c     bool (*read)(void *ctx, void *buf, int len), void *rctx);
-
-This function examines a serialised midend stream, of the same kind
-used by \cw{midend_serialise()} and \cw{midend_deserialise()}, and
-returns the \cw{name} field of the game back end from which it was
-saved.
-
-You might want this if your front end was a monolithic one containing
-all the puzzles, and you wanted to be able to load an arbitrary save
-file and automatically switch to the right game. Probably your next
-step would be to iterate through \cw{gamelist} (\k{frontend-backend})
-looking for a game structure whose \cw{name} field matched the
-returned string, and give an error if you didn't find one.
-
-On success, the return value of this function is \cw{NULL}, and the
-game name string is written into \cw{*name}. The caller should free
-that string after using it.
-
-On failure, \cw{*name} is \cw{NULL}, and the return value is an error
-message (which does not need freeing at all).
-
-(This isn't strictly speaking a midend function, since it doesn't
-accept or return a pointer to a midend. You'd probably call it just
-\e{before} deciding what kind of midend you wanted to instantiate.)
-
-\H{midend-request-id-changes} \cw{midend_request_id_changes()}
-
-\c void midend_request_id_changes(midend *me,
-\c                                void (*notify)(void *), void *ctx);
-
-This function is called by the front end to request notification by
-the mid-end when the current game IDs (either descriptive or
-random-seed) change. This can occur as a result of keypresses ('n' for
-New Game, for example) or when a puzzle supersedes its game
-description (see \k{backend-supersede}). After this function is
-called, any change of the game ids will cause the mid-end to call
-\cw{notify(ctx)} after the change.
-
-This is for use by puzzles which want to present the game description
-to the user constantly (e.g. as an HTML hyperlink) instead of only
-showing it when the user explicitly requests it.
-
-This is a function I anticipate few front ends needing to implement,
-so I make it a callback rather than a static function in order to
-relieve most front ends of the need to provide an empty
-implementation.
-
-\H{midend-which-game} \cw{midend_which_game()}
-
-\c const game *midend_which_preset(midend *me);
-
-This function returns the \c{game} structure for the puzzle type this
-midend is committed to.
-
-\H{frontend-backend} Direct reference to the back end structure by
-the front end
-
-Although \e{most} things the front end needs done should be done by
-calling the mid-end, there are a few situations in which the front
-end needs to refer directly to the game back end structure.
-
-The most obvious of these is
-
-\b passing the game back end as a parameter to \cw{midend_new()}.
-
-There are a few other back end features which are not wrapped by the
-mid-end because there didn't seem much point in doing so:
-
-\b fetching the \c{name} field to use in window titles and similar
-
-\b reading the \c{can_configure}, \c{can_solve} and
-\c{can_format_as_text_ever} fields to decide whether to add those
-items to the menu bar or equivalent
-
-\b reading the \c{winhelp_topic} field (Windows only)
-
-\b the GTK front end provides a \cq{--generate} command-line option
-which directly calls the back end to do most of its work. This is
-not really part of the main front end code, though, and I'm not sure
-it counts.
-
-In order to find the game back end structure, the front end does one
-of two things:
-
-\b If the particular front end is compiling a separate binary per
-game, then the back end structure is a global variable with the
-standard name \cq{thegame}:
-
-\lcont{
-
-\c extern const game thegame;
-
-}
-
-\b If the front end is compiled as a monolithic application
-containing all the puzzles together (in which case the preprocessor
-symbol \cw{COMBINED} must be defined when compiling most of the code
-base), then there will be two global variables defined:
-
-\lcont{
-
-\c extern const game *gamelist[];
-\c extern const int gamecount;
-
-\c{gamelist} will be an array of \c{gamecount} game structures,
-declared in the automatically constructed source module \c{list.c}.
-The application should search that array for the game it wants,
-probably by reaching into each game structure and looking at its
-\c{name} field.
-
-}
-
-\H{frontend-api} Mid-end to front-end calls
-
-This section describes the small number of functions which a front
-end must provide to be called by the mid-end or other standard
-utility modules.
-
-\H{frontend-get-random-seed} \cw{get_random_seed()}
-
-\c void get_random_seed(void **randseed, int *randseedsize);
-
-This function is called by a new mid-end, and also occasionally by
-game back ends. Its job is to return a piece of data suitable for
-using as a seed for initialisation of a new \c{random_state}.
-
-On exit, \c{*randseed} should be set to point at a newly allocated
-piece of memory containing some seed data, and \c{*randseedsize}
-should be set to the length of that data.
-
-A simple and entirely adequate implementation is to return a piece
-of data containing the current system time at the highest
-conveniently available resolution.
-
-\H{frontend-activate-timer} \cw{activate_timer()}
-
-\c void activate_timer(frontend *fe);
-
-This is called by the mid-end to request that the front end begin
-calling it back at regular intervals.
-
-The timeout interval is left up to the front end; the finer it is,
-the smoother move animations will be, but the more CPU time will be
-used. Current front ends use values around 20ms (i.e. 50Hz).
-
-After this function is called, the mid-end will expect to receive
-calls to \cw{midend_timer()} on a regular basis.
-
-\H{frontend-deactivate-timer} \cw{deactivate_timer()}
-
-\c void deactivate_timer(frontend *fe);
-
-This is called by the mid-end to request that the front end stop
-calling \cw{midend_timer()}.
-
-\H{frontend-fatal} \cw{fatal()}
-
-\c void fatal(const char *fmt, ...);
-
-This is called by some utility functions if they encounter a
-genuinely fatal error such as running out of memory. It is a
-variadic function in the style of \cw{printf()}, and is expected to
-show the formatted error message to the user any way it can and then
-terminate the application. It must not return.
-
-\H{frontend-default-colour} \cw{frontend_default_colour()}
-
-\c void frontend_default_colour(frontend *fe, float *output);
-
-This function expects to be passed a pointer to an array of three
-\cw{float}s. It returns the platform's local preferred background
-colour in those three floats, as red, green and blue values (in that
-order) ranging from \cw{0.0} to \cw{1.0}.
-
-This function should only ever be called by the back end function
-\cw{colours()} (\k{backend-colours}). (Thus, it isn't a
-\e{midend}-to-frontend function as such, but there didn't seem to be
-anywhere else particularly good to put it. Sorry.)
-
-\C{utils} Utility APIs
-
-This chapter documents a variety of utility APIs provided for the
-general use of the rest of the Puzzles code.
-
-\H{utils-random} Random number generation
-
-Platforms' local random number generators vary widely in quality and
-seed size. Puzzles therefore supplies its own high-quality random
-number generator, with the additional advantage of giving the same
-results if fed the same seed data on different platforms. This
-allows game random seeds to be exchanged between different ports of
-Puzzles and still generate the same games.
-
-Unlike the ANSI C \cw{rand()} function, the Puzzles random number
-generator has an \e{explicit} state object called a
-\c{random_state}. One of these is managed by each mid-end, for
-example, and passed to the back end to generate a game with.
-
-\S{utils-random-init} \cw{random_new()}
-
-\c random_state *random_new(char *seed, int len);
-
-Allocates, initialises and returns a new \c{random_state}. The input
-data is used as the seed for the random number stream (i.e. using
-the same seed at a later time will generate the same stream).
-
-The seed data can be any data at all; there is no requirement to use
-printable ASCII, or NUL-terminated strings, or anything like that.
-
-\S{utils-random-copy} \cw{random_copy()}
-
-\c random_state *random_copy(random_state *tocopy);
-
-Allocates a new \c{random_state}, copies the contents of another
-\c{random_state} into it, and returns the new state.  If exactly the
-same sequence of functions is subsequently called on both the copy and
-the original, the results will be identical.  This may be useful for
-speculatively performing some operation using a given random state,
-and later replaying that operation precisely.
-
-\S{utils-random-free} \cw{random_free()}
-
-\c void random_free(random_state *state);
-
-Frees a \c{random_state}.
-
-\S{utils-random-bits} \cw{random_bits()}
-
-\c unsigned long random_bits(random_state *state, int bits);
-
-Returns a random number from 0 to \cw{2^bits-1} inclusive. \c{bits}
-should be between 1 and 32 inclusive.
-
-\S{utils-random-upto} \cw{random_upto()}
-
-\c unsigned long random_upto(random_state *state, unsigned long limit);
-
-Returns a random number from 0 to \cw{limit-1} inclusive. \c{limit}
-may not be zero.
-
-\S{utils-random-state-encode} \cw{random_state_encode()}
-
-\c char *random_state_encode(random_state *state);
-
-Encodes the entire contents of a \c{random_state} in printable
-ASCII. Returns a dynamically allocated string containing that
-encoding. This can subsequently be passed to
-\cw{random_state_decode()} to reconstruct the same \c{random_state}.
-
-\S{utils-random-state-decode} \cw{random_state_decode()}
-
-\c random_state *random_state_decode(char *input);
-
-Decodes a string generated by \cw{random_state_encode()} and
-reconstructs an equivalent \c{random_state} to the one encoded, i.e.
-it should produce the same stream of random numbers.
-
-This function has no error reporting; if you pass it an invalid
-string it will simply generate an arbitrary random state, which may
-turn out to be noticeably non-random.
-
-\S{utils-shuffle} \cw{shuffle()}
-
-\c void shuffle(void *array, int nelts, int eltsize, random_state *rs);
-
-Shuffles an array into a random order. The interface is much like
-ANSI C \cw{qsort()}, except that there's no need for a compare
-function.
-
-\c{array} is a pointer to the first element of the array. \c{nelts}
-is the number of elements in the array; \c{eltsize} is the size of a
-single element (typically measured using \c{sizeof}). \c{rs} is a
-\c{random_state} used to generate all the random numbers for the
-shuffling process.
-
-\H{utils-presets} Presets menu management
-
-The function \c{midend_get_presets()} (\k{midend-get-presets}) returns
-a data structure describing a menu hierarchy. Back ends can also
-choose to provide such a structure to the mid-end, if they want to
-group their presets hierarchically. To make this easy, there are a few
-utility functions to construct preset menu structures, and also one
-intended for front-end use.
-
-\S{utils-preset-menu-new} \cw{preset_menu_new()}
-
-\c struct preset_menu *preset_menu_new(void);
-
-Allocates a new \c{struct preset_menu}, and initialises it to hold no
-menu items.
-
-\S{utils-preset-menu-add_submenu} \cw{preset_menu_add_submenu()}
-
-\c struct preset_menu *preset_menu_add_submenu
-\c     (struct preset_menu *parent, char *title);
-
-Adds a new submenu to the end of an existing preset menu, and returns
-a pointer to a newly allocated \c{struct preset_menu} describing the
-submenu.
-
-The string parameter \cq{title} must be dynamically allocated by the
-caller. The preset-menu structure will take ownership of it, so the
-caller must not free it.
-
-\S{utils-preset-menu-add-preset} \cw{preset_menu_add_preset()}
-
-\c void preset_menu_add_preset
-\c     (struct preset_menu *menu, char *title, game_params *params);
-
-Adds a preset game configuration to the end of a preset menu.
-
-Both the string parameter \cq{title} and the game parameter structure
-\cq{params} itself must be dynamically allocated by the caller. The
-preset-menu structure will take ownership of it, so the caller must
-not free it.
-
-\S{utils-preset-menu-lookup-by-id} \cw{preset_menu_lookup_by_id()}
-
-\c game_params *preset_menu_lookup_by_id
-\c     (struct preset_menu *menu, int id);
-
-Given a numeric index, searches recursively through a preset menu
-hierarchy to find the corresponding menu entry, and returns a pointer
-to its existing \c{game_params} structure.
-
-This function is intended for front end use (but front ends need not
-use it if they prefer to do things another way). If a front end finds
-it inconvenient to store anything more than a numeric index alongside
-each menu item, then this function provides an easy way for the front
-end to get back the actual game parameters corresponding to a menu
-item that the user has selected.
-
-\H{utils-alloc} Memory allocation
-
-Puzzles has some central wrappers on the standard memory allocation
-functions, which provide compile-time type checking, and run-time
-error checking by means of quitting the application if it runs out
-of memory. This doesn't provide the best possible recovery from
-memory shortage, but on the other hand it greatly simplifies the
-rest of the code, because nothing else anywhere needs to worry about
-\cw{NULL} returns from allocation.
-
-\S{utils-snew} \cw{snew()}
-
-\c var = snew(type);
-\e iii        iiii
-
-This macro takes a single argument which is a \e{type name}. It
-allocates space for one object of that type. If allocation fails it
-will call \cw{fatal()} and not return; so if it does return, you can
-be confident that its return value is non-\cw{NULL}.
-
-The return value is cast to the specified type, so that the compiler
-will type-check it against the variable you assign it into. Thus,
-this ensures you don't accidentally allocate memory the size of the
-wrong type and assign it into a variable of the right one (or vice
-versa!).
-
-\S{utils-snewn} \cw{snewn()}
-
-\c var = snewn(n, type);
-\e iii         i  iiii
-
-This macro is the array form of \cw{snew()}. It takes two arguments;
-the first is a number, and the second is a type name. It allocates
-space for that many objects of that type, and returns a type-checked
-non-\cw{NULL} pointer just as \cw{snew()} does.
-
-\S{utils-sresize} \cw{sresize()}
-
-\c var = sresize(var, n, type);
-\e iii           iii  i  iiii
-
-This macro is a type-checked form of \cw{realloc()}. It takes three
-arguments: an input memory block, a new size in elements, and a
-type. It re-sizes the input memory block to a size sufficient to
-contain that many elements of that type. It returns a type-checked
-non-\cw{NULL} pointer, like \cw{snew()} and \cw{snewn()}.
-
-The input memory block can be \cw{NULL}, in which case this function
-will behave exactly like \cw{snewn()}. (In principle any
-ANSI-compliant \cw{realloc()} implementation ought to cope with
-this, but I've never quite trusted it to work everywhere.)
-
-\S{utils-sfree} \cw{sfree()}
-
-\c void sfree(void *p);
-
-This function is pretty much equivalent to \cw{free()}. It is
-provided with a dynamically allocated block, and frees it.
-
-The input memory block can be \cw{NULL}, in which case this function
-will do nothing. (In principle any ANSI-compliant \cw{free()}
-implementation ought to cope with this, but I've never quite trusted
-it to work everywhere.)
-
-\S{utils-dupstr} \cw{dupstr()}
-
-\c char *dupstr(const char *s);
-
-This function dynamically allocates a duplicate of a C string. Like
-the \cw{snew()} functions, it guarantees to return non-\cw{NULL} or
-not return at all.
-
-(Many platforms provide the function \cw{strdup()}. As well as
-guaranteeing never to return \cw{NULL}, my version has the advantage
-of being defined \e{everywhere}, rather than inconveniently not
-quite everywhere.)
-
-\S{utils-free-cfg} \cw{free_cfg()}
-
-\c void free_cfg(config_item *cfg);
-
-This function correctly frees an array of \c{config_item}s, including
-walking the array until it gets to the end and freeing any subsidiary
-data items in each \c{u} sub-union which are expected to be
-dynamically allocated.
-
-(See \k{backend-configure} for details of the \c{config_item}
-structure.)
-
-\S{utils-free-keys} \cw{free_keys()}
-
-\c void free_keys(key_label *keys, int nkeys);
-
-This function correctly frees an array of \c{key_label}s, including
-the dynamically allocated label string for each key.
-
-(See \k{backend-request-keys} for details of the \c{key_label}
-structure.)
-
-\H{utils-tree234} Sorted and counted tree functions
-
-Many games require complex algorithms for generating random puzzles,
-and some require moderately complex algorithms even during play. A
-common requirement during these algorithms is for a means of
-maintaining sorted or unsorted lists of items, such that items can
-be removed and added conveniently.
-
-For general use, Puzzles provides the following set of functions
-which maintain 2-3-4 trees in memory. (A 2-3-4 tree is a balanced
-tree structure, with the property that all lookups, insertions,
-deletions, splits and joins can be done in \cw{O(log N)} time.)
-
-All these functions expect you to be storing a tree of \c{void *}
-pointers. You can put anything you like in those pointers.
-
-By the use of per-node element counts, these tree structures have
-the slightly unusual ability to look elements up by their numeric
-index within the list represented by the tree. This means that they
-can be used to store an unsorted list (in which case, every time you
-insert a new element, you must explicitly specify the position where
-you wish to insert it). They can also do numeric lookups in a sorted
-tree, which might be useful for (for example) tracking the median of
-a changing data set.
-
-As well as storing sorted lists, these functions can be used for
-storing \q{maps} (associative arrays), by defining each element of a
-tree to be a (key, value) pair.
-
-\S{utils-newtree234} \cw{newtree234()}
-
-\c tree234 *newtree234(cmpfn234 cmp);
-
-Creates a new empty tree, and returns a pointer to it.
-
-The parameter \c{cmp} determines the sorting criterion on the tree.
-Its prototype is
-
-\c typedef int (*cmpfn234)(void *, void *);
-
-If you want a sorted tree, you should provide a function matching
-this prototype, which returns like \cw{strcmp()} does (negative if
-the first argument is smaller than the second, positive if it is
-bigger, zero if they compare equal). In this case, the function
-\cw{addpos234()} will not be usable on your tree (because all
-insertions must respect the sorting order).
-
-If you want an unsorted tree, pass \cw{NULL}. In this case you will
-not be able to use either \cw{add234()} or \cw{del234()}, or any
-other function such as \cw{find234()} which depends on a sorting
-order. Your tree will become something more like an array, except
-that it will efficiently support insertion and deletion as well as
-lookups by numeric index.
-
-\S{utils-freetree234} \cw{freetree234()}
-
-\c void freetree234(tree234 *t);
-
-Frees a tree. This function will not free the \e{elements} of the
-tree (because they might not be dynamically allocated, or you might
-be storing the same set of elements in more than one tree); it will
-just free the tree structure itself. If you want to free all the
-elements of a tree, you should empty it before passing it to
-\cw{freetree234()}, by means of code along the lines of
-
-\c while ((element = delpos234(tree, 0)) != NULL)
-\c     sfree(element); /* or some more complicated free function */
-\e                     iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
-
-\S{utils-add234} \cw{add234()}
-
-\c void *add234(tree234 *t, void *e);
-
-Inserts a new element \c{e} into the tree \c{t}. This function
-expects the tree to be sorted; the new element is inserted according
-to the sort order.
-
-If an element comparing equal to \c{e} is already in the tree, then
-the insertion will fail, and the return value will be the existing
-element. Otherwise, the insertion succeeds, and \c{e} is returned.
-
-\S{utils-addpos234} \cw{addpos234()}
-
-\c void *addpos234(tree234 *t, void *e, int index);
-
-Inserts a new element into an unsorted tree. Since there is no
-sorting order to dictate where the new element goes, you must
-specify where you want it to go. Setting \c{index} to zero puts the
-new element right at the start of the list; setting \c{index} to the
-current number of elements in the tree puts the new element at the
-end.
-
-Return value is \c{e}, in line with \cw{add234()} (although this
-function cannot fail except by running out of memory, in which case
-it will bomb out and die rather than returning an error indication).
-
-\S{utils-index234} \cw{index234()}
-
-\c void *index234(tree234 *t, int index);
-
-Returns a pointer to the \c{index}th element of the tree, or
-\cw{NULL} if \c{index} is out of range. Elements of the tree are
-numbered from zero.
-
-\S{utils-find234} \cw{find234()}
-
-\c void *find234(tree234 *t, void *e, cmpfn234 cmp);
-
-Searches for an element comparing equal to \c{e} in a sorted tree.
-
-If \c{cmp} is \cw{NULL}, the tree's ordinary comparison function
-will be used to perform the search. However, sometimes you don't
-want that; suppose, for example, each of your elements is a big
-structure containing a \c{char *} name field, and you want to find
-the element with a given name. You \e{could} achieve this by
-constructing a fake element structure, setting its name field
-appropriately, and passing it to \cw{find234()}, but you might find
-it more convenient to pass \e{just} a name string to \cw{find234()},
-supplying an alternative comparison function which expects one of
-its arguments to be a bare name and the other to be a large
-structure containing a name field.
-
-Therefore, if \c{cmp} is not \cw{NULL}, then it will be used to
-compare \c{e} to elements of the tree. The first argument passed to
-\c{cmp} will always be \c{e}; the second will be an element of the
-tree.
-
-(See \k{utils-newtree234} for the definition of the \c{cmpfn234}
-function pointer type.)
-
-The returned value is the element found, or \cw{NULL} if the search
-is unsuccessful.
-
-\S{utils-findrel234} \cw{findrel234()}
-
-\c void *findrel234(tree234 *t, void *e, cmpfn234 cmp, int relation);
-
-This function is like \cw{find234()}, but has the additional ability
-to do a \e{relative} search. The additional parameter \c{relation}
-can be one of the following values:
-
-\dt \cw{REL234_EQ}
-
-\dd Find only an element that compares equal to \c{e}. This is
-exactly the behaviour of \cw{find234()}.
-
-\dt \cw{REL234_LT}
-
-\dd Find the greatest element that compares strictly less than
-\c{e}. \c{e} may be \cw{NULL}, in which case it finds the greatest
-element in the whole tree (which could also be done by
-\cw{index234(t, count234(t)-1)}).
-
-\dt \cw{REL234_LE}
-
-\dd Find the greatest element that compares less than or equal to
-\c{e}. (That is, find an element that compares equal to \c{e} if
-possible, but failing that settle for something just less than it.)
-
-\dt \cw{REL234_GT}
-
-\dd Find the smallest element that compares strictly greater than
-\c{e}. \c{e} may be \cw{NULL}, in which case it finds the smallest
-element in the whole tree (which could also be done by
-\cw{index234(t, 0)}).
-
-\dt \cw{REL234_GE}
-
-\dd Find the smallest element that compares greater than or equal to
-\c{e}. (That is, find an element that compares equal to \c{e} if
-possible, but failing that settle for something just bigger than
-it.)
-
-Return value, as before, is the element found or \cw{NULL} if no
-element satisfied the search criterion.
-
-\S{utils-findpos234} \cw{findpos234()}
-
-\c void *findpos234(tree234 *t, void *e, cmpfn234 cmp, int *index);
-
-This function is like \cw{find234()}, but has the additional feature
-of returning the index of the element found in the tree; that index
-is written to \c{*index} in the event of a successful search (a
-non-\cw{NULL} return value).
-
-\c{index} may be \cw{NULL}, in which case this function behaves
-exactly like \cw{find234()}.
-
-\S{utils-findrelpos234} \cw{findrelpos234()}
-
-\c void *findrelpos234(tree234 *t, void *e, cmpfn234 cmp, int relation,
-\c                     int *index);
-
-This function combines all the features of \cw{findrel234()} and
-\cw{findpos234()}.
-
-\S{utils-del234} \cw{del234()}
-
-\c void *del234(tree234 *t, void *e);
-
-Finds an element comparing equal to \c{e} in the tree, deletes it,
-and returns it.
-
-The input tree must be sorted.
-
-The element found might be \c{e} itself, or might merely compare
-equal to it.
-
-Return value is \cw{NULL} if no such element is found.
-
-\S{utils-delpos234} \cw{delpos234()}
-
-\c void *delpos234(tree234 *t, int index);
-
-Deletes the element at position \c{index} in the tree, and returns
-it.
-
-Return value is \cw{NULL} if the index is out of range.
-
-\S{utils-count234} \cw{count234()}
-
-\c int count234(tree234 *t);
-
-Returns the number of elements currently in the tree.
-
-\S{utils-splitpos234} \cw{splitpos234()}
-
-\c tree234 *splitpos234(tree234 *t, int index, bool before);
-
-Splits the input tree into two pieces at a given position, and
-creates a new tree containing all the elements on one side of that
-position.
-
-If \c{before} is \cw{true}, then all the items at or after position
-\c{index} are left in the input tree, and the items before that
-point are returned in the new tree. Otherwise, the reverse happens:
-all the items at or after \c{index} are moved into the new tree, and
-those before that point are left in the old one.
-
-If \c{index} is equal to 0 or to the number of elements in the input
-tree, then one of the two trees will end up empty (and this is not
-an error condition). If \c{index} is further out of range in either
-direction, the operation will fail completely and return \cw{NULL}.
-
-This operation completes in \cw{O(log N)} time, no matter how large
-the tree or how balanced or unbalanced the split.
-
-\S{utils-split234} \cw{split234()}
-
-\c tree234 *split234(tree234 *t, void *e, cmpfn234 cmp, int rel);
-
-Splits a sorted tree according to its sort order.
-
-\c{rel} can be any of the relation constants described in
-\k{utils-findrel234}, \e{except} for \cw{REL234_EQ}. All the
-elements having that relation to \c{e} will be transferred into the
-new tree; the rest will be left in the old one.
-
-The parameter \c{cmp} has the same semantics as it does in
-\cw{find234()}: if it is not \cw{NULL}, it will be used in place of
-the tree's own comparison function when comparing elements to \c{e},
-in such a way that \c{e} itself is always the first of its two
-operands.
-
-Again, this operation completes in \cw{O(log N)} time, no matter how
-large the tree or how balanced or unbalanced the split.
-
-\S{utils-join234} \cw{join234()}
-
-\c tree234 *join234(tree234 *t1, tree234 *t2);
-
-Joins two trees together by concatenating the lists they represent.
-All the elements of \c{t2} are moved into \c{t1}, in such a way that
-they appear \e{after} the elements of \c{t1}. The tree \c{t2} is
-freed; the return value is \c{t1}.
-
-If you apply this function to a sorted tree and it violates the sort
-order (i.e. the smallest element in \c{t2} is smaller than or equal
-to the largest element in \c{t1}), the operation will fail and
-return \cw{NULL}.
-
-This operation completes in \cw{O(log N)} time, no matter how large
-the trees being joined together.
-
-\S{utils-join234r} \cw{join234r()}
-
-\c tree234 *join234r(tree234 *t1, tree234 *t2);
-
-Joins two trees together in exactly the same way as \cw{join234()},
-but this time the combined tree is returned in \c{t2}, and \c{t1} is
-destroyed. The elements in \c{t1} still appear before those in
-\c{t2}.
-
-Again, this operation completes in \cw{O(log N)} time, no matter how
-large the trees being joined together.
-
-\S{utils-copytree234} \cw{copytree234()}
-
-\c tree234 *copytree234(tree234 *t, copyfn234 copyfn,
-\c                      void *copyfnstate);
-
-Makes a copy of an entire tree.
-
-If \c{copyfn} is \cw{NULL}, the tree will be copied but the elements
-will not be; i.e. the new tree will contain pointers to exactly the
-same physical elements as the old one.
-
-If you want to copy each actual element during the operation, you
-can instead pass a function in \c{copyfn} which makes a copy of each
-element. That function has the prototype
-
-\c typedef void *(*copyfn234)(void *state, void *element);
-
-and every time it is called, the \c{state} parameter will be set to
-the value you passed in as \c{copyfnstate}.
-
-\H{utils-dsf} Disjoint set forests
-
-This section describes a set of functions implementing the data
-structure variously known as \q{union-find} or \q{Tarjan's disjoint
-set forest}. In this code base, it's universally abbreviated as a
-\q{dsf}.
-
-A dsf represents a collection of elements partitioned into
-\q{equivalence classes}, in circumstances where equivalences are added
-incrementally. That is, all elements start off considered to be
-different, and you gradually declare more and more of them to be equal
-via the \cw{dsf_merge()} operation, which says that two particular
-elements should be regarded as equal from now on.
-
-For example, if I start off with A,B,U,V all distinct, and I merge A
-with B and merge U with V, then the structure will tell me that A and
-U are not equivalent. But if I then merge B with V, then after that,
-the structure will tell me that A and U \e{are} equivalent, by
-following the transitive chain of equivalences it knows about.
-
-The dsf data structure is therefore ideal for tracking incremental
-connectivity in an undirected graph (again, \q{incremental} meaning
-that you only ever add edges, never delete them), and other
-applications in which you gradually acquire knowledge you didn't
-previously have about what things are the same as each other. It's
-used extensively in puzzle solver and generator algorithms, and
-sometimes during gameplay as well.
-
-The time complexity of dsf operations is not \e{quite} constant time,
-in theory, but it's so close to it as to make no difference in
-practice. In particular, any time a dsf has to do non-trivial work, it
-updates the structure so that that work won't be needed a second time.
-Use dsf operations without worrying about how long they take!
-
-For some puzzle-game applications, it's useful to augment this data
-structure with extra information about how the elements of an
-equivalence class relate to each other. There's more than one way you
-might do this; the one supported here is useful in cases where the
-objects you're tracking are going to end up in one of two states (say,
-black/white, or on/off), and for any two objects you either know that
-they're in the same one of those states, or you know they're in
-opposite states, or you don't know which yet. Puzzles calls this a
-\q{flip dsf}: it tracks whether objects in the same equivalence class
-are flipped relative to each other.
-
-As well as querying whether two elements are equivalent, this dsf
-implementation also allows you to ask for the number of elements in a
-given equivalence class, and the smallest element in the class. (The
-latter is used, for example, to decide which square to print the clue
-in each region of a Keen puzzle.)
-
-\S{utils-dsf-new} \cw{dsf_new()}, \cw{dsf_new_flip()}, \cw{dsf_new_min()}
-
-\c DSF *dsf_new(int size);
-\c DSF *dsf_new_flip(int size);
-\c DSF *dsf_new_min(int size);
-
-Each of these functions allocates space for a dsf describing \c{size}
-elements, and initialises it so that every element is in an
-equivalence class by itself.
-
-The elements described by the dsf are represented by the integers from
-\cw{0} to \cw{size-1} inclusive.
-
-\cw{dsf_new_flip()} will create a dsf which has the extra ability to
-track whether objects in the same equivalence class are flipped
-relative to each other.
-
-\cw{dsf_new_min()} will create a dsf which has the extra ability to
-track the smallest element of each equivalence class.
-
-The returned object from any of these functions must be freed using
-\cw{dsf_free()}.
-
-\S{utils-dsf-free} \cw{dsf_free()}
-
-\c void dsf_free(DSF *dsf);
-
-Frees a dsf allocated by any of the \cw{dsf_new()} functions.
-
-\S{utils-dsf-reinit} \cw{dsf_reinit()}
-
-\c void dsf_reinit(DSF *dsf);
-
-Reinitialises an existing dsf to the state in which all elements are
-distinct, without having to free and reallocate it.
-
-\S{utils-dsf-copy} \cw{dsf_copy()}
-
-\c void dsf_copy(DSF *to, DSF *from);
-
-Copies the contents of one dsf over the top of another. Everything
-previously stored in \c{to} is overwritten.
-
-The two dsfs must have been created with the same size, and the
-destination dsf may not have any extra information that the source dsf
-does not have.
-
-\S{utils-dsf-merge} \cw{dsf_merge()}
-
-\c void dsf_merge(DSF *dsf, int v1, int v2);
-
-Updates a dsf so that elements \c{v1} and \c{v2} will now be
-considered to be in the same equivalence class. If they were already
-in the same class, this function will safely do nothing.
-
-This function may not be called on a flip dsf. Use \cw{dsf_merge_flip}
-instead.
-
-\S{utils-dsf-canonify} \cw{dsf_canonify()}
-
-\c int dsf_canonify(DSF *dsf, int val);
-
-Returns the \q{canonical} element of the equivalence class in the dsf
-containing \c{val}. This will be some element of the same equivalence
-class. So in order to determine whether two elements are in the same
-equivalence class, you can call \cw{dsf_canonify} on both of them, and
-compare the results.
-
-Canonical elements don't necessarily stay the same if the dsf is
-mutated via \c{dsf_merge}. But between two calls to \c{dsf_merge},
-they stay the same.
-
-\S{utils-dsf-size} \cw{dsf_size()}
-
-\c int dsf_size(DSF *dsf, int val);
-
-Returns the number of elements currently in the equivalence class
-containing \c{val}.
-
-\c{val} itself counts, so in a newly created dsf, the return value
-will be 1.
-
-\S{utils-dsf-merge-flip} \cw{dsf_merge_flip()}
-
-\c void edsf_merge(DSF *dsf, int v1, int v2, bool flip);
-
-Updates a flip dsf so that elements \c{v1} and \c{v2} are in the same
-equivalence class. If \c{flip} is \cw{false}, they will be regarded as
-in the same state as each other; if \c{flip} is \cw{true} then they
-will be regarded as being in opposite states.
-
-If \c{v1} and \c{v2} were already in the same equivalence class, then
-the new value of \c{flip} will be checked against what the edsf
-previously believed, and an assertion failure will occur if you
-contradict that.
-
-For example, if you start from a blank flip dsf and do this:
-
-\c dsf_merge_flip(dsf, 0, 1, false);
-\c dsf_merge_flip(dsf, 1, 2, true);
-
-then it will create a dsf in which elements 0,1,2 are all in the same
-class, with 0,1 in the same state as each other and 2 in the opposite
-state from both. And then this call will do nothing, because it agrees
-with what the dsf already knew:
-
-\c dsf_merge_flip(dsf, 0, 2, true);
-
-But this call will fail an assertion:
-
-\c dsf_merge_flip(dsf, 0, 2, false);
-
-\S{utils-dsf-canonify-flip} \cw{dsf_canonify_flip()}
-
-\c int dsf_canonify_flip(DSF *dsf, int val, bool *inverse);
-
-Like \c{dsf_canonify()}, this returns the canonical element of the
-equivalence class of a dsf containing \c{val}.
-
-However, it may only be called on a flip dsf, and it also fills in
-\c{*flip} with a flag indicating whether \c{val} and the canonical
-element are in opposite states: \cw{true} if they are in opposite
-states, or \cw{false} if they're in the same state.
-
-So if you want to know the relationship between \c{v1} and \c{v2}, you
-can do this:
-
-\c bool inv1, inv2;
-\c int canon1 = dsf_canonify_flip(dsf, v1, &inv1);
-\c int canon2 = dsf_canonify_flip(dsf, v2, &inv2);
-\c if (canon1 != canon2) {
-\c     // v1 and v2 have no known relation
-\c } else if (inv1 == inv2) {
-\c     // v1 and v2 are known to be in the same state as each other
-\c } else {
-\c     // v1 and v2 are known to be in opposite states
-\c }
-
-\S{utils-dsf-minimal} \cw{dsf_minimal()}
-
-\c int dsf_minimal(DSF *dsf, int val);
-
-Returns the smallest element of the equivalence class in the dsf
-containing \c{val}.
-
-For this function to work, the dsf must have been created using
-\cw{dsf_new_min()}.
-
-\H{utils-tdq} To-do queues
-
-This section describes a set of functions implementing a \q{to-do
-queue}, a simple de-duplicating to-do list mechanism. The code calls
-this a \q{tdq}.
-
-A tdq can store integers up to a given size (specified at creation
-time). But it can't store the same integer more than once. So you can
-quickly \e{make sure} an integer is in the queue (which will do
-nothing if it's already there), and you can quickly pop an integer
-from the queue and return it, both in constant time.
-
-The idea is that you might use this in a game solver, in the kind of
-game where updating your knowledge about one square of a grid means
-there's a specific other set of squares (such as its neighbours) where
-it's now worth attempting further deductions. So you keep a tdq of all
-the grid squares you plan to look at next, and every time you make a
-deduction in one square, you add the neighbouring squares to the tdq
-to make sure they get looked at again after that.
-
-In solvers where deductions are mostly localised, this avoids the
-slowdown of having to find the next thing to do every time by looping
-over the whole grid: instead, you can keep checking the tdq for
-\e{specific} squares to look at, until you run out.
-
-However, it's common to have games in which \e{most} deductions are
-localised, but not all. In that situation, when your tdq is empty, you
-can re-fill it with every square in the grid using \cw{tdq_fill()},
-which will force an iteration over everything again. And then if the
-tdq becomes empty \e{again} without you having made any progress, give
-up.
-
-\S{utils-tdq-new} \cw{tdq_new()}
-
-\c tdq *tdq_new(int n);
-
-Allocates space for a tdq that tracks items from \cw{0} to \cw{size-1}
-inclusive.
-
-\S{utils-tdq-free} \cw{tdq_free()}
-
-\c void tdq_free(tdq *tdq);
-
-Frees a tdq.
-
-\S{utils-tdq-add} \cw{tdq_add()}
-
-\c void tdq_add(tdq *tdq, int k);
-
-Adds the value \c{k} to a tdq. If \c{k} was already in the to-do list,
-does nothing.
-
-\S{utils-tdq-remove} \cw{tdq_remove()}
-
-\c int tdq_remove(tdq *tdq);
-
-Removes one item from the tdq, and returns it. If the tdq is empty,
-returns \cw{-1}.
-
-\S{utils-tdq-fill} \cw{tdq_fill()}
-
-\c void tdq_fill(tdq *tdq);
-
-Fills a tdq with every element it can possibly keep track of.
-
-\H{utils-findloop} Finding loops in graphs and grids
-
-Many puzzles played on grids or graphs have a common gameplay element
-of connecting things together into paths in such a way that you need
-to avoid making loops (or, perhaps, making the \e{wrong} kind of
-loop).
-
-Just determining \e{whether} a loop exists in a graph is easy, using a
-dsf tracking connectivity between the vertices. Simply iterate over
-each edge of the graph, merging the two vertices at each end of the
-edge \dash but before you do that, check whether those vertices are
-\e{already} known to be connected to each other, and if they are, then
-the new edge is about to complete a loop.
-
-But if you also want to identify \e{exactly} the set of edges that are
-part of any loop, e.g. to highlight the whole loop red during
-gameplay, then that's a harder problem. This API is provided here for
-all puzzles to use for that purpose.
-
-\S{utils-findloop-new-state} \cw{findloop_new_state()}
-
-\c struct findloopstate *findloop_new_state(int nvertices);
-
-Allocates a new state structure for the findloop algorithm, capable of
-handling a graph with up to \c{nvertices} vertices. The vertices will
-be represented by integers between \c{0} and \c{nvertices-1} inclusive.
-
-\S{utils-findloop-free-state} \cw{findloop_free_state()}
-
-\c void findloop_free_state(struct findloopstate *state);
-
-Frees a state structure allocated by \cw{findloop_new_state()}.
-
-\S{utils-findloop-run} \cw{findloop_run()}
-
-\c bool findloop_run(struct findloopstate *state, int nvertices,
-\c                   neighbour_fn_t neighbour, void *ctx);
-
-Runs the loop-finding algorithm, which will explore the graph and
-identify whether each edge is or is not part of any loop.
-
-The algorithm will call the provided function \c{neighbour} to list
-the neighbouring vertices of each vertex. It should have this
-prototype:
-
-\c int neighbour(int vertex, void *ctx);
-
-In this callback, \c{vertex} will be the index of a vertex when the
-algorithm \e{first} calls it for a given vertex. The function should
-return the index of one of that vertex's neighbours, or a negative
-number if there are none.
-
-If the function returned a vertex, the algorithm will then call
-\c{neighbour} again with a \e{negative} number as the \c{vertex}
-parameter, which means \q{please give me another neighbour of the same
-vertex as last time}. Again, the function should return a vertex
-index, or a negative number to indicate that there are no more
-vertices.
-
-The \c{ctx} parameter passed to \cw{findloop_run()} is passed on
-unchanged to \c{neighbour}, so you can point that at your game state
-or solver state or whatever.
-
-The return value is \cw{true} if at least one loop exists in the
-graph, and \cw{false} if no loop exists. Also, the algorithm state
-will have been filled in with information that the following query
-functions can use to ask about individual graph edges.
-
-\S{utils-findloop-is-loop-edge} \cw{findloop_is_loop_edge()}
-
-\c bool findloop_is_loop_edge(struct findloopstate *state,
-\c                            int u, int v);
-
-Queries whether the graph edge between vertices \c{u} and \c{v} is
-part of a loop. If so, the return value is \cw{true}, otherwise
-\cw{false}.
-
-\S{utils-findloop-is-bridge} \cw{findloop_is_bridge()}
-
-\c bool findloop_is_bridge(struct findloopstate *pv,
-\c     int u, int v, int *u_vertices, int *v_vertices);
-
-Queries whether the graph edge between vertices \c{u} and \c{v} is a
-\q{bridge}, i.e. an edge which would break the graph into (more)
-disconnected components if it were removed.
-
-This is the exact inverse of the \q{loop edge} criterion: a vertex
-returns \cw{true} from \cw{findloop_is_loop_edge()} if and only if it
-returns \cw{false} from \cw{findloop_is_bridge()}, and vice versa.
-
-However, \cw{findloop_is_bridge()} returns more information. If it
-returns \cw{true}, then it also fills in \c{*u_vertices} and
-\c{*v_vertices} with the number of vertices connected to the \c{u} and
-\c{v} sides of the bridge respectively.
-
-For example, if you have three vertices A,B,C all connected to each
-other, and four vertices U,V,W,X all connected to each other, and a
-single edge between A and V, then calling \cw{findloop_is_bridge()} on
-the pair A,V will return true (removing that edge would separate the
-two sets from each other), and will report that there are three
-vertices on the A side and four on the V side.
-
-\H{utils-combi} Choosing r things out of n
-
-This section describes a small API for iterating over all combinations
-of r things out of n.
-
-For example, if you asked for all combinations of 3 things out of 5,
-you'd get back the sets \{0,1,2\}, \{0,1,3\}, \{0,1,4\}, \{0,2,3\},
-\{0,2,4\}, \{0,3,4\}, \{1,2,3\}, \{1,2,4\}, \{1,3,4\}, and \{2,3,4\}.
-
-These functions use a structure called a \c{combi_ctx}, which contains
-an element \c{int *a} holding each returned combination, plus other
-fields for implementation use only.
-
-\S{utils-combi-new} \cw{new_combi()}
-
-\c combi_ctx *new_combi(int r, int n);
-
-Allocates a new \c{combi_ctx} structure for enumerating r things out
-of n.
-
-\S{utils-combi-free} \cw{free_combi()}
-
-\c void free_combi(combi_ctx *combi);
-
-Frees a \c{combi_ctx} structure.
-
-\S{utils-combi-reset} \cw{reset_combi()}
-
-\c void reset_combi(combi_ctx *combi);
-
-Resets an existing \c{combi_ctx} structure to the start of its
-iteration
-
-\S{utils-combi-next} \cw{next_combi()}
-
-\c combi_ctx *next_combi(combi_ctx *combi);
-
-Requests a combination from a \c{combi_ctx}.
-
-If there are none left to return, the return value is \cw{NULL}.
-Otherwise, it returns the input structure \c{combi}, indicating that
-it has filled in \cw{combi->a[0]}, \cw{combi->a[1]}, ...,
-\cw{combi->a[r-1]} with an increasing sequence of distinct integers
-from \cw{0} to \cw{n-1} inclusive.
-
-\H{utils-misc} Miscellaneous utility functions and macros
-
-This section contains all the utility functions which didn't
-sensibly fit anywhere else.
-
-\S{utils-maxmin} \cw{max()} and \cw{min()}
-
-The main Puzzles header file defines the pretty standard macros
-\cw{max()} and \cw{min()}, each of which is given two arguments and
-returns the one which compares greater or less respectively.
-
-These macros may evaluate their arguments multiple times. Avoid side
-effects.
-
-\S{utils-max-digits} \cw{MAX_DIGITS()}
-
-The \cw{MAX_DIGITS()} macro, defined in the main Puzzles header file,
-takes a type (or a variable of that type) and expands to an integer
-constant representing a reasonable upper bound on the number of
-characters that a number of that type could expand to when formatted
-as a decimal number using the \c{%u} or \c{%d} format of
-\cw{printf()}.  This is useful for allocating a fixed-size buffer
-that's guaranteed to be big enough to \cw{sprintf()} a value into.
-Don't forget to add one for the trailing \cw{'\\0'}!
-
-\S{utils-pi} \cw{PI}
-
-The main Puzzles header file defines a macro \cw{PI} which expands
-to a floating-point constant representing pi.
-
-(I've never understood why ANSI's \cw{<math.h>} doesn't define this.
-It'd be so useful!)
-
-\S{utils-obfuscate-bitmap} \cw{obfuscate_bitmap()}
-
-\c void obfuscate_bitmap(unsigned char *bmp, int bits, bool decode);
-
-This function obscures the contents of a piece of data, by
-cryptographic methods. It is useful for games of hidden information
-(such as Mines, Guess or Black Box), in which the game ID
-theoretically reveals all the information the player is supposed to
-be trying to guess. So in order that players should be able to send
-game IDs to one another without accidentally spoiling the resulting
-game by looking at them, these games obfuscate their game IDs using
-this function.
-
-Although the obfuscation function is cryptographic, it cannot
-properly be called encryption because it has no key. Therefore,
-anybody motivated enough can re-implement it, or hack it out of the
-Puzzles source, and strip the obfuscation off one of these game IDs
-to see what lies beneath. (Indeed, they could usually do it much
-more easily than that, by entering the game ID into their own copy
-of the puzzle and hitting Solve.) The aim is not to protect against
-a determined attacker; the aim is simply to protect people who
-wanted to play the game honestly from \e{accidentally} spoiling
-their own fun.
-
-The input argument \c{bmp} points at a piece of memory to be
-obfuscated. \c{bits} gives the length of the data. Note that that
-length is in \e{bits} rather than bytes: if you ask for obfuscation
-of a partial number of bytes, then you will get it. Bytes are
-considered to be used from the top down: thus, for example, setting
-\c{bits} to 10 will cover the whole of \cw{bmp[0]} and the \e{top
-two} bits of \cw{bmp[1]}. The remainder of a partially used byte is
-undefined (i.e. it may be corrupted by the function).
-
-The parameter \c{decode} is \cw{false} for an encoding operation,
-and \cw{true} for a decoding operation. Each is the inverse of the
-other. (There's no particular reason you shouldn't obfuscate by
-decoding and restore cleartext by encoding, if you really wanted to;
-it should still work.)
-
-The input bitmap is processed in place.
-
-\S{utils-bin2hex} \cw{bin2hex()}
-
-\c char *bin2hex(const unsigned char *in, int inlen);
-
-This function takes an input byte array and converts it into an
-ASCII string encoding those bytes in (lower-case) hex. It returns a
-dynamically allocated string containing that encoding.
-
-This function is useful for encoding the result of
-\cw{obfuscate_bitmap()} in printable ASCII for use in game IDs.
-
-\S{utils-hex2bin} \cw{hex2bin()}
-
-\c unsigned char *hex2bin(const char *in, int outlen);
-
-This function takes an ASCII string containing hex digits, and
-converts it back into a byte array of length \c{outlen}. If there
-aren't enough hex digits in the string, the contents of the
-resulting array will be undefined.
-
-This function is the inverse of \cw{bin2hex()}.
-
-\S{utils-fgetline} \cw{fgetline()}
-
-\c char *fgetline(FILE *fp);
-
-This function reads a single line of text from a standard C input
-stream, and returns it as a dynamically allocated string. The returned
-string still has a newline on the end.
-
-\S{utils-arraysort} \cw{arraysort()}
-
-Sorts an array, with slightly more flexibility than the standard C
-\cw{qsort()}.
-
-This function is really implemented as a macro, so it doesn't have a
-prototype as such. But you could imagine it having a prototype like
-this:
-
-\c void arraysort(element_t *array, size_t nmemb,
-\c                arraysort_cmpfn_t cmp, void *ctx);
-
-in which \c{element_t} is an unspecified type.
-
-(Really, there's an underlying function that takes an extra parameter
-giving the size of each array element. But callers are encouraged to
-use this macro version, which fills that in automatically using
-\c{sizeof}.)
-
-This function behaves essentially like \cw{qsort()}: it expects
-\c{array} to point to an array of \c{nmemb} elements, and it will sort
-them in place into the order specified by the comparison function
-\c{cmp}.
-
-The comparison function should have this prototype:
-
-\c int cmp(const void *a, const void *b, void *ctx);
-
-in which \c{a} and \c{b} point at the two elements to be compared, and
-the return value is negative if \cw{a<b} (that is, \c{a} should appear
-before \c{b} in the output array), positive if \cw{a>b}, or zero if
-\c{a=b}.
-
-The \c{ctx} parameter to \cw{arraysort()} is passed directly to the
-comparison function. This is the feature that makes \cw{arraysort()}
-more flexible than standard \cw{qsort()}: it lets you vary the sorting
-criterion in a dynamic manner without having to write global variables
-in the caller for the compare function to read.
-
-\S{utils-colour-mix} \cw{colour_mix()}
-
-\c void colour_mix(const float src1[3], const float src2[3], float p,
-\c                 float dst[3]);
-
-This function mixes the colours \c{src1} and \c{src2} in specified
-proportions, producing \c{dst}.  \c{p} is the proportion of \c{src2}
-in the result.  So if \c{p} is \cw{1.0}, \cw{dst} will be the same as
-\c{src2}.  If \c{p} is \cw{0.0}, \cw{dst} will be the same as
-\c{src1}.  And if \c{p} is somewhere in between, so will \c{dst} be.
-\c{p} is not restricted to the range \cw{0.0} to \cw{1.0}.  Values
-outside that range will produce extrapolated colours, which may be
-useful for some purposes, but may also produce impossible colours.
-
-\S{utils-game-mkhighlight} \cw{game_mkhighlight()}
-
-\c void game_mkhighlight(frontend *fe, float *ret,
-\c                       int background, int highlight, int lowlight);
-
-It's reasonably common for a puzzle game's graphics to use
-highlights and lowlights to indicate \q{raised} or \q{lowered}
-sections. Fifteen, Sixteen and Twiddle are good examples of this.
-
-Puzzles using this graphical style are running a risk if they just
-use whatever background colour is supplied to them by the front end,
-because that background colour might be too light or dark to see any
-highlights on at all. (In particular, it's not unheard of for the
-front end to specify a default background colour of white.)
-
-Therefore, such puzzles can call this utility function from their
-\cw{colours()} routine (\k{backend-colours}). You pass it your front
-end handle, a pointer to the start of your return array, and three
-colour indices. It will:
-
-\b call \cw{frontend_default_colour()} (\k{frontend-default-colour})
-to fetch the front end's default background colour
-
-\b alter the brightness of that colour if it's unsuitable
-
-\b define brighter and darker variants of the colour to be used as
-highlights and lowlights
-
-\b write those results into the relevant positions in the \c{ret}
-array.
-
-Thus, \cw{ret[background*3]} to \cw{ret[background*3+2]} will be set
-to RGB values defining a sensible background colour, and similary
-\c{highlight} and \c{lowlight} will be set to sensible colours.
-
-Either \c{highlight} or \c{lowlight} may be passed in as \cw{-1} to
-indicate that the back-end does not require a highlight or lowlight
-colour, respectively.
-
-\S{utils-game-mkhighlight-specific} \cw{game_mkhighlight_specific()}
-
-\c void game_mkhighlight_specific(frontend *fe, float *ret,
-\c     int background, int highlight, int lowlight);
-
-This function behaves exactly like \cw{game_mkhighlight()}, except
-that it expects the background colour to have been filled in
-\e{already} in the elements \cw{ret[background*3]} to
-\cw{ret[background*3+2]}. It will fill in the other two colours as
-brighter and darker versions of that.
-
-This is useful if you want to show relief sections of a puzzle in more
-than one base colour.
-
-\S{utils-button2label} \cw{button2label()}
-
-\c char *button2label(int button);
-
-This function generates a descriptive text label for \cw{button},
-which should be a button code that can be passed to the midend. For
-example, calling this function with \cw{CURSOR_UP} will result in the
-string \cw{"Up"}. This function should only be called when the
-\cw{key_label} item returned by a backend's \cw{request_keys()}
-(\k{backend-request-keys}) function has its \cw{label} field set to
-\cw{NULL}; in this case, the corresponding \cw{button} field can be
-passed to this function to obtain an appropriate label. If, however,
-the field is not \cw{NULL}, this function should not be called with
-the corresponding \cw{button} field.
-
-The returned string is dynamically allocated and should be
-\cw{sfree}'d by the caller.
-
-\S{utils-move-cursor} \cw{move_cursor()}
-
-\c char *move_cursor(int button, int *x, int *y, int w, int h,
-\c                   bool wrap, bool *visible);
-
-This function can be called by \cw{interpret_move()} to implement the
-default keyboard API for moving a cursor around a grid.
-
-\c{button} is the same value passed in to \cw{interpret_move()}. If
-it's not any of \cw{CURSOR_UP}, \cw{CURSOR_DOWN}, \cw{CURSOR_LEFT} or
-\cw{CURSOR_RIGHT}, the function will do nothing.
-
-\c{x} and \c{y} point to two integers which on input give the current
-location of a cursor in a square grid. \c{w} and \c{h} give the
-dimensions of the grid. On return, \c{x} and \c{y} are updated to give
-the cursor's new position according to which arrow key was pressed.
-
-This function assumes that the grid coordinates run from \cw{0} to
-\cw{w-1} inclusive (left to right), and from \cw{0} to \cw{h-1}
-inclusive (top to bottom).
-
-If \c{wrap} is \cw{true}, then trying to move the cursor off any edge
-of the grid will result in it wrapping round to the corresponding
-square on the opposite edge. If \c{wrap} is \cw{false}, such a move
-will have no effect.
-
-If \c{visible} is not \cw{NULL}, it points to a flag indicating
-whether the cursor is visible.  This will be set to \cw{true} if
-\c{button} represents a cursor-movement key.
-
-The function returns one of the special constants that can be returned
-by \cw{interpret_move()}.  The return value is \cw{MOVE_UNUSED} if
-\c{button} is unrecognised, \cw{MOVE_UI_UPDATE} if \c{x}, \c{y}, or
-\c{visible} was updated, and \cw{MOVE_NO EFFECT} otherwise.
-
-\S{utils-divvy-rectangle} \cw{divvy_rectangle()}
-
-\c int *divvy_rectangle(int w, int h, int k, random_state *rs);
-
-Invents a random division of a rectangle into same-sized polyominoes,
-such as is found in the block layout of a Solo puzzle in jigsaw mode,
-or the solution to a Palisade puzzle.
-
-\c{w} and \c{h} are the dimensions of the rectangle. \c{k} is the size
-of polyomino desired. It must be a factor of \c{w*h}.
-
-\c{rs} is a \cw{random_state} used to supply the random numbers to
-select a random division of the rectangle.
-
-The return value is a dsf (see \k{utils-dsf}) whose equivalence
-classes correspond to the polyominoes that the rectangle is divided
-into. The indices of the dsf are of the form \c{y*w+x}, for the cell
-with coordinates \cw{x,y}.
-
-\S{utils-domino-layout} \cw{domino_layout()}
-
-\c int *domino_layout(int w, int h, random_state *rs);
-
-Invents a random tiling of a rectangle with dominoes.
-
-\c{w} and \c{h} are the dimensions of the rectangle. If they are both
-odd, then one square will be left untiled.
-
-\c{rs} is a \cw{random_state} used to supply the random numbers to
-select a random division of the rectangle.
-
-The return value is an array in which element \c{y*w+x} represents the
-cell with coordinates \cw{x,y}. Each element of the array gives the
-index (in the same representation) of the other end of its domino. If
-there's a left-over square, then that element contains its own index.
-
-\S{utils-domino-layout-prealloc} \cw{domino_layout_prealloc()}
-
-\c void domino_layout_prealloc(int w, int h, random_state *rs,
-\c                             int *grid, int *grid2, int *list);
-
-Just like \cw{domino_layout()}, but does no memory allocation. You can
-use this to save allocator overhead if you expect to need to generate
-many domino tilings of the same grid.
-
-\c{grid} and \c{grid2} should each have space for \cw{w*h} ints.
-\c{list} should have space for \c{2*w*h} ints.
-
-The returned array is delivered in \c{grid}.
-
-\S{utils-strip-button-modifiers} \cw{STRIP_BUTTON_MODIFIERS()}
-
-This macro, defined in the main Puzzles header file, strips the
-modifier flags from the key code passed as an argument. It is
-equivalent to a bitwise-AND with \cw{~MOD_MASK}.
-
-\S{utils-swap-regions} \cw{swap_regions()}
-
-\c void swap_regions(void *av, void *bv, size_t size);
-
-Swap two regions of memory of \cw{size} bytes. The two regions must
-not overlap.
-
-\C{writing} How to write a new puzzle
-
-This chapter gives a guide to how to actually write a new puzzle:
-where to start, what to do first, how to solve common problems.
-
-The previous chapters have been largely composed of facts. This one
-is mostly advice.
-
-\H{writing-editorial} Choosing a puzzle
-
-Before you start writing a puzzle, you have to choose one. Your
-taste in puzzle games is up to you, of course; and, in fact, you're
-probably reading this guide because you've \e{already} thought of a
-game you want to write. But if you want to get it accepted into the
-official Puzzles distribution, then there's a criterion it has to
-meet.
-
-The current Puzzles editorial policy is that all games should be
-\e{fair}. A fair game is one which a player can only fail to complete
-through demonstrable lack of skill \dash that is, such that a better
-player presented with the same game state would have \e{known} to do
-something different.
-
-For a start, that means every game presented to the user must have
-\e{at least one solution}. Giving the unsuspecting user a puzzle which
-is actually impossible is not acceptable.
-
-(An exception to this: if the user has selected some non-default
-option which is clearly labelled as potentially unfair, \e{then}
-you're allowed to generate possibly insoluble puzzles, because the
-user isn't unsuspecting any more. Same Game and Mines both have
-options of this type.)
-
-Secondly, if the game includes hidden information, then it must be
-possible to deduce a correct move at every stage from the currently
-available information. It's not enough that there should exist some
-sequence of moves which will get from the start state to the solved
-state, if the player doesn't necessarily have enough information to
-\e{find} that solution. For example, in the card solitaire game
-Klondike, it's possible to reach a dead end because you had an
-arbitrary choice to make on no information, and made it the wrong way,
-which violates the fairness criterion, because a better player
-couldn't have known they needed to make the other choice.
-
-(Of course, games in this collection always have an Undo function, so
-if you did take the wrong route through a Klondike game, you could use
-Undo to back up and try a different choice. This doesn't count. In a
-fair game, you should be able to determine a correct move from the
-information visible \e{now}, without having to make moves to get more
-information that you can then back up and use.)
-
-Sometimes you can adjust the rules of an unfair puzzle to make it meet
-this definition of fairness. For example, more than one implementation
-of solitaire-style games (including card solitaires and Mahjong
-Solitaire) include a UI action to shuffle the remaining cards or tiles
-without changing their position; this action might be available at any
-time with a time or points penalty, or it might be illegal to use
-unless you have no other possible move. Adding an option like this
-would make a game \e{technically} fair, but it's better to avoid even
-that if you can.
-
-Providing a \e{unique} solution is a little more negotiable; it
-depends on the puzzle. Solo would have been of unacceptably low
-quality if it didn't always have a unique solution, whereas Twiddle
-inherently has multiple solutions by its very nature and it would
-have been meaningless to even \e{suggest} making it uniquely
-soluble. Somewhere in between, Flip could reasonably be made to have
-unique solutions (by enforcing a zero-dimension kernel in every
-generated matrix) but it doesn't seem like a serious quality problem
-that it doesn't.
-
-Of course, you don't \e{have} to care about all this. There's
-nothing stopping you implementing any puzzle you want to if you're
-happy to maintain your puzzle yourself, distribute it from your own
-web site, fork the Puzzles code completely, or anything like that.
-It's free software; you can do what you like with it. But any game
-that you want to be accepted into \e{my} Puzzles code base has to
-satisfy the fairness criterion, which means all randomly generated
-puzzles must have a solution (unless the user has deliberately
-chosen otherwise) and it must be possible \e{in theory} to find that
-solution without having to guess.
-
-\H{writing-gs} Getting started
-
-The simplest way to start writing a new puzzle is to copy
-\c{nullgame.c}. This is a template puzzle source file which does
-almost nothing, but which contains all the back end function
-prototypes and declares the back end data structure correctly. It is
-built every time the rest of Puzzles is built, to ensure that it
-doesn't get out of sync with the code and remains buildable.
-
-So start by copying \c{nullgame.c} into your new source file. Then
-you'll gradually add functionality until the very boring Null Game
-turns into your real game.
-
-Next you'll need to add your puzzle to the build scripts, in order to
-compile it conveniently. Puzzles is a CMake project, so you do this by
-adding a \cw{puzzle()} statement to CMakeLists.txt. Look at the
-existing ones to see what those look like, and add one that looks
-similar.
-
-Once your source file is building, you can move on to the fun bit.
-
-\S{writing-generation} Puzzle generation
-
-Randomly generating instances of your puzzle is almost certain to be
-the most difficult part of the code, and also the task with the
-highest chance of turning out to be completely infeasible. Therefore
-I strongly recommend doing it \e{first}, so that if it all goes
-horribly wrong you haven't wasted any more time than you absolutely
-had to. What I usually do is to take an unmodified \c{nullgame.c},
-and start adding code to \cw{new_game_desc()} which tries to
-generate a puzzle instance and print it out using \cw{printf()}.
-Once that's working, \e{then} I start connecting it up to the return
-value of \cw{new_game_desc()}, populating other structures like
-\c{game_params}, and generally writing the rest of the source file.
-
-There are many ways to generate a puzzle which is known to be
-soluble. In this section I list all the methods I currently know of,
-in case any of them can be applied to your puzzle. (Not all of these
-methods will work, or in some cases even make sense, for all
-puzzles.)
-
-Some puzzles are mathematically tractable, meaning you can work out
-in advance which instances are soluble. Sixteen, for example, has a
-parity constraint in some settings which renders exactly half the
-game space unreachable, but it can be mathematically proved that any
-position not in that half \e{is} reachable. Therefore, Sixteen's
-grid generation simply consists of selecting at random from a well
-defined subset of the game space. Cube in its default state is even
-easier: \e{every} possible arrangement of the blue squares and the
-cube's starting position is soluble!
-
-Another option is to redefine what you mean by \q{soluble}. Black
-Box takes this approach. There are layouts of balls in the box which
-are completely indistinguishable from one another no matter how many
-beams you fire into the box from which angles, which would normally
-be grounds for declaring those layouts unfair; but fortunately,
-detecting that indistinguishability is computationally easy. So
-Black Box doesn't demand that your ball placements match its own; it
-merely demands that your ball placements be \e{indistinguishable}
-from the ones it was thinking of. If you have an ambiguous puzzle,
-then any of the possible answers is considered to be a solution.
-Having redefined the rules in that way, any puzzle is soluble again.
-
-Those are the simple techniques. If they don't work, you have to get
-cleverer.
-
-One way to generate a soluble puzzle is to start from the solved
-state and make inverse moves until you reach a starting state. Then
-you know there's a solution, because you can just list the inverse
-moves you made and make them in the opposite order to return to the
-solved state.
-
-This method can be simple and effective for puzzles where you get to
-decide what's a starting state and what's not. In Pegs, for example,
-the generator begins with one peg in the centre of the board and
-makes inverse moves until it gets bored; in this puzzle, valid
-inverse moves are easy to detect, and \e{any} state that's reachable
-from the solved state by inverse moves is a reasonable starting
-position. So Pegs just continues making inverse moves until the
-board satisfies some criteria about extent and density, and then
-stops and declares itself done.
-
-For other puzzles, it can be a lot more difficult. Same Game uses
-this strategy too, and it's lucky to get away with it at all: valid
-inverse moves aren't easy to find (because although it's easy to
-insert additional squares in a Same Game position, it's difficult to
-arrange that \e{after} the insertion they aren't adjacent to any
-other squares of the same colour), so you're constantly at risk of
-running out of options and having to backtrack or start again. Also,
-Same Game grids never start off half-empty, which means you can't
-just stop when you run out of moves \dash you have to find a way to
-fill the grid up \e{completely}.
-
-The other way to generate a puzzle that's soluble is to start from
-the other end, and actually write a \e{solver}. This tends to ensure
-that a puzzle has a \e{unique} solution over and above having a
-solution at all, so it's a good technique to apply to puzzles for
-which that's important.
-
-One theoretical drawback of generating soluble puzzles by using a
-solver is that your puzzles are restricted in difficulty to those
-which the solver can handle. (Most solvers are not fully general:
-many sets of puzzle rules are NP-complete or otherwise nasty, so
-most solvers can only handle a subset of the theoretically soluble
-puzzles.) It's been my experience in practice, however, that this
-usually isn't a problem; computers are good at very different things
-from humans, and what the computer thinks is nice and easy might
-still be pleasantly challenging for a human. For example, when
-solving Dominosa puzzles I frequently find myself using a variety of
-reasoning techniques that my solver doesn't know about; in
-principle, therefore, I should be able to solve the puzzle using
-only those techniques it \e{does} know about, but this would involve
-repeatedly searching the entire grid for the one simple deduction I
-can make. Computers are good at this sort of exhaustive search, but
-it's been my experience that human solvers prefer to do more complex
-deductions than to spend ages searching for simple ones. So in many
-cases I don't find my own playing experience to be limited by the
-restrictions on the solver.
-
-(This isn't \e{always} the case. Solo is a counter-example;
-generating Solo puzzles using a simple solver does lead to
-qualitatively easier puzzles. Therefore I had to make the Solo
-solver rather more advanced than most of them.)
-
-There are several different ways to apply a solver to the problem of
-generating a soluble puzzle. I list a few of them below.
-
-The simplest approach is brute force: randomly generate a puzzle,
-use the solver to see if it's soluble, and if not, throw it away and
-try again until you get lucky. This is often a viable technique if
-all else fails, but it tends not to scale well: for many puzzle
-types, the probability of finding a uniquely soluble instance
-decreases sharply as puzzle size goes up, so this technique might
-work reasonably fast for small puzzles but take (almost) forever at
-larger sizes. Still, if there's no other alternative it can be
-usable: Pattern and Dominosa both use this technique. (However,
-Dominosa has a means of tweaking the randomly generated grids to
-increase the \e{probability} of them being soluble, by ruling out
-one of the most common ambiguous cases. This improved generation
-speed by over a factor of 10 on the highest preset!)
-
-An approach which can be more scalable involves generating a grid
-and then tweaking it to make it soluble. This is the technique used
-by Mines and also by Net: first a random puzzle is generated, and
-then the solver is run to see how far it gets. Sometimes the solver
-will get stuck; when that happens, examine the area it's having
-trouble with, and make a small random change in that area to allow
-it to make more progress. Continue solving (possibly even without
-restarting the solver), tweaking as necessary, until the solver
-finishes. Then restart the solver from the beginning to ensure that
-the tweaks haven't caused new problems in the process of solving old
-ones (which can sometimes happen).
-
-This strategy works well in situations where the usual solver
-failure mode is to get stuck in an easily localised spot. Thus it
-works well for Net and Mines, whose most common failure mode tends
-to be that most of the grid is fine but there are a few widely
-separated ambiguous sections; but it would work less well for
-Dominosa, in which the way you get stuck is to have scoured the
-whole grid and not found anything you can deduce \e{anywhere}. Also,
-it relies on there being a low probability that tweaking the grid
-introduces a new problem at the same time as solving the old one;
-Mines and Net also have the property that most of their deductions
-are local, so that it's very unlikely for a tweak to affect
-something half way across the grid from the location where it was
-applied. In Dominosa, by contrast, a lot of deductions use
-information about half the grid (\q{out of all the sixes, only one
-is next to a three}, which can depend on the values of up to 32 of
-the 56 squares in the default setting!), so this tweaking strategy
-would be rather less likely to work well.
-
-A more specialised strategy is that used in Solo and Slant. These
-puzzles have the property that they derive their difficulty from not
-presenting all the available clues. (In Solo's case, if all the
-possible clues were provided then the puzzle would already be
-solved; in Slant it would still require user action to fill in the
-lines, but it would present no challenge at all). Therefore, a
-simple generation technique is to leave the decision of which clues
-to provide until the last minute. In other words, first generate a
-random \e{filled} grid with all possible clues present, and then
-gradually remove clues for as long as the solver reports that it's
-still soluble. Unlike the methods described above, this technique
-\e{cannot} fail \dash once you've got a filled grid, nothing can
-stop you from being able to convert it into a viable puzzle.
-However, it wouldn't even be meaningful to apply this technique to
-(say) Pattern, in which clues can never be left out, so the only way
-to affect the set of clues is by altering the solution.
-
-(Unfortunately, Solo is complicated by the need to provide puzzles
-at varying difficulty levels. It's easy enough to generate a puzzle
-of \e{at most} a given level of difficulty; you just have a solver
-with configurable intelligence, and you set it to a given level and
-apply the above technique, thus guaranteeing that the resulting grid
-is solvable by someone with at most that much intelligence. However,
-generating a puzzle of \e{at least} a given level of difficulty is
-rather harder; if you go for \e{at most} Intermediate level, you're
-likely to find that you've accidentally generated a Trivial grid a
-lot of the time, because removing just one number is sufficient to
-take the puzzle from Trivial straight to Ambiguous. In that
-situation Solo has no remaining options but to throw the puzzle away
-and start again.)
-
-A final strategy is to use the solver \e{during} puzzle
-construction: lay out a bit of the grid, run the solver to see what
-it allows you to deduce, and then lay out a bit more to allow the
-solver to make more progress. There are articles on the web that
-recommend constructing Sudoku puzzles by this method (which is
-completely the opposite way round to how Solo does it); for Sudoku
-it has the advantage that you get to specify your clue squares in
-advance (so you can have them make pretty patterns).
-
-Rectangles uses a strategy along these lines. First it generates a
-grid by placing the actual rectangles; then it has to decide where
-in each rectangle to place a number. It uses a solver to help it
-place the numbers in such a way as to ensure a unique solution. It
-does this by means of running a test solver, but it runs the solver
-\e{before} it's placed any of the numbers \dash which means the
-solver must be capable of coping with uncertainty about exactly
-where the numbers are! It runs the solver as far as it can until it
-gets stuck; then it narrows down the possible positions of a number
-in order to allow the solver to make more progress, and so on. Most
-of the time this process terminates with the grid fully solved, at
-which point any remaining number-placement decisions can be made at
-random from the options not so far ruled out. Note that unlike the
-Net/Mines tweaking strategy described above, this algorithm does not
-require a checking run after it completes: if it finishes
-successfully at all, then it has definitely produced a uniquely
-soluble puzzle.
-
-Most of the strategies described above are not 100% reliable. Each
-one has a failure rate: every so often it has to throw out the whole
-grid and generate a fresh one from scratch. (Solo's strategy would
-be the exception, if it weren't for the need to provide configurable
-difficulty levels.) Occasional failures are not a fundamental
-problem in this sort of work, however: it's just a question of
-dividing the grid generation time by the success rate (if it takes
-10ms to generate a candidate grid and 1/5 of them work, then it will
-take 50ms on average to generate a viable one), and seeing whether
-the expected time taken to \e{successfully} generate a puzzle is
-unacceptably slow. Dominosa's generator has a very low success rate
-(about 1 out of 20 candidate grids turn out to be usable, and if you
-think \e{that's} bad then go and look at the source code and find
-the comment showing what the figures were before the generation-time
-tweaks!), but the generator itself is very fast so this doesn't
-matter. Rectangles has a slower generator, but fails well under 50%
-of the time.
-
-So don't be discouraged if you have an algorithm that doesn't always
-work: if it \e{nearly} always works, that's probably good enough.
-The one place where reliability is important is that your algorithm
-must never produce false positives: it must not claim a puzzle is
-soluble when it isn't. It can produce false negatives (failing to
-notice that a puzzle is soluble), and it can fail to generate a
-puzzle at all, provided it doesn't do either so often as to become
-slow.
-
-One last piece of advice: for grid-based puzzles, when writing and
-testing your generation algorithm, it's almost always a good idea
-\e{not} to test it initially on a grid that's square (i.e.
-\cw{w==h}), because if the grid is square then you won't notice if
-you mistakenly write \c{h} instead of \c{w} (or vice versa)
-somewhere in the code. Use a rectangular grid for testing, and any
-size of grid will be likely to work after that.
-
-\S{writing-textformats} Designing textual description formats
-
-Another aspect of writing a puzzle which is worth putting some
-thought into is the design of the various text description formats:
-the format of the game parameter encoding, the game description
-encoding, and the move encoding.
-
-The first two of these should be reasonably intuitive for a user to
-type in; so provide some flexibility where possible. Suppose, for
-example, your parameter format consists of two numbers separated by
-an \c{x} to specify the grid dimensions (\c{10x10} or \c{20x15}),
-and then has some suffixes to specify other aspects of the game
-type. It's almost always a good idea in this situation to arrange
-that \cw{decode_params()} can handle the suffixes appearing in any
-order, even if \cw{encode_params()} only ever generates them in one
-order.
-
-These formats will also be expected to be reasonably stable: users
-will expect to be able to exchange game IDs with other users who
-aren't running exactly the same version of your game. So make them
-robust and stable: don't build too many assumptions into the game ID
-format which will have to be changed every time something subtle
-changes in the puzzle code.
-
-\H{writing-howto} Common how-to questions
-
-This section lists some common things people want to do when writing
-a puzzle, and describes how to achieve them within the Puzzles
-framework.
-
-\S{writing-howto-redraw} Redrawing just the changed parts of the window
-
-Redrawing the entire window on every move is wasteful. If the user
-makes a move changing only one square of a grid, it's better to redraw
-just that square.
-
-(Yes, computers are fast these days, but these puzzles still try to be
-portable to devices at the less fast end of the spectrum, so it's
-still worth saving effort where it's easy. On the other hand, some
-puzzles just \e{can't} do this easily \dash Untangle is an example
-that really does have no better option than to redraw everything.)
-
-For a typical grid-oriented puzzle, a robust way to do this is:
-
-\b Invent a data representation that describes everything about the
-appearance of a grid cell in the puzzle window.
-
-\b Have \c{game_drawstate} contain an array of those, describing the
-current appearance of each cell, as it was last drawn in the window.
-
-\b In \cw{redraw()}, loop over each cell deciding what the new
-appearance should be. If it's not the same as the value stored in
-\c{game_drawstate}, then redraw that cell, and update the entry in the
-\c{game_drawstate} array.
-
-Where possible, I generally make my data representation an integer
-full of bit flags, to save space, and to make it easy to compare the
-old and new versions. If yours needs to be bigger than that, you may
-have to define a small \cw{struct} and write an equality-checking
-function.
-
-The data representation of the \e{appearance} of a square in
-\c{game_drawstate} will not generally be identical to the
-representation of the \e{logical state} of a square in \c{game_state},
-because many things contribute to a square's appearance other than its
-logical state. For example:
-
-\b Extra information overlaid on the square by the user interface,
-such as a keyboard-controlled cursor, or highlighting of squares
-currently involved in a mouse drag action.
-
-\b Error highlights marking violations of the puzzle constraints.
-
-\b Visual intrusions into one square because of things in nearby
-squares. For example, if you draw thick lines along the edges between
-grid squares, then the corners of those lines will be visible in
-logically unrelated squares. An entry in the \c{game_drawstate} array
-should describe a specific \e{rectangular area of the screen}, so that
-those areas can be erased and redrawn independently \dash so it must
-represent anything that appears in that area, even if it's sticking
-out from a graphic that logically lives in some other square.
-
-\b Temporary changes to the appearance of a square because of an
-ongoing completion flash.
-
-\b The current display mode, if a game provides more than one. (For
-example, the optional letters distinguishing the different coloured
-pegs in Guess.)
-
-All of this must be included in the \c{game_drawstate} representation,
-but should not be in the \c{game_state} at all. \cw{redraw()} will
-pull it all together from the \c{game_state}, the \c{game_ui}, and the
-animation and flash parameters.
-
-To make sure that \e{everything} affecting a square's appearance is
-included in this representation, it's a good idea to have a separate
-function for drawing a grid square, and deliberately \e{not} pass it a
-copy of the \c{game_state} or the \c{game_ui} at all. That way, if you
-want that function to draw anything differently, you \e{have} to do it
-by including that information in the representation of a square's
-appearance.
-
-But of course there are a couple of exceptions to this rule. A few
-things \e{don't} have to go in the \c{game_drawstate} array, and can
-safely be passed separately to the redraw-square function:
-
-\b Anything that remains completely fixed throughout the whole of a
-game, such as the clues provided by the puzzle. This is safe because a
-\c{game_drawstate} is never reused between puzzle instances: when you
-press New Game, a new \c{game_drawstate} will always be created from
-scratch. So the \c{game_drawstate} only needs to describe everything
-that might \e{change} during gameplay. If you have a sub-\cw{struct}
-in your \c{game_state} that describes immutable properties of the
-current game, as suggested in \k{writing-ref-counting}, then it's safe
-to pass \e{that substructure} to the redraw-square function, and have
-it retrieve that information directly.
-
-\b How far through a move animation the last redraw was. When
-\cw{redraw()} is called multiple times during an animated move, it's
-much easier to just assume that any square involved in the animation
-will \e{always} need redrawing. So \c{anim_length} can safely be
-passed separately to the redraw-square function \dash but you also
-have to remember to redraw a square if \e{either} its appearance is
-different from the last redraw \e{or} it's involved in an animation.
-
-\S{writing-howto-cursor} Drawing an object at only one position
-
-A common phenomenon is to have an object described in the
-\c{game_state} or the \c{game_ui} which can only be at one position.
-A cursor \dash probably specified in the \c{game_ui} \dash is a good
-example.
-
-In the \c{game_ui}, it would \e{obviously} be silly to have an array
-covering the whole game grid with a boolean flag stating whether the
-cursor was at each position. Doing that would waste space, would
-make it difficult to find the cursor in order to do anything with
-it, and would introduce the potential for synchronisation bugs in
-which you ended up with two cursors or none. The obviously sensible
-way to store a cursor in the \c{game_ui} is to have fields directly
-encoding the cursor's coordinates.
-
-However, it is a mistake to assume that the same logic applies to the
-\c{game_drawstate}. If you replicate the cursor position fields in the
-draw state, the redraw code will get very complicated. In the draw
-state, in fact, it \e{is} probably the right thing to have a cursor
-flag for every position in the grid, and make it part of the
-representation of each square's appearance, as described in
-\k{writing-howto-redraw}. So when you iterate over each square in
-\c{redraw()} working out its position, you set the \q{cursor here}
-flag in the representation of the square's appearance, if its
-coordinates match the cursor coordinates stored in the \c{game_ui}.
-This will automatically ensure that when the cursor moves, the redraw
-loop will redraw the square that \e{previously} contained the cursor
-and doesn't any more, and the one that now contains the cursor.
-
-\S{writing-keyboard-cursor} Implementing a keyboard-controlled cursor
-
-It is often useful to provide a keyboard control method in a
-basically mouse-controlled game. A keyboard-controlled cursor is
-best implemented by storing its location in the \c{game_ui} (since
-if it were in the \c{game_state} then the user would have to
-separately undo every cursor move operation). So the procedure would
-be:
-
-\b Put cursor position fields in the \c{game_ui}.
-
-\b \cw{interpret_move()} responds to arrow keys by modifying the
-cursor position fields and returning \cw{MOVE_UI_UPDATE}.
-
-\b \cw{interpret_move()} responds to some other button \dash either
-\cw{CURSOR_SELECT} or some more specific thing like a number key \dash
-by actually performing a move based on the current cursor location.
-
-\b You might want an additional \c{game_ui} field stating whether
-the cursor is currently visible, and having it disappear when a
-mouse action occurs (so that it doesn't clutter the display when not
-actually in use).
-
-\b You might also want to automatically hide the cursor in
-\cw{changed_state()} when the current game state changes to one in
-which there is no move to make (which is the case in some types of
-completed game).
-
-\b \cw{redraw()} draws the cursor using the technique described in
-\k{writing-howto-cursor}.
-
-\S{writing-howto-dragging} Implementing draggable sprites
-
-Some games have a user interface which involves dragging some sort
-of game element around using the mouse. If you need to show a
-graphic moving smoothly over the top of other graphics, use a
-blitter (see \k{drawing-blitter} for the blitter API) to save the
-background underneath it. The typical scenario goes:
-
-\b Have a blitter field in the \c{game_drawstate}.
-
-\b Set the blitter field to \cw{NULL} in the game's
-\cw{new_drawstate()} function, since you don't yet know how big the
-piece of saved background needs to be.
-
-\b In the game's \cw{set_size()} function, once you know the size of
-the object you'll be dragging around the display and hence the
-required size of the blitter, actually allocate the blitter.
-
-\b In \cw{free_drawstate()}, free the blitter if it's not \cw{NULL}.
-
-\b In \cw{interpret_move()}, respond to mouse-down and mouse-drag
-events by updating some fields in the \cw{game_ui} which indicate
-that a drag is in progress.
-
-\b At the \e{very end} of \cw{redraw()}, after all other drawing has
-been done, draw the moving object if there is one. First save the
-background under the object in the blitter; then set a clip
-rectangle covering precisely the area you just saved (just in case
-anti-aliasing or some other error causes your drawing to go beyond
-the area you saved). Then draw the object, and call \cw{unclip()}.
-Finally, set a flag in the \cw{game_drawstate} that indicates that
-the blitter needs restoring.
-
-\b At the very start of \cw{redraw()}, before doing anything else at
-all, check the flag in the \cw{game_drawstate}, and if it says the
-blitter needs restoring then restore it. (Then clear the flag, so
-that this won't happen again in the next redraw if no moving object
-is drawn this time.)
-
-This way, you will be able to write the rest of the redraw function
-completely ignoring the dragged object, as if it were floating above
-your bitmap and being completely separate.
-
-\S{writing-ref-counting} Sharing large invariant data between all
-game states
-
-In some puzzles, there is a large amount of data which never changes
-between game states. The array of numbers in Dominosa is a good
-example.
-
-You \e{could} dynamically allocate a copy of that array in every
-\c{game_state}, and have \cw{dup_game()} make a fresh copy of it for
-every new \c{game_state}; but it would waste memory and time. A
-more efficient way is to use a reference-counted structure.
-
-\b Define a structure type containing the data in question, and also
-containing an integer reference count.
-
-\b Have a field in \c{game_state} which is a pointer to this
-structure.
-
-\b In \cw{new_game()}, when creating a fresh game state at the start
-of a new game, create an instance of this structure, initialise it
-with the invariant data, and set its reference count to 1.
-
-\b In \cw{dup_game()}, rather than making a copy of the structure
-for the new game state, simply set the new game state to point at
-the same copy of the structure, and increment its reference count.
-
-\b In \cw{free_game()}, decrement the reference count in the
-structure pointed to by the game state; if the count reaches zero,
-free the structure.
-
-This way, the invariant data will persist for only as long as it's
-genuinely needed; \e{as soon} as the last game state for a
-particular puzzle instance is freed, the invariant data for that
-puzzle will vanish as well. Reference counting is a very efficient
-form of garbage collection, when it works at all. (Which it does in
-this instance, of course, because there's no possibility of circular
-references.)
-
-\S{writing-flash-types} Implementing multiple types of flash
-
-In some games you need to flash in more than one different way.
-Mines, for example, flashes white when you win, and flashes red when
-you tread on a mine and die.
-
-The simple way to do this is:
-
-\b Have a field in the \c{game_ui} which describes the type of flash.
-
-\b In \cw{flash_length()}, examine the old and new game states to
-decide whether a flash is required and what type. Write the type of
-flash to the \c{game_ui} field whenever you return non-zero.
-
-\b In \cw{redraw()}, when you detect that \c{flash_time} is
-non-zero, examine the field in \c{game_ui} to decide which type of
-flash to draw.
-
-\cw{redraw()} will never be called with \c{flash_time} non-zero
-unless \cw{flash_length()} was first called to tell the mid-end that
-a flash was required; so whenever \cw{redraw()} notices that
-\c{flash_time} is non-zero, you can be sure that the field in
-\c{game_ui} is correctly set.
-
-\S{writing-move-anim} Animating game moves
-
-A number of puzzle types benefit from a quick animation of each move
-you make.
-
-For some games, such as Fifteen, this is particularly easy. Whenever
-\cw{redraw()} is called with \c{oldstate} non-\cw{NULL}, Fifteen
-simply compares the position of each tile in the two game states,
-and if the tile is not in the same place then it draws it some
-fraction of the way from its old position to its new position. This
-method copes automatically with undo.
-
-Other games are less obvious. In Sixteen, for example, you can't
-just draw each tile a fraction of the way from its old to its new
-position: if you did that, the end tile would zip very rapidly past
-all the others to get to the other end and that would look silly.
-(Worse, it would look inconsistent if the end tile was drawn on top
-going one way and on the bottom going the other way.)
-
-A useful trick here is to define a field or two in the game state
-that indicates what the last move was.
-
-\b Add a \q{last move} field to the \c{game_state} (or two or more
-fields if the move is complex enough to need them).
-
-\b \cw{new_game()} initialises this field to a null value for a new
-game state.
-
-\b \cw{execute_move()} sets up the field to reflect the move it just
-performed.
-
-\b \cw{redraw()} now needs to examine its \c{dir} parameter. If
-\c{dir} is positive, it determines the move being animated by
-looking at the last-move field in \c{newstate}; but if \c{dir} is
-negative, it has to look at the last-move field in \c{oldstate}, and
-invert whatever move it finds there.
-
-Note also that Sixteen needs to store the \e{direction} of the move,
-because you can't quite determine it by examining the row or column
-in question. You can in almost all cases, but when the row is
-precisely two squares long it doesn't work since a move in either
-direction looks the same. (You could argue that since moving a
-2-element row left and right has the same effect, it doesn't matter
-which one you animate; but in fact it's very disorienting to click
-the arrow left and find the row moving right, and almost as bad to
-undo a move to the right and find the game animating \e{another}
-move to the right.)
-
-\S{writing-conditional-anim} Animating drag operations
-
-In Untangle, moves are made by dragging a node from an old position
-to a new position. Therefore, at the time when the move is initially
-made, it should not be animated, because the node has already been
-dragged to the right place and doesn't need moving there. However,
-it's nice to animate the same move if it's later undone or redone.
-This requires a bit of fiddling.
-
-The obvious approach is to have a flag in the \c{game_ui} which
-inhibits move animation, and to set that flag in
-\cw{interpret_move()}. The question is, when would the flag be reset
-again? The obvious place to do so is \cw{changed_state()}, which
-will be called once per move. But it will be called \e{before}
-\cw{anim_length()}, so if it resets the flag then \cw{anim_length()}
-will never see the flag set at all.
-
-The solution is to have \e{two} flags in a queue.
-
-\b Define two flags in \c{game_ui}; let's call them \q{current} and
-\q{next}.
-
-\b Set both to \cw{false} in \c{new_ui()}.
-
-\b When a drag operation completes in \cw{interpret_move()}, set the
-\q{next} flag to \cw{true}.
-
-\b Every time \cw{changed_state()} is called, set the value of
-\q{current} to the value in \q{next}, and then set the value of
-\q{next} to \cw{false}.
-
-\b That way, \q{current} will be \cw{true} \e{after} a call to
-\cw{changed_state()} if and only if that call to
-\cw{changed_state()} was the result of a drag operation processed by
-\cw{interpret_move()}. Any other call to \cw{changed_state()}, due
-to an Undo or a Redo or a Restart or a Solve, will leave \q{current}
-\cw{false}.
-
-\b So now \cw{anim_length()} can request a move animation if and
-only if the \q{current} flag is \e{not} set.
-
-\S{writing-cheating} Inhibiting the victory flash when Solve is used
-
-Many games flash when you complete them, as a visual congratulation
-for having got to the end of the puzzle. It often seems like a good
-idea to disable that flash when the puzzle is brought to a solved
-state by means of the Solve operation.
-
-This is easily done:
-
-\b Add a \q{cheated} flag to the \c{game_state}.
-
-\b Set this flag to \cw{false} in \cw{new_game()}.
-
-\b Have \cw{solve()} return a move description string which clearly
-identifies the move as a solve operation.
-
-\b Have \cw{execute_move()} respond to that clear identification by
-setting the \q{cheated} flag in the returned \c{game_state}. The
-flag will then be propagated to all subsequent game states, even if
-the user continues fiddling with the game after it is solved.
-
-\b \cw{flash_length()} now returns non-zero if \c{oldstate} is not
-completed and \c{newstate} is, \e{and} neither state has the
-\q{cheated} flag set.
-
-\H{writing-testing} Things to test once your puzzle is written
-
-Puzzle implementations written in this framework are self-testing as
-far as I could make them.
-
-Textual game and move descriptions, for example, are generated and
-parsed as part of the normal process of play. Therefore, if you can
-make moves in the game \e{at all} you can be reasonably confident
-that the mid-end serialisation interface will function correctly and
-you will be able to save your game. (By contrast, if I'd stuck with
-a single \cw{make_move()} function performing the jobs of both
-\cw{interpret_move()} and \cw{execute_move()}, and had separate
-functions to encode and decode a game state in string form, then
-those functions would not be used during normal play; so they could
-have been completely broken, and you'd never know it until you tried
-to save the game \dash which would have meant you'd have to test
-game saving \e{extensively} and make sure to test every possible
-type of game state. As an added bonus, doing it the way I did leads
-to smaller save files.)
-
-There is one exception to this, which is the string encoding of the
-\c{game_ui}. Most games do not store anything permanent in the
-\c{game_ui}, and hence do not need to put anything in its encode and
-decode functions; but if there is anything in there, you do need to
-test game loading and saving to ensure those functions work
-properly.
-
-It's also worth testing undo and redo of all operations, to ensure
-that the redraw and the animations (if any) work properly. Failing
-to animate undo properly seems to be a common error.
-
-Other than that, just use your common sense.
diff --git a/apps/plugins/puzzles/src/emcc.c b/apps/plugins/puzzles/src/emcc.c
deleted file mode 100644
index 6aa9c6b093..0000000000
--- a/apps/plugins/puzzles/src/emcc.c
+++ /dev/null
@@ -1,1149 +0,0 @@
-/*
- * emcc.c: the C component of an Emscripten-based web/Javascript front
- * end for Puzzles.
- *
- * The Javascript parts of this system live in emcclib.js and
- * emccpre.js. It also depends on being run in the context of a web
- * page containing an appropriate collection of bits and pieces (a
- * canvas, some buttons and links etc), which is generated for each
- * puzzle by the script html/jspage.pl.
- */
-
-/*
- * Further thoughts on possible enhancements:
- *
- *  - I should think about whether these webified puzzles can support
- *    touchscreen-based tablet browsers.
- *
- *  - think about making use of localStorage. It might be useful to
- *    let the user save games into there as an alternative to disk
- *    files - disk files are all very well for getting the save right
- *    out of your browser to (e.g.) email to me as a bug report, but
- *    for just resuming a game you were in the middle of, you'd
- *    probably rather have a nice simple 'quick save' and 'quick load'
- *    button pair.
- *
- *  - this is a downright silly idea, but it does occur to me that if
- *    I were to write a PDF output driver for the Puzzles printing
- *    API, then I might be able to implement a sort of 'printing'
- *    feature in this front end, using data: URIs again. (Ask the user
- *    exactly what they want printed, then construct an appropriate
- *    PDF and embed it in a gigantic data: URI. Then they can print
- *    that using whatever they normally use to print PDFs!)
- */
-
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-
-#include "puzzles.h"
-
-/*
- * Extern references to Javascript functions provided in emcclib.js.
- */
-extern void js_init_puzzle(void);
-extern void js_post_init(void);
-extern void js_debug(const char *);
-extern void js_error_box(const char *message);
-extern void js_remove_type_dropdown(void);
-extern void js_remove_solve_button(void);
-extern void js_add_preset(int menuid, const char *name, int value);
-extern int js_add_preset_submenu(int menuid, const char *name);
-extern int js_get_selected_preset(void);
-extern void js_select_preset(int n);
-extern void js_default_colour(float *output);
-extern void js_set_colour(int colour_number, const char *colour_string);
-extern void js_get_date_64(unsigned *p);
-extern void js_update_permalinks(const char *desc, const char *seed);
-extern void js_enable_undo_redo(bool undo, bool redo);
-extern void js_update_key_labels(const char *lsk, const char *csk);
-extern void js_activate_timer(void);
-extern void js_deactivate_timer(void);
-extern void js_canvas_start_draw(void);
-extern void js_canvas_draw_update(int x, int y, int w, int h);
-extern void js_canvas_end_draw(void);
-extern void js_canvas_draw_rect(int x, int y, int w, int h, int colour);
-extern void js_canvas_clip_rect(int x, int y, int w, int h);
-extern void js_canvas_unclip(void);
-extern void js_canvas_draw_line(float x1, float y1, float x2, float y2,
-                                int width, int colour);
-extern void js_canvas_draw_poly(const int *points, int npoints,
-                                int fillcolour, int outlinecolour);
-extern void js_canvas_draw_circle(int x, int y, int r,
-                                  int fillcolour, int outlinecolour);
-extern int js_canvas_find_font_midpoint(int height, bool monospaced);
-extern void js_canvas_draw_text(int x, int y, int halign,
-                                int colour, int height,
-                                bool monospaced, const char *text);
-extern int js_canvas_new_blitter(int w, int h);
-extern void js_canvas_free_blitter(int id);
-extern void js_canvas_copy_to_blitter(int id, int x, int y, int w, int h);
-extern void js_canvas_copy_from_blitter(int id, int x, int y, int w, int h);
-extern void js_canvas_remove_statusbar(void);
-extern void js_canvas_set_statusbar(const char *text);
-extern bool js_canvas_get_preferred_size(int *wp, int *hp);
-extern void js_canvas_set_size(int w, int h);
-extern double js_get_device_pixel_ratio(void);
-
-extern void js_dialog_init(const char *title);
-extern void js_dialog_string(int i, const char *title, const char *initvalue);
-extern void js_dialog_choices(int i, const char *title, const char *choicelist,
-                              int initvalue);
-extern void js_dialog_boolean(int i, const char *title, bool initvalue);
-extern void js_dialog_launch(void);
-extern void js_dialog_cleanup(void);
-extern void js_focus_canvas(void);
-
-extern bool js_savefile_read(void *buf, int len);
-
-extern void js_save_prefs(const char *);
-extern void js_load_prefs(midend *);
-
-/*
- * These functions are called from JavaScript, so their prototypes
- * need to be kept in sync with emccpre.js.
- */
-bool mouseup(int x, int y, int button);
-bool mousedown(int x, int y, int button);
-bool mousemove(int x, int y, int buttons);
-bool key(int keycode, const char *key, const char *chr, int location,
-         bool shift, bool ctrl);
-void timer_callback(double tplus);
-void command(int n);
-char *get_text_format(void);
-void free_save_file(char *buffer);
-char *get_save_file(void);
-void free_save_file(char *buffer);
-void load_game(void);
-void dlg_return_sval(int index, const char *val);
-void dlg_return_ival(int index, int val);
-void resize_puzzle(int w, int h);
-void restore_puzzle_size(int w, int h);
-void rescale_puzzle(void);
-
-/*
- * Internal forward references.
- */
-static void save_prefs(midend *me);
-
-/*
- * Call JS to get the date, and use that to initialise our random
- * number generator to invent the first game seed.
- */
-void get_random_seed(void **randseed, int *randseedsize)
-{
-    unsigned *ret = snewn(2, unsigned);
-    js_get_date_64(ret);
-    *randseed = ret;
-    *randseedsize = 2*sizeof(unsigned);
-}
-
-/*
- * Fatal error, called in cases of complete despair such as when
- * malloc() has returned NULL.
- */
-void fatal(const char *fmt, ...)
-{
-    char buf[512];
-    va_list ap;
-
-    strcpy(buf, "puzzle fatal error: ");
-
-    va_start(ap, fmt);
-    vsnprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), fmt, ap);
-    va_end(ap);
-
-    js_error_box(buf);
-}
-
-#ifdef DEBUGGING
-void debug_printf(const char *fmt, ...)
-{
-    char buf[512];
-    va_list ap;
-    va_start(ap, fmt);
-    vsnprintf(buf, sizeof(buf), fmt, ap);
-    va_end(ap);
-    js_debug(buf);
-}
-#endif
-
-/*
- * Helper function that makes it easy to test strings that might be
- * NULL.
- */
-static int strnullcmp(const char *a, const char *b)
-{
-    if (a == NULL || b == NULL)
-        return a != NULL ? +1 : b != NULL ? -1 : 0;
-    return strcmp(a, b);
-}
-
-/*
- * The global midend object.
- */
-static midend *me;
-
-/* ----------------------------------------------------------------------
- * Timing functions.
- */
-static bool timer_active = false;
-void deactivate_timer(frontend *fe)
-{
-    js_deactivate_timer();
-    timer_active = false;
-}
-void activate_timer(frontend *fe)
-{
-    if (!timer_active) {
-        js_activate_timer();
-        timer_active = true;
-    }
-}
-void timer_callback(double tplus)
-{
-    if (timer_active)
-        midend_timer(me, tplus);
-}
-
-/* ----------------------------------------------------------------------
- * Helper functions to resize the canvas, and variables to remember
- * its size for other functions (e.g. trimming blitter rectangles).
- */
-static int canvas_w, canvas_h;
-
-/*
- * Called when we resize as a result of changing puzzle settings
- * or device pixel ratio.
- */
-static void resize(void)
-{
-    int w, h;
-    bool user;
-    w = h = INT_MAX;
-    user = js_canvas_get_preferred_size(&w, &h);
-    midend_size(me, &w, &h, user, js_get_device_pixel_ratio());
-    js_canvas_set_size(w, h);
-    canvas_w = w;
-    canvas_h = h;
-}
-
-/* Called from JS when the device pixel ratio changes */
-void rescale_puzzle(void)
-{
-    resize();
-    midend_force_redraw(me);
-}
-
-/* Called from JS when the user uses the resize handle */
-void resize_puzzle(int w, int h)
-{
-    midend_size(me, &w, &h, true, js_get_device_pixel_ratio());
-    if (canvas_w != w || canvas_h != h) { 
-        js_canvas_set_size(w, h);
-        canvas_w = w;
-        canvas_h = h;
-        midend_force_redraw(me);
-    }
-}
-
-/* Called from JS when the user uses the restore button */
-void restore_puzzle_size(int w, int h)
-{
-    midend_reset_tilesize(me);
-    resize();
-    midend_force_redraw(me);
-}
-
-/*
- * Try to extract a background colour from the canvas's CSS.  In case
- * it doesn't have a usable one, make up a lightish grey ourselves.
- */
-void frontend_default_colour(frontend *fe, float *output)
-{
-    output[0] = output[1] = output[2] = 0.9F;
-    js_default_colour(output);
-}
-
-/*
- * Helper function called from all over the place to ensure the undo
- * and redo buttons get properly enabled and disabled after every move
- * or undo or new-game event.
- */
-static void post_move(void)
-{
-    js_enable_undo_redo(midend_can_undo(me), midend_can_redo(me));
-    js_update_key_labels(midend_current_key_label(me, CURSOR_SELECT2),
-                         midend_current_key_label(me, CURSOR_SELECT));
-}
-
-/*
- * Mouse event handlers called from JS.
- */
-bool mousedown(int x, int y, int button)
-{
-    bool handled;
-
-    button = (button == 0 ? LEFT_BUTTON :
-              button == 1 ? MIDDLE_BUTTON : RIGHT_BUTTON);
-    handled = midend_process_key(me, x, y, button) != PKR_UNUSED;
-    post_move();
-    return handled;
-}
-
-bool mouseup(int x, int y, int button)
-{
-    bool handled;
-
-    button = (button == 0 ? LEFT_RELEASE :
-              button == 1 ? MIDDLE_RELEASE : RIGHT_RELEASE);
-    handled = midend_process_key(me, x, y, button) != PKR_UNUSED;
-    post_move();
-    return handled;
-}
-
-bool mousemove(int x, int y, int buttons)
-{
-    int button = (buttons & 2 ? MIDDLE_DRAG :
-                  buttons & 4 ? RIGHT_DRAG : LEFT_DRAG);
-    bool handled;
-
-    handled = midend_process_key(me, x, y, button) != PKR_UNUSED;
-    post_move();
-    return handled;
-}
-
-/*
- * Keyboard handler called from JS.  Returns true if the key was
- * handled and hence the keydown event should be cancelled.
- */
-bool key(int keycode, const char *key, const char *chr, int location,
-         bool shift, bool ctrl)
-{
-    /* Key location constants from JavaScript. */
-    #define DOM_KEY_LOCATION_STANDARD 0
-    #define DOM_KEY_LOCATION_LEFT     1
-    #define DOM_KEY_LOCATION_RIGHT    2
-    #define DOM_KEY_LOCATION_NUMPAD   3
-    int keyevent = -1;
-    int process_key_result;
-
-    if (!strnullcmp(key, "Backspace") || !strnullcmp(key, "Delete") ||
-        !strnullcmp(key, "Del"))
-        keyevent = 127;                /* Backspace / Delete */
-    else if (!strnullcmp(key, "Enter"))
-        keyevent = 13;             /* return */
-    else if (!strnullcmp(key, "Spacebar"))
-        keyevent = ' ';
-    else if (!strnullcmp(key, "Escape"))
-        keyevent = 27;
-    else if (!strnullcmp(key, "ArrowLeft") || !strnullcmp(key, "Left"))
-        keyevent = CURSOR_LEFT;
-    else if (!strnullcmp(key, "ArrowUp") || !strnullcmp(key, "Up"))
-        keyevent = CURSOR_UP;
-    else if (!strnullcmp(key, "ArrowRight") || !strnullcmp(key, "Right"))
-        keyevent = CURSOR_RIGHT;
-    else if (!strnullcmp(key, "ArrowDown") || !strnullcmp(key, "Down"))
-        keyevent = CURSOR_DOWN;
-    else if (!strnullcmp(key, "SoftLeft"))
-        /* Left soft key on KaiOS. */
-        keyevent = CURSOR_SELECT2;
-    else if (!strnullcmp(key, "End"))
-        /*
-         * We interpret Home, End, PgUp and PgDn as numeric keypad
-         * controls regardless of whether they're the ones on the
-         * numeric keypad (since we can't tell). The effect of
-         * this should only be that the non-numeric-pad versions
-         * of those keys generate directions in 8-way movement
-         * puzzles like Cube and Inertia.
-         */
-        keyevent = MOD_NUM_KEYPAD | '1';
-    else if (!strnullcmp(key, "PageDown"))
-        keyevent = MOD_NUM_KEYPAD | '3';
-    else if (!strnullcmp(key, "Home"))
-        keyevent = MOD_NUM_KEYPAD | '7';
-    else if (!strnullcmp(key, "PageUp"))
-        keyevent = MOD_NUM_KEYPAD | '9';
-    else if (shift && ctrl && (!strnullcmp(key, "Z") || !strnullcmp(key, "z")))
-        keyevent = UI_REDO;
-    else if (key && (unsigned char)key[0] < 0x80 && key[1] == '\0')
-        /* Key generating a single ASCII character. */
-        keyevent = key[0];
-    /*
-     * In modern browsers (since about 2017), all keys that Puzzles
-     * cares about should be matched by one of the clauses above.  The
-     * code below that checks keycode and chr should be relavent only
-     * in older browsers.
-     */
-    else if (keycode == 8 || keycode == 46)
-        keyevent = 127;                /* Backspace / Delete */
-    else if (keycode == 13)
-        keyevent = 13;             /* return */
-    else if (keycode == 37)
-        keyevent = CURSOR_LEFT;
-    else if (keycode == 38)
-        keyevent = CURSOR_UP;
-    else if (keycode == 39)
-        keyevent = CURSOR_RIGHT;
-    else if (keycode == 40)
-        keyevent = CURSOR_DOWN;
-    else if (keycode == 35)
-        keyevent = MOD_NUM_KEYPAD | '1';
-    else if (keycode == 34)
-        keyevent = MOD_NUM_KEYPAD | '3';
-    else if (keycode == 36)
-        keyevent = MOD_NUM_KEYPAD | '7';
-    else if (keycode == 33)
-        keyevent = MOD_NUM_KEYPAD | '9';
-    else if (shift && ctrl && (keycode & 0x1F) == 26)
-        keyevent = UI_REDO;
-    else if (chr && chr[0] && !chr[1])
-        keyevent = chr[0] & 0xFF;
-    else if (keycode >= 96 && keycode < 106)
-        keyevent = MOD_NUM_KEYPAD | ('0' + keycode - 96);
-    else if (keycode >= 65 && keycode <= 90)
-        keyevent = keycode + (shift ? 0 : 32);
-    else if (keycode >= 48 && keycode <= 57)
-        keyevent = keycode;
-    else if (keycode == 32)        /* space / CURSOR_SELECT2 */
-        keyevent = keycode;
-
-    if (keyevent >= 0) {
-        if (shift) keyevent |= MOD_SHFT;
-        if (ctrl) keyevent |= MOD_CTRL;
-        if (location == DOM_KEY_LOCATION_NUMPAD) keyevent |= MOD_NUM_KEYPAD;
-
-        process_key_result = midend_process_key(me, 0, 0, keyevent);
-        post_move();
-        /*
-         * Treat Backspace specially because that's expected on KaiOS.
-         * https://developer.kaiostech.com/docs/design-guide/key
-         */
-        if (process_key_result == PKR_NO_EFFECT &&
-            !strnullcmp(key, "Backspace"))
-            return false;
-        return process_key_result != PKR_UNUSED;
-    }
-    return false; /* Event not handled, because we don't even recognise it. */
-}
-
-/*
- * Helper function called from several places to update the permalinks
- * whenever a new game is created.
- */
-static void update_permalinks(void)
-{
-    char *desc, *seed;
-    desc = midend_get_game_id(me);
-    seed = midend_get_random_seed(me);
-    js_update_permalinks(desc, seed);
-    sfree(desc);
-    sfree(seed);
-}
-
-/*
- * Callback from the midend when the game ids change, so we can update
- * the permalinks.
- */
-static void ids_changed(void *ignored)
-{
-    update_permalinks();
-}
-
-/* ----------------------------------------------------------------------
- * Implementation of the drawing API by calling Javascript canvas
- * drawing functions. (Well, half of it; the other half is on the JS
- * side.)
- */
-static void js_start_draw(void *handle)
-{
-    js_canvas_start_draw();
-}
-
-static void js_clip(void *handle, int x, int y, int w, int h)
-{
-    js_canvas_clip_rect(x, y, w, h);
-}
-
-static void js_unclip(void *handle)
-{
-    js_canvas_unclip();
-}
-
-static void js_draw_text(void *handle, int x, int y, int fonttype,
-                         int fontsize, int align, int colour,
-                         const char *text)
-{
-    int halign;
-
-    if (align & ALIGN_VCENTRE)
-        y += js_canvas_find_font_midpoint(fontsize, fonttype == FONT_FIXED);
-
-    if (align & ALIGN_HCENTRE)
-        halign = 1;
-    else if (align & ALIGN_HRIGHT)
-        halign = 2;
-    else
-        halign = 0;
-
-    js_canvas_draw_text(x, y, halign, colour,
-                        fontsize, fonttype == FONT_FIXED, text);
-}
-
-static void js_draw_rect(void *handle, int x, int y, int w, int h, int colour)
-{
-    js_canvas_draw_rect(x, y, w, h, colour);
-}
-
-static void js_draw_line(void *handle, int x1, int y1, int x2, int y2,
-                         int colour)
-{
-    js_canvas_draw_line(x1, y1, x2, y2, 1, colour);
-}
-
-static void js_draw_thick_line(void *handle, float thickness,
-                               float x1, float y1, float x2, float y2,
-                               int colour)
-{
-    js_canvas_draw_line(x1, y1, x2, y2, thickness, colour);
-}
-
-static void js_draw_poly(void *handle, const int *coords, int npoints,
-                         int fillcolour, int outlinecolour)
-{
-    js_canvas_draw_poly(coords, npoints, fillcolour, outlinecolour);
-}
-
-static void js_draw_circle(void *handle, int cx, int cy, int radius,
-                           int fillcolour, int outlinecolour)
-{
-    js_canvas_draw_circle(cx, cy, radius, fillcolour, outlinecolour);
-}
-
-struct blitter {
-    int id;                            /* allocated on the js side */
-    int w, h;                          /* easier to retain here */
-};
-
-static blitter *js_blitter_new(void *handle, int w, int h)
-{
-    blitter *bl = snew(blitter);
-    bl->w = w;
-    bl->h = h;
-    bl->id = js_canvas_new_blitter(w, h);
-    return bl;
-}
-
-static void js_blitter_free(void *handle, blitter *bl)
-{
-    js_canvas_free_blitter(bl->id);
-    sfree(bl);
-}
-
-static void trim_rect(int *x, int *y, int *w, int *h)
-{
-    int x0, x1, y0, y1;
-
-    /*
-     * Reduce the size of the copied rectangle to stop it going
-     * outside the bounds of the canvas.
-     */
-
-    /* Transform from x,y,w,h form into coordinates of all edges */
-    x0 = *x;
-    y0 = *y;
-    x1 = *x + *w;
-    y1 = *y + *h;
-
-    /* Clip each coordinate at both extremes of the canvas */
-    x0 = (x0 < 0 ? 0 : x0 > canvas_w ? canvas_w : x0);
-    x1 = (x1 < 0 ? 0 : x1 > canvas_w ? canvas_w : x1);
-    y0 = (y0 < 0 ? 0 : y0 > canvas_h ? canvas_h : y0);
-    y1 = (y1 < 0 ? 0 : y1 > canvas_h ? canvas_h : y1); 
-
-    /* Transform back into x,y,w,h to return */
-    *x = x0;
-    *y = y0;
-    *w = x1 - x0;
-    *h = y1 - y0;
-}
-
-static void js_blitter_save(void *handle, blitter *bl, int x, int y)
-{
-    int w = bl->w, h = bl->h;
-    trim_rect(&x, &y, &w, &h);
-    if (w > 0 && h > 0)
-        js_canvas_copy_to_blitter(bl->id, x, y, w, h);
-}
-
-static void js_blitter_load(void *handle, blitter *bl, int x, int y)
-{
-    int w = bl->w, h = bl->h;
-    trim_rect(&x, &y, &w, &h);
-    if (w > 0 && h > 0)
-        js_canvas_copy_from_blitter(bl->id, x, y, w, h);
-}
-
-static void js_draw_update(void *handle, int x, int y, int w, int h)
-{
-    trim_rect(&x, &y, &w, &h);
-    if (w > 0 && h > 0)
-        js_canvas_draw_update(x, y, w, h);
-}
-
-static void js_end_draw(void *handle)
-{
-    js_canvas_end_draw();
-}
-
-static void js_status_bar(void *handle, const char *text)
-{
-    js_canvas_set_statusbar(text);
-}
-
-static char *js_text_fallback(void *handle, const char *const *strings,
-                              int nstrings)
-{
-    return dupstr(strings[0]); /* Emscripten has no trouble with UTF-8 */
-}
-
-static const struct drawing_api js_drawing = {
-    js_draw_text,
-    js_draw_rect,
-    js_draw_line,
-    js_draw_poly,
-    js_draw_circle,
-    js_draw_update,
-    js_clip,
-    js_unclip,
-    js_start_draw,
-    js_end_draw,
-    js_status_bar,
-    js_blitter_new,
-    js_blitter_free,
-    js_blitter_save,
-    js_blitter_load,
-    NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
-    NULL, NULL,                        /* line_width, line_dotted */
-    js_text_fallback,
-    js_draw_thick_line,
-};
-
-/* ----------------------------------------------------------------------
- * Presets and game-configuration dialog support.
- */
-static game_params **presets;
-static int npresets;
-static bool have_presets_dropdown;
-
-static void populate_js_preset_menu(int menuid, struct preset_menu *menu)
-{
-    int i;
-    for (i = 0; i < menu->n_entries; i++) {
-        struct preset_menu_entry *entry = &menu->entries[i];
-        if (entry->params) {
-            presets[entry->id] = entry->params;
-            js_add_preset(menuid, entry->title, entry->id);
-        } else {
-            int js_submenu = js_add_preset_submenu(menuid, entry->title);
-            populate_js_preset_menu(js_submenu, entry->submenu);
-        }
-    }
-}
-
-static void select_appropriate_preset(void)
-{
-    if (have_presets_dropdown) {
-        int preset = midend_which_preset(me);
-        js_select_preset(preset < 0 ? -1 : preset);
-    }
-}
-
-static config_item *cfg = NULL;
-static int cfg_which;
-
-/*
- * Set up a dialog box. This is pretty easy on the C side; most of the
- * work is done in JS.
- */
-static void cfg_start(int which)
-{
-    char *title;
-    int i;
-
-    cfg = midend_get_config(me, which, &title);
-    cfg_which = which;
-
-    js_dialog_init(title);
-    sfree(title);
-
-    for (i = 0; cfg[i].type != C_END; i++) {
-        switch (cfg[i].type) {
-          case C_STRING:
-            js_dialog_string(i, cfg[i].name, cfg[i].u.string.sval);
-            break;
-          case C_BOOLEAN:
-            js_dialog_boolean(i, cfg[i].name, cfg[i].u.boolean.bval);
-            break;
-          case C_CHOICES:
-            js_dialog_choices(i, cfg[i].name, cfg[i].u.choices.choicenames,
-                              cfg[i].u.choices.selected);
-            break;
-        }
-    }
-
-    js_dialog_launch();
-}
-
-/*
- * Callbacks from JS when the OK button is clicked, to return the
- * final state of each control.
- */
-void dlg_return_sval(int index, const char *val)
-{
-    config_item *i = cfg + index;
-    switch (i->type) {
-      case C_STRING:
-        sfree(i->u.string.sval);
-        i->u.string.sval = dupstr(val);
-        break;
-      default:
-        assert(0 && "Bad type for return_sval");
-    }
-}
-void dlg_return_ival(int index, int val)
-{
-    config_item *i = cfg + index;
-    switch (i->type) {
-      case C_BOOLEAN:
-        i->u.boolean.bval = val;
-        break;
-      case C_CHOICES:
-        i->u.choices.selected = val;
-        break;
-      default:
-        assert(0 && "Bad type for return_ival");
-    }
-}
-
-/*
- * Called when the user clicks OK or Cancel. use_results will be true
- * or false respectively, in those cases. We terminate the dialog box,
- * unless the user selected an invalid combination of parameters.
- */
-static void cfg_end(bool use_results)
-{
-    if (use_results) {
-        /*
-         * User hit OK.
-         */
-        const char *err = midend_set_config(me, cfg_which, cfg);
-
-        if (err) {
-            /*
-             * The settings were unacceptable, so leave the config box
-             * open for the user to adjust them and try again.
-             */
-            js_error_box(err);
-        } else if (cfg_which == CFG_PREFS) {
-            /*
-             * Acceptable settings for user preferences: enact them
-             * without blowing away the current game.
-             */
-            resize();
-            midend_redraw(me);
-            free_cfg(cfg);
-            js_dialog_cleanup();
-            save_prefs(me);
-        } else {
-            /*
-             * Acceptable settings for the remaining configuration
-             * types: start a new game and close the dialog.
-             */
-            select_appropriate_preset();
-            midend_new_game(me);
-            resize();
-            midend_redraw(me);
-            free_cfg(cfg);
-            js_dialog_cleanup();
-        }
-    } else {
-        /*
-         * User hit Cancel. Close the dialog, but also we must still
-         * reselect the right element of the dropdown list.
-         *
-         * (Because: imagine you have a preset selected, and then you
-         * select Custom from the list, but change your mind and hit
-         * Esc. The Custom option will now still be selected in the
-         * list, whereas obviously it should show the preset you still
-         * _actually_ have selected.)
-         */
-        select_appropriate_preset();
-
-        free_cfg(cfg);
-        js_dialog_cleanup();
-    }
-}
-
-/* ----------------------------------------------------------------------
- * Called from JS when a command is given to the puzzle by clicking a
- * button or control of some sort.
- */
-void command(int n)
-{
-    switch (n) {
-      case 0:                          /* specific game ID */
-        cfg_start(CFG_DESC);
-        break;
-      case 1:                          /* random game seed */
-        cfg_start(CFG_SEED);
-        break;
-      case 2:                          /* game parameter dropdown changed */
-        {
-            int i = js_get_selected_preset();
-            if (i < 0) {
-                /*
-                 * The user selected 'Custom', so launch the config
-                 * box.
-                 */
-                if (thegame.can_configure) /* (double-check just in case) */
-                    cfg_start(CFG_SETTINGS);
-            } else {
-                /*
-                 * The user selected a preset, so just switch straight
-                 * to that.
-                 */
-                assert(i < npresets);
-                midend_set_params(me, presets[i]);
-                midend_new_game(me);
-                resize();
-                midend_redraw(me);
-                post_move();
-                js_focus_canvas();
-                select_appropriate_preset();
-            }
-        }
-        break;
-      case 3:                          /* OK clicked in a config box */
-        cfg_end(true);
-        post_move();
-        break;
-      case 4:                          /* Cancel clicked in a config box */
-        cfg_end(false);
-        post_move();
-        break;
-      case 5:                          /* New Game */
-        midend_process_key(me, 0, 0, UI_NEWGAME);
-        post_move();
-        js_focus_canvas();
-        break;
-      case 6:                          /* Restart */
-        midend_restart_game(me);
-        post_move();
-        js_focus_canvas();
-        break;
-      case 7:                          /* Undo */
-        midend_process_key(me, 0, 0, UI_UNDO);
-        post_move();
-        js_focus_canvas();
-        break;
-      case 8:                          /* Redo */
-        midend_process_key(me, 0, 0, UI_REDO);
-        post_move();
-        js_focus_canvas();
-        break;
-      case 9:                          /* Solve */
-        if (thegame.can_solve) {
-            const char *msg = midend_solve(me);
-            if (msg)
-                js_error_box(msg);
-        }
-        post_move();
-        js_focus_canvas();
-        break;
-      case 10:                         /* user preferences */
-        cfg_start(CFG_PREFS);
-        break;
-    }
-}
-
-char *get_text_format(void)
-{
-    return midend_text_format(me);
-}
-
-void free_text_format(char *buffer)
-{
-    sfree(buffer);
-}
-
-/* ----------------------------------------------------------------------
- * Called from JS to prepare a save-game file, and free one after it's
- * been used.
- */
-
-struct savefile_write_ctx {
-    char *buffer;
-    size_t pos;
-};
-
-static void savefile_write(void *vctx, const void *buf, int len)
-{
-    struct savefile_write_ctx *ctx = (struct savefile_write_ctx *)vctx;
-    if (ctx->buffer)
-        memcpy(ctx->buffer + ctx->pos, buf, len);
-    ctx->pos += len;
-}
-
-char *get_save_file(void)
-{
-    struct savefile_write_ctx ctx;
-    size_t size;
-
-    /* First pass, to count up the size */
-    ctx.buffer = NULL;
-    ctx.pos = 0;
-    midend_serialise(me, savefile_write, &ctx);
-    size = ctx.pos;
-
-    /* Second pass, to actually write out the data. We have to put a
-     * terminating \0 on the end (which we expect never to show up in
-     * the actual serialisation format - it's text, not binary) so
-     * that the Javascript side can easily find out the length. */
-    ctx.buffer = snewn(size+1, char);
-    ctx.pos = 0;
-    midend_serialise(me, savefile_write, &ctx);
-    assert(ctx.pos == size);
-    ctx.buffer[ctx.pos] = '\0';
-
-    return ctx.buffer;
-}
-
-void free_save_file(char *buffer)
-{
-    sfree(buffer);
-}
-
-static bool savefile_read(void *vctx, void *buf, int len)
-{
-    return js_savefile_read(buf, len);
-}
-
-void load_game(void)
-{
-    const char *err;
-
-    /*
-     * savefile_read_callback in JavaScript was set up by our caller
-     * as a closure that knows what file we're loading.
-     */
-    err = midend_deserialise(me, savefile_read, NULL);
-
-    if (err) {
-        js_error_box(err);
-    } else {
-        select_appropriate_preset();
-        resize();
-        midend_redraw(me);
-        update_permalinks();
-        post_move();
-    }
-}
-
-/* ----------------------------------------------------------------------
- * Functions to load and save preferences, calling out to JS to access
- * the appropriate localStorage slot.
- */
-
-static void save_prefs(midend *me)
-{
-    struct savefile_write_ctx ctx;
-    size_t size;
-
-    /* First pass, to count up the size */
-    ctx.buffer = NULL;
-    ctx.pos = 0;
-    midend_save_prefs(me, savefile_write, &ctx);
-    size = ctx.pos;
-
-    /* Second pass, to actually write out the data. As with
-     * get_save_file, we append a terminating \0. */
-    ctx.buffer = snewn(size+1, char);
-    ctx.pos = 0;
-    midend_save_prefs(me, savefile_write, &ctx);
-    assert(ctx.pos == size);
-    ctx.buffer[ctx.pos] = '\0';
-
-    js_save_prefs(ctx.buffer);
-
-    sfree(ctx.buffer);
-}
-
-struct prefs_read_ctx {
-    const char *buffer;
-    size_t pos, len;
-};
-
-static bool prefs_read(void *vctx, void *buf, int len)
-{
-    struct prefs_read_ctx *ctx = (struct prefs_read_ctx *)vctx;
-
-    if (len < 0)
-        return false;
-    if (ctx->len - ctx->pos < len)
-        return false;
-    memcpy(buf, ctx->buffer + ctx->pos, len);
-    ctx->pos += len;
-    return true;
-}
-
-void prefs_load_callback(midend *me, const char *prefs)
-{
-    struct prefs_read_ctx ctx;
-
-    ctx.buffer = prefs;
-    ctx.len = strlen(prefs);
-    ctx.pos = 0;
-
-    midend_load_prefs(me, prefs_read, &ctx);
-}
-
-/* ----------------------------------------------------------------------
- * Setup function called at page load time. It's called main() because
- * that's the most convenient thing in Emscripten, but it's not main()
- * in the usual sense of bounding the program's entire execution.
- * Instead, this function returns once the initial puzzle is set up
- * and working, and everything thereafter happens by means of JS event
- * handlers sending us callbacks.
- */
-int main(int argc, char **argv)
-{
-    const char *param_err;
-    float *colours;
-    int i, ncolours;
-
-    /*
-     * Initialise JavaScript event handlers.
-     */
-    js_init_puzzle();
-
-    /*
-     * Instantiate a midend.
-     */
-    me = midend_new(NULL, &thegame, &js_drawing, NULL);
-    js_load_prefs(me);
-
-    /*
-     * Chuck in the HTML fragment ID if we have one (trimming the
-     * leading # off the front first). If that's invalid, we retain
-     * the error message and will display it at the end, after setting
-     * up a random puzzle as usual.
-     */
-    if (argc > 1 && argv[1][0] == '#' && argv[1][1] != '\0')
-        param_err = midend_game_id(me, argv[1] + 1);
-    else
-        param_err = NULL;
-
-    /*
-     * Create either a random game or the specified one, and set the
-     * canvas size appropriately.
-     */
-    midend_new_game(me);
-    resize();
-
-    /*
-     * Remove the status bar, if not needed.
-     */
-    if (!midend_wants_statusbar(me))
-        js_canvas_remove_statusbar();
-
-    /*
-     * Set up the game-type dropdown with presets and/or the Custom
-     * option.
-     */
-    {
-        struct preset_menu *menu = midend_get_presets(me, &npresets);
-        bool may_configure = false;
-        presets = snewn(npresets, game_params *);
-        for (i = 0; i < npresets; i++)
-            presets[i] = NULL;
-
-        populate_js_preset_menu(0, menu);
-
-        /*
-         * Crude hack to allow the "Custom..." item to be hidden on
-         * KaiOS, where dialogs don't yet work.
-         */
-        if (thegame.can_configure && getenv_bool("PUZZLES_ALLOW_CUSTOM", true))
-            may_configure = true;
-        if (may_configure)
-            js_add_preset(0, "Custom...", -1);
-
-        have_presets_dropdown = npresets > 1 || may_configure;
-
-        if (have_presets_dropdown)
-            /*
-             * Now ensure the appropriate element of the presets menu
-             * starts off selected, in case it isn't the first one in the
-             * list (e.g. Slant).
-             */
-            select_appropriate_preset();
-        else
-            js_remove_type_dropdown();
-    }
-
-    /*
-     * Remove the Solve button if the game doesn't support it.
-     */
-    if (!thegame.can_solve)
-        js_remove_solve_button();
-
-    /*
-     * Retrieve the game's colours, and convert them into #abcdef type
-     * hex ID strings.
-     */
-    colours = midend_colours(me, &ncolours);
-    for (i = 0; i < ncolours; i++) {
-        char col[40];
-        sprintf(col, "#%02x%02x%02x",
-                (unsigned)(0.5F + 255 * colours[i*3+0]),
-                (unsigned)(0.5F + 255 * colours[i*3+1]),
-                (unsigned)(0.5F + 255 * colours[i*3+2]));
-        js_set_colour(i, col);
-    }
-
-    /*
-     * Request notification when the game ids change (e.g. if the user
-     * presses 'n', and also when Mines supersedes its game
-     * description), so that we can proactively update the permalink.
-     */
-    midend_request_id_changes(me, ids_changed, NULL);
-
-    /*
-     * Draw the puzzle's initial state, and set up the permalinks and
-     * undo/redo greying out.
-     */
-    midend_redraw(me);
-    update_permalinks();
-    post_move();
-
-    /*
-     * If we were given an erroneous game ID in argv[1], now's the
-     * time to put up the error box about it, after we've fully set up
-     * a random puzzle. Then when the user clicks 'ok', we have a
-     * puzzle for them.
-     */
-    if (param_err)
-        js_error_box(param_err);
-
-    /*
-     * Reveal the puzzle!
-     */
-    js_post_init();
-
-    /*
-     * Done. Return to JS, and await callbacks!
-     */
-    return 0;
-}
diff --git a/apps/plugins/puzzles/src/emcccopy.but b/apps/plugins/puzzles/src/emcccopy.but
deleted file mode 100644
index 5332e0df38..0000000000
--- a/apps/plugins/puzzles/src/emcccopy.but
+++ /dev/null
@@ -1,128 +0,0 @@
-\A{thirdparty} Third-party software licences
-
-\# This file should contain the copyright notices for third-party code
-included in the Emscripten builds of Puzzles.  To get a list of
-relevant source files, you can build Puzzles with "-gsource-map" and
-then do something like:
-
-\# jq -r '.sources[]' *.map | sort -u
-
-\# This file is based on a build of Git commit
-2e48ce132e011e83517a9fc4905edcc8f9a5ef58 using Emscripten 3.1.35
-
-\# system/lib/compiler-rt/lib/builtins/*
-\# upstream/lib/clang/17/include/tgmath.h
-
-\# These are under the Apache Licence v2.0 with LLVM Exceptions.  The
-LLVM Exceptions allow us not to mention them in binary distributions.
-
-\# system/lib/dlmalloc.c
-
-\# dlmalloc is in the public domain and so needs no acknowledgement.
-
-The JavaScript and KaiOS versions of Puzzles incorporate some third
-party software.  Most of it is licensed under the \i{MIT licence} (see
-\k{licence}) and requires the following \i{copyright} notices:
-
-\quote{
-
-\# system/lib/libc/emscripten_get_heap_size.c
-\# system/lib/libc/emscripten_memcpy.c
-\# system/lib/libc/emscripten_syscall_stubs.c
-\# system/lib/libc/wasi-helpers.c
-\# system/lib/pthread/library_pthread_stub.c
-\# system/lib/pthread/pthread_self_stub.c
-\# system/lib/sbrk.c
-
-\# These are parts of Emscripten and either refer explicitly to the
-Emscripten LICENSE file or make no mention of a licence.  LICENSE
-allows use under the MIT licence and specifies this copyright notice:
-
-Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
-
-\# cache/sysroot/include/math.h
-\# system/lib/libc/musl/src/ctype/*
-\# system/lib/libc/musl/src/env/*
-\# system/lib/libc/musl/src/errno/*
-\# system/lib/libc/musl/src/internal/atomic.h
-\# system/lib/libc/musl/src/internal/floatscan.c
-\# system/lib/libc/musl/src/internal/intscan.c
-\# system/lib/libc/musl/src/internal/shgetc.c
-\# system/lib/libc/musl/src/math/copysignl.c
-\# system/lib/libc/musl/src/math/fabs.c
-\# system/lib/libc/musl/src/math/fabsl.c
-\# system/lib/libc/musl/src/math/floor.c
-\# system/lib/libc/musl/src/math/fmodl.c
-\# system/lib/libc/musl/src/math/__fpclassifyl.c
-\# system/lib/libc/musl/src/math/frexp.c
-\# system/lib/libc/musl/src/math/scalbn.c
-\# system/lib/libc/musl/src/math/scalbnl.c
-\# system/lib/libc/musl/src/math/sqrtf.c
-\# system/lib/libc/musl/src/multibyte/*
-\# system/lib/libc/musl/src/stdio/*
-\# system/lib/libc/musl/src/stdlib/abs.c
-\# system/lib/libc/musl/src/stdlib/atof.c
-\# system/lib/libc/musl/src/stdlib/atoi.c
-\# system/lib/libc/musl/src/stdlib/atol.c
-\# system/lib/libc/musl/src/stdlib/labs.c
-\# system/lib/libc/musl/src/stdlib/qsort_nr.c
-\# system/lib/libc/musl/src/stdlib/strtod.c
-\# system/lib/libc/musl/src/stdlib/strtol.c
-\# system/lib/libc/musl/src/string/*
-\# system/lib/libc/musl/src/unistd/getpid.c
-
-\# These are parts of musl, which is licensed "as a whole" under the
-MIT licence.  These parts don't carry any licence notice themselves.
-This is the copyright notice from musl's COPYRIGHT file, modified to
-allow for non-Unicode targets:
-
-Copyright \u00A9{(C)} 2005-2020 Rich Felker, et al.
-
-\# system/lib/libc/musl/src/stdlib/qsort.c
-
-\# This is part of musl, but has its own copyright notice and MIT
-licence in its source file.
-
-Copyright (C) 2011 by Valentin Ochs
-
-}
-
-Other incorporated software requires these notices:
-
-\quote{
-
-\# system/lib/libc/musl/src/math/acosf.c
-\# system/lib/libc/musl/src/math/atan.c
-\# system/lib/libc/musl/src/math/cos.c
-\# system/lib/libc/musl/src/math/__cosdf.c
-\# system/lib/libc/musl/src/math/cosf.c
-\# system/lib/libc/musl/src/math/__rem_pio2f.c
-\# system/lib/libc/musl/src/math/sin.c
-\# system/lib/libc/musl/src/math/__sindf.c
-\# system/lib/libc/musl/src/math/sinf.c
-
-\# These are parts of musl with a SunPro copyright notice and licence.
-
-Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
-
-Developed at SunPro, a Sun Microsystems, Inc. business.
-Permission to use, copy, modify, and distribute this
-software is freely granted, provided that this notice
-is preserved.
-
-\# system/lib/libc/musl/src/math/atan2.c
-\# system/lib/libc/musl/src/math/__cos.c
-\# system/lib/libc/musl/src/math/__rem_pio2.c
-\# system/lib/libc/musl/src/math/__rem_pio2_large.c
-\# system/lib/libc/musl/src/math/__sin.c
-
-\# These are parts of musl with a SunSoft copyright notice and licence.
-
-Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
-
-Developed at SunSoft, a Sun Microsystems, Inc. business.
-Permission to use, copy, modify, and distribute this
-software is freely granted, provided that this notice
-is preserved.
-
-}
\ No newline at end of file
diff --git a/apps/plugins/puzzles/src/fuzzpuzz.c b/apps/plugins/puzzles/src/fuzzpuzz.c
deleted file mode 100644
index 3fb632ec57..0000000000
--- a/apps/plugins/puzzles/src/fuzzpuzz.c
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
- * fuzzpuzz.c: Fuzzing frontend to all puzzles.
- */
-
-/*
- * The idea here is that this front-end supports all back-ends and can
- * feed them save files.  It then asks the back-end to draw the puzzle
- * (through a null drawing API) and reserialises the state.  This
- * tests the deserialiser, the code for loading game descriptions, the
- * processing of move strings, the redraw code, and the serialisation
- * routines, but is still pretty quick.
- *
- * To use AFL++ to drive fuzzpuzz, you can do something like:
- *
- * CC=afl-cc cmake -B build-afl
- * cmake --build build-afl --target fuzzpuzz
- * mkdir fuzz-in && ln icons/''*.sav fuzz-in
- * afl-fuzz -i fuzz-in -o fuzz-out -x fuzzpuzz.dict -- build-afl/fuzzpuzz
- *
- * Similarly with Honggfuzz:
- *
- * CC=hfuzz-cc cmake -B build-honggfuzz
- * cmake --build build-honggfuzz --target fuzzpuzz
- * mkdir fuzz-corpus && ln icons/''*.sav fuzz-corpus
- * honggfuzz -s -i fuzz-corpus -w fuzzpuzz.dict -- build-honggfuzz/fuzzpuzz
- *
- * You can also use libFuzzer, though it's not really a good fit for
- * Puzzles.  The experimental forking mode seems to work OK:
- *
- * CC=clang cmake -B build-clang -DWITH_LIBFUZZER=Y
- * cmake --build build-clang --target fuzzpuzz
- * mkdir fuzz-corpus && ln icons/''*.sav fuzz-corpus
- * build-clang/fuzzpuzz -fork=1 -ignore_crashes=1 -dict=fuzzpuzz.dict \
- *   fuzz-corpus
- */
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#ifdef __AFL_FUZZ_TESTCASE_LEN
-# include <unistd.h> /* read() is used by __AFL_FUZZ_TESTCASE_LEN. */
-#endif
-
-#include "puzzles.h"
-
-#ifdef __AFL_FUZZ_INIT
-__AFL_FUZZ_INIT();
-#endif
-
-#ifdef HAVE_HF_ITER
-extern int HF_ITER(unsigned char **, size_t *);
-#endif
-
-/* This function is expected by libFuzzer. */
-
-int LLVMFuzzerTestOneInput(unsigned char *data, size_t size);
-
-static const char *fuzz_one(bool (*readfn)(void *, void *, int), void *rctx,
-                            void (*rewindfn)(void *),
-                            void (*writefn)(void *, const void *, int),
-                            void *wctx)
-{
-    const char *err;
-    char *gamename;
-    int i, w, h;
-    const game *ourgame = NULL;
-    static const drawing_api drapi = { NULL };
-    midend *me;
-
-    err = identify_game(&gamename, readfn, rctx);
-    if (err != NULL) return err;
-
-    for (i = 0; i < gamecount; i++)
-        if (strcmp(gamename, gamelist[i]->name) == 0)
-            ourgame = gamelist[i];
-    sfree(gamename);
-    if (ourgame == NULL)
-        return "Game not recognised";
-
-    me = midend_new(NULL, ourgame, &drapi, NULL);
-
-    rewindfn(rctx);
-    err = midend_deserialise(me, readfn, rctx);
-    if (err != NULL) {
-        midend_free(me);
-        return err;
-    }
-    w = h = INT_MAX;
-    midend_size(me, &w, &h, false, 1);
-    midend_redraw(me);
-    midend_serialise(me, writefn, wctx);
-    midend_free(me);
-    return NULL;
-}
-
-#if defined(__AFL_FUZZ_TESTCASE_LEN) || defined(HAVE_HF_ITER) || \
-    !defined(OMIT_MAIN)
-static void savefile_write(void *wctx, const void *buf, int len)
-{
-    FILE *fp = (FILE *)wctx;
-
-    fwrite(buf, 1, len, fp);
-}
-#endif
-
-struct memread {
-    const unsigned char *buf;
-    size_t pos;
-    size_t len;
-};
-
-static bool mem_read(void *wctx, void *buf, int len)
-{
-    struct memread *ctx = wctx;
-
-    if (ctx->pos + len > ctx->len) return false;
-    memcpy(buf, ctx->buf + ctx->pos, len);
-    ctx->pos += len;
-    return true;
-}
-
-static void mem_rewind(void *wctx)
-{
-    struct memread *ctx = wctx;
-
-    ctx->pos = 0;
-}
-
-static void null_write(void *wctx, const void *buf, int len)
-{
-}
-
-int LLVMFuzzerTestOneInput(unsigned char *data, size_t size) {
-    struct memread ctx;
-
-    ctx.buf = data;
-    ctx.len = size;
-    ctx.pos = 0;
-    fuzz_one(mem_read, &ctx, mem_rewind, null_write, NULL);
-    return 0;
-}
-
-#if defined(__AFL_FUZZ_TESTCASE_LEN) || defined(HAVE_HF_ITER)
-static const char *fuzz_one_mem(unsigned char *data, size_t size) {
-    struct memread ctx;
-
-    ctx.buf = data;
-    ctx.len = size;
-    ctx.pos = 0;
-    return fuzz_one(mem_read, &ctx, mem_rewind, savefile_write, stdout);
-}
-#endif
-
-/* 
- * Three different versions of main(), for standalone, AFL, and
- * Honggfuzz modes.  LibFuzzer brings its own main().
- */
-
-#ifdef OMIT_MAIN
-/* Nothing. */
-#elif defined(__AFL_FUZZ_TESTCASE_LEN)
-/*
- * AFL persistent mode, where we fuzz from a RAM buffer provided
- * by AFL in a loop.  This version can still be run standalone if
- * necessary, for instance to diagnose a crash.
- */
-int main(int argc, char **argv)
-{
-    const char *err;
-    int ret;
-
-    if (argc != 1) {
-        fprintf(stderr, "usage: %s\n", argv[0]);
-        return 1;
-    }
-#ifdef __AFL_HAVE_MANUAL_CONTROL
-    __AFL_INIT();
-#endif
-    while (__AFL_LOOP(10000)) {
-        err = fuzz_one_mem(__AFL_FUZZ_TESTCASE_BUF, __AFL_FUZZ_TESTCASE_LEN);
-        if (err != NULL) {
-            fprintf(stderr, "%s\n", err);
-            ret = 1;
-        } else
-            ret = 0;
-    }
-    return ret;
-}
-#elif defined(HAVE_HF_ITER)
-/*
- * Honggfuzz persistent mode.  Unlike AFL persistent mode, the
- * resulting executable cannot be run outside of Honggfuzz.
- */
-int main(int argc, char **argv)
-{
-    if (argc != 1) {
-        fprintf(stderr, "usage: %s\n", argv[0]);
-        return 1;
-    }
-    while (true) {
-        unsigned char *testcase_buf;
-        size_t testcase_len;
-        HF_ITER(&testcase_buf, &testcase_len);
-        fuzz_one_mem(testcase_buf, testcase_len);
-    }
-}
-#else
-/*
- * Stand-alone mode: just handle a single test case on stdin.
- */
-static bool savefile_read(void *wctx, void *buf, int len)
-{
-    FILE *fp = (FILE *)wctx;
-    int ret;
-
-    ret = fread(buf, 1, len, fp);
-    return (ret == len);
-}
-
-static void savefile_rewind(void *wctx)
-{
-    FILE *fp = (FILE *)wctx;
-
-    rewind(fp);
-}
-
-int main(int argc, char **argv)
-{
-    const char *err;
-
-    if (argc != 1) {
-        fprintf(stderr, "usage: %s\n", argv[0]);
-        return 1;
-    }
-
-    /* Might in theory use this mode under AFL. */
-#ifdef __AFL_HAVE_MANUAL_CONTROL
-    __AFL_INIT();
-#endif
-
-    err = fuzz_one(savefile_read, stdin, savefile_rewind,
-                   savefile_write, stdout);
-    if (err != NULL) {
-        fprintf(stderr, "%s\n", err);
-        return 1;
-    }
-    return 0;
-}
-#endif
diff --git a/apps/plugins/puzzles/src/gtk.c b/apps/plugins/puzzles/src/gtk.c
deleted file mode 100644
index a40a70187f..0000000000
--- a/apps/plugins/puzzles/src/gtk.c
+++ /dev/null
@@ -1,4399 +0,0 @@
-/*
- * gtk.c: GTK front end for my puzzle collection.
- */
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE 1 /* for strcasestr */
-#endif
-
-#include <stdio.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <time.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-#ifdef NO_TGMATH_H
-#  include <math.h>
-#else
-#  include <tgmath.h>
-#endif
-#include <unistd.h>
-
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-
-#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 <X11/Xatom.h>
-
-#include "puzzles.h"
-#include "gtk.h"
-
-#if GTK_CHECK_VERSION(2,0,0)
-# 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 defined USE_CAIRO && GTK_CHECK_VERSION(2,10,0)
-/* We can only use printing if we are using Cairo for drawing and we
-   have a GTK version >= 2.10 (when GtkPrintOperation was added). */
-# define USE_PRINTING
-# if GTK_CHECK_VERSION(2,18,0)
-/* We can embed the page setup. Before 2.18, we needed to have a
-   separate page setup. */
-#  define USE_EMBED_PAGE_SETUP
-# 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;
-
-static void dputs(const char *buf)
-{
-    if (!debug_fp) {
-        debug_fp = fopen("debug.log", "w");
-    }
-
-    fputs(buf, stderr);
-
-    if (debug_fp) {
-        fputs(buf, debug_fp);
-        fflush(debug_fp);
-    }
-}
-
-void debug_printf(const char *fmt, ...)
-{
-    char buf[4096];
-    va_list ap;
-
-    va_start(ap, fmt);
-    vsprintf(buf, fmt, ap);
-    dputs(buf);
-    va_end(ap);
-}
-#endif
-
-/* ----------------------------------------------------------------------
- * Error reporting functions used elsewhere.
- */
-
-void fatal(const char *fmt, ...)
-{
-    va_list ap;
-
-    fprintf(stderr, "fatal error: ");
-
-    va_start(ap, fmt);
-    vfprintf(stderr, fmt, ap);
-    va_end(ap);
-
-    fprintf(stderr, "\n");
-    exit(1);
-}
-
-/* ----------------------------------------------------------------------
- * GTK front end to puzzles.
- */
-
-static void changed_preset(frontend *fe);
-static void load_prefs(frontend *fe);
-static char *save_prefs(frontend *fe);
-
-struct font {
-#ifdef USE_PANGO
-    PangoFontDescription *desc;
-#else
-    GdkFont *font;
-#endif
-    int type;
-    int size;
-};
-
-/*
- * An internal API for functions which need to be different for
- * printing and drawing.
- */
-struct internal_drawing_api {
-    void (*set_colour)(frontend *fe, int colour);
-#ifdef USE_CAIRO
-    void (*fill)(frontend *fe);
-    void (*fill_preserve)(frontend *fe);
-#endif
-};
-
-/*
- * This structure holds all the data relevant to a single window.
- * In principle this would allow us to open multiple independent
- * puzzle windows, although I can't currently see any real point in
- * doing so. I'm just coding cleanly because there's no
- * particularly good reason not to.
- */
-struct frontend {
-    bool headless; /* true if we're running without GTK, for --screenshot */
-
-    GtkWidget *window;
-    GtkAccelGroup *dummy_accelgroup;
-    GtkWidget *area;
-    GtkWidget *statusbar;
-    GtkWidget *menubar;
-#if GTK_CHECK_VERSION(3,20,0)
-    GtkCssProvider *css_provider;
-#endif
-    guint statusctx;
-    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;
-    bool timer_active;
-    int timer_id;
-    struct timeval last_time;
-    struct font *fonts;
-    int nfonts, fontsize;
-    config_item *cfg;
-    int cfg_which;
-    bool cfgret;
-    GtkWidget *cfgbox;
-    void *paste_data;
-    int paste_data_len;
-    int pw, ph, ps;  /* pixmap size (w, h are area size, s is GDK scale) */
-    int ox, oy;                        /* offset of pixmap in drawing area */
-#ifdef OLD_FILESEL
-    char *filesel_name;
-#endif
-    GSList *preset_radio;
-    bool preset_threaded;
-    GtkWidget *preset_custom;
-    GtkWidget *copy_menu_item;
-#if !GTK_CHECK_VERSION(3,0,0)
-    bool drawing_area_shrink_pending;
-    bool menubar_is_local;
-#endif
-#if GTK_CHECK_VERSION(3,0,0)
-    /*
-     * This is used to get round an annoying lack of GTK notification
-     * message. If we request a window resize with
-     * gtk_window_resize(), we normally get back a "configure" event
-     * on the window and on its drawing area, and we respond to the
-     * latter by doing an appropriate resize of the puzzle. If the
-     * window is maximised, so that gtk_window_resize() _doesn't_
-     * change its size, then that configure event never shows up. But
-     * if we requested the resize in response to a change of puzzle
-     * parameters (say, the user selected a differently-sized preset
-     * from the menu), then we would still like to be _notified_ that
-     * the window size was staying the same, so that we can respond by
-     * choosing an appropriate tile size for the new puzzle preset in
-     * the existing window size.
-     *
-     * Fortunately, in GTK 3, we may not get a "configure" event on
-     * the drawing area in this situation, but we still get a
-     * "size_allocate" event on the whole window (which, in other
-     * situations when we _do_ get a "configure" on the area, turns up
-     * second). So we treat _that_ event as indicating that if the
-     * "configure" event hasn't already shown up then it's not going
-     * to arrive.
-     *
-     * This flag is where we bookkeep this system. On
-     * gtk_window_resize we set this flag to true; the area's
-     * configure handler sets it back to false; then if that doesn't
-     * happen, the window's size_allocate handler does a fallback
-     * puzzle resize when it sees this flag still set to true.
-     */
-    bool awaiting_resize_ack;
-#endif
-#ifdef USE_CAIRO
-    int printcount, printw, printh;
-    float printscale;
-    bool printsolns, printcolour;
-    int hatch;
-    float hatchthick, hatchspace;
-    drawing *print_dr;
-    document *doc;
-#endif
-#ifdef USE_PRINTING
-    GtkPrintOperation *printop;
-    GtkPrintContext *printcontext;
-    GtkSpinButton *printcount_spin_button, *printw_spin_button,
-        *printh_spin_button, *printscale_spin_button;
-    GtkCheckButton *soln_check_button, *colour_check_button;
-#endif
-    const struct internal_drawing_api *dr_api;
-};
-
-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)
-{
-    struct timeval *tvp = snew(struct timeval);
-    gettimeofday(tvp, NULL);
-    *randseed = (void *)tvp;
-    *randseedsize = sizeof(struct timeval);
-}
-
-void frontend_default_colour(frontend *fe, float *output)
-{
-#if !GTK_CHECK_VERSION(3,0,0)
-    if (!fe->headless) {
-        /*
-         * If we have a widget and it has a style that specifies a
-         * default background colour, use that 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;
-    }
-#endif
-
-    /*
-     * 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.
-     *
-     * This is also what we do on GTK 2 in headless mode, where we
-     * don't have a widget style to query.
-     */
-    output[0] = output[1] = output[2] = 0.9F;
-}
-
-static void gtk_status_bar(void *handle, const char *text)
-{
-    frontend *fe = (frontend *)handle;
-
-    if (fe->headless)
-        return;
-
-    assert(fe->statusbar);
-
-    gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx);
-    gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, text);
-}
-
-/* ----------------------------------------------------------------------
- * Cairo drawing functions.
- */
-
-#ifdef USE_CAIRO
-
-static void setup_drawing(frontend *fe)
-{
-    fe->cr = cairo_create(fe->image);
-    cairo_scale(fe->cr, fe->ps, fe->ps);
-    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);
-}
-
-static void teardown_drawing(frontend *fe)
-{
-    cairo_destroy(fe->cr);
-    fe->cr = NULL;
-
-#ifndef USE_CAIRO_WITHOUT_PIXMAP
-    if (!fe->headless) {
-        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
-}
-
-static void snaffle_colours(frontend *fe)
-{
-    fe->colours = midend_colours(fe->me, &fe->ncolours);
-}
-
-static void draw_set_colour(frontend *fe, int colour)
-{
-    cairo_set_source_rgb(fe->cr,
-                         fe->colours[3*colour + 0],
-                         fe->colours[3*colour + 1],
-                         fe->colours[3*colour + 2]);
-}
-
-static void print_set_colour(frontend *fe, int colour)
-{
-    float r, g, b;
-
-    print_get_colour(fe->print_dr, colour, fe->printcolour,
-                     &(fe->hatch), &r, &g, &b);
-
-    if (fe->hatch < 0)
-        cairo_set_source_rgb(fe->cr, r, g, b);
-}
-
-static void set_window_background(frontend *fe, int colour)
-{
-#if GTK_CHECK_VERSION(3,0,0)
-    /* In case the user's chosen theme is dark, we should not override
-     * the background colour for the whole window as this makes the
-     * menu and status bars unreadable. This might be visible through
-     * the gtk-application-prefer-dark-theme flag or else we have to
-     * work it out from the name. */
-    gboolean dark_theme = false;
-    char *theme_name = NULL;
-    g_object_get(gtk_settings_get_default(),
-                 "gtk-application-prefer-dark-theme", &dark_theme,
-                 "gtk-theme-name", &theme_name,
-                 NULL);
-    if (theme_name && strcasestr(theme_name, "-dark"))
-        dark_theme = true;
-    g_free(theme_name);
-#if GTK_CHECK_VERSION(3,20,0)
-    char css_buf[512];
-    sprintf(css_buf, ".background { "
-            "background-color: #%02x%02x%02x; }",
-            (unsigned)(fe->colours[3*colour + 0] * 255),
-            (unsigned)(fe->colours[3*colour + 1] * 255),
-            (unsigned)(fe->colours[3*colour + 2] * 255));
-    if (!fe->css_provider)
-        fe->css_provider = gtk_css_provider_new();
-    if (!gtk_css_provider_load_from_data(
-            GTK_CSS_PROVIDER(fe->css_provider), css_buf, -1, NULL))
-        assert(0 && "Couldn't load CSS");
-    if (!dark_theme) {
-        gtk_style_context_add_provider(
-            gtk_widget_get_style_context(fe->window),
-            GTK_STYLE_PROVIDER(fe->css_provider),
-            GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
-    }
-    gtk_style_context_add_provider(
-        gtk_widget_get_style_context(fe->area),
-        GTK_STYLE_PROVIDER(fe->css_provider),
-        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
-#else // still at least GTK 3.0 but less than 3.20
-    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);
-    if (!dark_theme)
-        gdk_window_set_background_rgba(gtk_widget_get_window(fe->window),
-                                       &rgba);
-#endif // GTK_CHECK_VERSION(3,20,0)
-#else // GTK 2 version comes next
-    GdkColormap *colmap;
-
-    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
-}
-
-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_hatch(frontend *fe)
-{
-    double i, x, y, width, height, maxdim;
-
-    /* Get the dimensions of the region to be hatched. */
-    cairo_path_extents(fe->cr, &x, &y, &width, &height);
-
-    maxdim = max(width, height);
-
-    cairo_save(fe->cr);
-
-    /* Set the line color and width. */
-    cairo_set_source_rgb(fe->cr, 0, 0, 0);
-    cairo_set_line_width(fe->cr, fe->hatchthick);
-    /* Clip to the region. */
-    cairo_clip(fe->cr);
-    /* Hatch the bounding area of the fill region. */
-    if (fe->hatch == HATCH_VERT || fe->hatch == HATCH_PLUS) {
-        for (i = 0.0; i <= width; i += fe->hatchspace) {
-            cairo_move_to(fe->cr, i, 0);
-            cairo_rel_line_to(fe->cr, 0, height);
-        }
-    }
-    if (fe->hatch == HATCH_HORIZ || fe->hatch == HATCH_PLUS) {
-        for (i = 0.0; i <= height; i += fe->hatchspace) {
-            cairo_move_to(fe->cr, 0, i);
-            cairo_rel_line_to(fe->cr, width, 0);
-        }
-    }
-    if (fe->hatch == HATCH_SLASH || fe->hatch == HATCH_X) {
-        for (i = -height; i <= width; i += fe->hatchspace * ROOT2) {
-            cairo_move_to(fe->cr, i, 0);
-            cairo_rel_line_to(fe->cr, maxdim, maxdim);
-        }
-    }
-    if (fe->hatch == HATCH_BACKSLASH || fe->hatch == HATCH_X) {
-        for (i = 0.0; i <= width + height; i += fe->hatchspace * ROOT2) {
-            cairo_move_to(fe->cr, i, 0);
-            cairo_rel_line_to(fe->cr, -maxdim, maxdim);
-        }
-    }
-    cairo_stroke(fe->cr);
-
-    cairo_restore(fe->cr);
-}
-
-static void do_draw_fill(frontend *fe)
-{
-    cairo_fill(fe->cr);
-}
-
-static void do_draw_fill_preserve(frontend *fe)
-{
-    cairo_fill_preserve(fe->cr);
-}
-
-static void do_print_fill(frontend *fe)
-{
-    if (fe->hatch < 0)
-        cairo_fill(fe->cr);
-    else
-        do_hatch(fe);
-}
-
-static void do_print_fill_preserve(frontend *fe)
-{
-    if (fe->hatch < 0) {
-        cairo_fill_preserve(fe->cr);
-    } else {
-        cairo_path_t *oldpath;
-        oldpath = cairo_copy_path(fe->cr);
-        do_hatch(fe);
-        cairo_append_path(fe->cr, oldpath);
-    }
-}
-
-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);
-    fe->dr_api->fill(fe);
-    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, const int *coords, int npoints,
-                         int fillcolour, int outlinecolour)
-{
-    int i;
-
-    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) {
-        fe->dr_api->set_colour(fe, fillcolour);
-        fe->dr_api->fill_preserve(fe);
-    }
-    assert(outlinecolour >= 0);
-    fe->dr_api->set_colour(fe, outlinecolour);
-    cairo_stroke(fe->cr);
-}
-
-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) {
-        fe->dr_api->set_colour(fe, fillcolour);
-        fe->dr_api->fill_preserve(fe);
-    }
-    assert(outlinecolour >= 0);
-    fe->dr_api->set_colour(fe, outlinecolour);
-    cairo_stroke(fe->cr);
-}
-
-static void setup_blitter(blitter *bl, int w, int h)
-{
-    bl->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24, w, h);
-}
-
-static void teardown_blitter(blitter *bl)
-{
-    cairo_surface_destroy(bl->image);
-}
-
-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_maybe_destroy_cairo(frontend *fe, cairo_t *cr,
-                                         bool destroy)
-{
-    cairo_set_source_rgb(cr, fe->colours[0], fe->colours[1], fe->colours[2]);
-    cairo_paint(cr);
-    if (destroy)
-        cairo_destroy(cr);
-}
-
-static void setup_backing_store(frontend *fe)
-{
-#ifndef USE_CAIRO_WITHOUT_PIXMAP
-    if (!fe->headless) {
-        fe->pixmap = gdk_pixmap_new(gtk_widget_get_window(fe->area),
-                                    fe->pw*fe->ps, fe->ph*fe->ps, -1);
-    } else {
-        fe->pixmap = NULL;
-    }
-#endif
-
-    fe->image = cairo_image_surface_create(CAIRO_FORMAT_RGB24,
-                                           fe->pw*fe->ps, fe->ph*fe->ps);
-
-    wipe_and_maybe_destroy_cairo(fe, cairo_create(fe->image), true);
-#ifndef USE_CAIRO_WITHOUT_PIXMAP
-    if (!fe->headless)
-        wipe_and_maybe_destroy_cairo(fe, gdk_cairo_create(fe->pixmap), true);
-#endif
-    if (!fe->headless) {
-#if GTK_CHECK_VERSION(3,22,0)
-        GdkWindow *gdkwin;
-        cairo_region_t *region;
-        GdkDrawingContext *drawctx;
-        cairo_t *cr;
-
-        gdkwin = gtk_widget_get_window(fe->area);
-        region = gdk_window_get_clip_region(gdkwin);
-        drawctx = gdk_window_begin_draw_frame(gdkwin, region);
-        cr = gdk_drawing_context_get_cairo_context(drawctx);
-        wipe_and_maybe_destroy_cairo(fe, cr, false);
-        gdk_window_end_draw_frame(gdkwin, drawctx);
-        cairo_region_destroy(region);
-#else
-        wipe_and_maybe_destroy_cairo(
-            fe, gdk_cairo_create(gtk_widget_get_window(fe->area)), true);
-#endif
-    }
-}
-
-static bool backing_store_ok(frontend *fe)
-{
-    return fe->image != NULL;
-}
-
-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;
-}
-
-#endif
-
-/* ----------------------------------------------------------------------
- * GDK drawing functions.
- */
-
-#ifndef USE_CAIRO
-
-static void setup_drawing(frontend *fe)
-{
-    fe->gc = gdk_gc_new(fe->area->window);
-}
-
-static void teardown_drawing(frontend *fe)
-{
-    gdk_gc_unref(fe->gc);
-    fe->gc = NULL;
-}
-
-static void snaffle_colours(frontend *fe)
-{
-    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);
-        }
-    }
-}
-
-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]);
-}
-
-static void draw_set_colour(frontend *fe, int colour)
-{
-    gdk_gc_set_foreground(fe->gc, &fe->colours[colour]);
-}
-
-#ifdef USE_PANGO
-static PangoLayout *make_pango_layout(frontend *fe)
-{
-    return (pango_layout_new(gtk_widget_get_pango_context(fe->area)));
-}
-
-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;
-
-    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);
-}
-
-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)
-{
-    gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h);
-}
-
-static void do_draw_line(frontend *fe, int x1, int y1, int x2, int y2)
-{
-    gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2);
-}
-
-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, const int *coords, int npoints,
-                         int fillcolour, int outlinecolour)
-{
-    GdkPoint *points = snewn(npoints, GdkPoint);
-    int i;
-
-    for (i = 0; i < npoints; i++) {
-        points[i].x = coords[i*2];
-        points[i].y = coords[i*2+1];
-    }
-
-    if (fillcolour >= 0) {
-        fe->dr_api->set_colour(fe, fillcolour);
-        gdk_draw_polygon(fe->pixmap, fe->gc, true, points, npoints);
-    }
-    assert(outlinecolour >= 0);
-    fe->dr_api->set_colour(fe, outlinecolour);
-
-    /*
-     * In principle we ought to be able to use gdk_draw_polygon for
-     * the outline as well. In fact, it turns out to interact badly
-     * with a clipping region, for no terribly obvious reason, so I
-     * draw the outline as a sequence of lines instead.
-     */
-    for (i = 0; i < npoints; i++)
-        gdk_draw_line(fe->pixmap, fe->gc,
-                      points[i].x, points[i].y,
-                      points[(i+1)%npoints].x, points[(i+1)%npoints].y);
-
-    sfree(points);
-}
-
-static void do_draw_circle(frontend *fe, int cx, int cy, int radius,
-                           int fillcolour, int outlinecolour)
-{
-    if (fillcolour >= 0) {
-        fe->dr_api->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);
-    fe->dr_api->set_colour(fe, outlinecolour);
-    gdk_draw_arc(fe->pixmap, fe->gc, false,
-                 cx - radius, cy - radius,
-                 2 * radius, 2 * radius, 0, 360 * 64);
-}
-
-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.
-     */
-    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;
-
-    if (fe->headless) {
-        fprintf(stderr, "headless mode does not work with GDK drawing\n");
-        exit(1);
-    }
-
-    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.
- */
-
-static 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);
-}
-
-static void gtk_clip(void *handle, int x, int y, int w, int h)
-{
-    frontend *fe = (frontend *)handle;
-    do_clip(fe, x, y, w, h);
-}
-
-static void gtk_unclip(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-    do_unclip(fe);
-}
-
-static void gtk_draw_text(void *handle, int x, int y, int fonttype,
-                          int fontsize, int align, int colour,
-                          const 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.
-     */
-    fe->dr_api->set_colour(fe, colour);
-    align_and_draw_text(fe, i, align, x, y, text);
-}
-
-static void gtk_draw_rect(void *handle, int x, int y, int w, int h, int colour)
-{
-    frontend *fe = (frontend *)handle;
-    fe->dr_api->set_colour(fe, colour);
-    do_draw_rect(fe, x, y, w, h);
-}
-
-static void gtk_draw_line(void *handle, int x1, int y1, int x2, int y2,
-                          int colour)
-{
-    frontend *fe = (frontend *)handle;
-    fe->dr_api->set_colour(fe, colour);
-    do_draw_line(fe, x1, y1, x2, y2);
-}
-
-static void gtk_draw_thick_line(void *handle, float thickness,
-                                float x1, float y1, float x2, float y2,
-                                int colour)
-{
-    frontend *fe = (frontend *)handle;
-    fe->dr_api->set_colour(fe, colour);
-    do_draw_thick_line(fe, thickness, x1, y1, x2, y2);
-}
-
-static void gtk_draw_poly(void *handle, const int *coords, int npoints,
-                          int fillcolour, int outlinecolour)
-{
-    frontend *fe = (frontend *)handle;
-    do_draw_poly(fe, coords, npoints, fillcolour, outlinecolour);
-}
-
-static 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);
-}
-
-static 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;
-}
-
-static void gtk_blitter_free(void *handle, blitter *bl)
-{
-    teardown_blitter(bl);
-    sfree(bl);
-}
-
-static void gtk_blitter_save(void *handle, blitter *bl, int x, int y)
-{
-    frontend *fe = (frontend *)handle;
-    do_blitter_save(fe, bl, x, y);
-    bl->x = x;
-    bl->y = y;
-}
-
-static void gtk_blitter_load(void *handle, blitter *bl, int x, int y)
-{
-    frontend *fe = (frontend *)handle;
-    if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) {
-        x = bl->x;
-        y = bl->y;
-    }
-    do_blitter_load(fe, bl, x, y);
-}
-
-static void gtk_draw_update(void *handle, int x, int y, int w, int h)
-{
-    frontend *fe = (frontend *)handle;
-    if (fe->bbox_l > x  ) fe->bbox_l = x  ;
-    if (fe->bbox_r < x+w) fe->bbox_r = x+w;
-    if (fe->bbox_u > y  ) fe->bbox_u = y  ;
-    if (fe->bbox_d < y+h) fe->bbox_d = y+h;
-}
-
-static void gtk_end_draw(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-
-    teardown_drawing(fe);
-
-    if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d && !fe->headless) {
-#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
-static 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
-
-#ifdef USE_PRINTING
-static void gtk_begin_doc(void *handle, int pages)
-{
-    frontend *fe = (frontend *)handle;
-    gtk_print_operation_set_n_pages(fe->printop, pages);
-}
-
-static void gtk_begin_page(void *handle, int number)
-{
-}
-
-static void gtk_begin_puzzle(void *handle, float xm, float xc,
-                             float ym, float yc, int pw, int ph, float wmm)
-{
-    frontend *fe = (frontend *)handle;
-    double ppw, pph, pox, poy, dpmmx, dpmmy;
-    double scale;
-
-    ppw = gtk_print_context_get_width(fe->printcontext);
-    pph = gtk_print_context_get_height(fe->printcontext);
-    dpmmx = gtk_print_context_get_dpi_x(fe->printcontext) / 25.4;
-    dpmmy = gtk_print_context_get_dpi_y(fe->printcontext) / 25.4;
-
-    /*
-     * Compute the puzzle's position in pixels on the logical page.
-     */
-    pox = xm * ppw + xc * dpmmx;
-    poy = ym * pph + yc * dpmmy;
-
-    /*
-     * And determine the scale.
-     *
-     * I need a scale such that the maximum puzzle-coordinate
-     * extent of the rectangle (pw * scale) is equal to the pixel
-     * equivalent of the puzzle's millimetre width (wmm * dpmmx).
-     */
-    scale = wmm * dpmmx / pw;
-
-    /*
-     * Now instruct Cairo to transform points based on our calculated
-     * values (order here *is* important).
-     */
-    cairo_save(fe->cr);
-    cairo_translate(fe->cr, pox, poy);
-    cairo_scale(fe->cr, scale, scale);
-
-    fe->hatchthick = 0.2 * pw / wmm;
-    fe->hatchspace = 1.0 * pw / wmm;
-}
-
-static void gtk_end_puzzle(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-    cairo_restore(fe->cr);
-}
-
-static void gtk_end_page(void *handle, int number)
-{
-}
-
-static void gtk_end_doc(void *handle)
-{
-}
-
-static void gtk_line_width(void *handle, float width)
-{
-    frontend *fe = (frontend *)handle;
-    cairo_set_line_width(fe->cr, width);
-}
-
-static void gtk_line_dotted(void *handle, bool dotted)
-{
-    frontend *fe = (frontend *)handle;
-
-    if (dotted) {
-        const double dash = 35.0;
-        cairo_set_dash(fe->cr, &dash, 1, 0);
-    } else {
-        cairo_set_dash(fe->cr, NULL, 0, 0);
-    }
-}
-#endif /* USE_PRINTING */
-
-static const struct internal_drawing_api internal_drawing = {
-    draw_set_colour,
-#ifdef USE_CAIRO
-    do_draw_fill,
-    do_draw_fill_preserve,
-#endif
-};
-
-#ifdef USE_CAIRO
-static const struct internal_drawing_api internal_printing = {
-    print_set_colour,
-    do_print_fill,
-    do_print_fill_preserve,
-};
-#endif
-
-static const struct drawing_api gtk_drawing = {
-    gtk_draw_text,
-    gtk_draw_rect,
-    gtk_draw_line,
-    gtk_draw_poly,
-    gtk_draw_circle,
-    gtk_draw_update,
-    gtk_clip,
-    gtk_unclip,
-    gtk_start_draw,
-    gtk_end_draw,
-    gtk_status_bar,
-    gtk_blitter_new,
-    gtk_blitter_free,
-    gtk_blitter_save,
-    gtk_blitter_load,
-#ifdef USE_PRINTING
-    gtk_begin_doc,
-    gtk_begin_page,
-    gtk_begin_puzzle,
-    gtk_end_puzzle,
-    gtk_end_page,
-    gtk_end_doc,
-    gtk_line_width,
-    gtk_line_dotted,
-#else
-    NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
-    NULL, NULL,                        /* line_width, line_dotted */
-#endif
-#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)
-{
-    frontend *fe = (frontend *)data;
-    deactivate_timer(fe);
-    midend_free(fe->me);
-    gtk_main_quit();
-}
-
-static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    int keyval;
-    int shift = (event->state & GDK_SHIFT_MASK) ? MOD_SHFT : 0;
-    int ctrl = (event->state & GDK_CONTROL_MASK) ? MOD_CTRL : 0;
-
-    if (!backing_store_ok(fe))
-        return true;
-
-    /* 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_KEY_KP_Up ||
-             event->keyval == GDK_KEY_KP_8)
-        keyval = MOD_NUM_KEYPAD | '8';
-    else if (event->keyval == GDK_KEY_Down)
-        keyval = shift | ctrl | CURSOR_DOWN;
-    else if (event->keyval == GDK_KEY_KP_Down ||
-             event->keyval == GDK_KEY_KP_2)
-        keyval = MOD_NUM_KEYPAD | '2';
-    else if (event->keyval == GDK_KEY_Left)
-        keyval = shift | ctrl | CURSOR_LEFT;
-    else if (event->keyval == GDK_KEY_KP_Left ||
-             event->keyval == GDK_KEY_KP_4)
-        keyval = MOD_NUM_KEYPAD | '4';
-    else if (event->keyval == GDK_KEY_Right)
-        keyval = shift | ctrl | CURSOR_RIGHT;
-    else if (event->keyval == GDK_KEY_KP_Right ||
-             event->keyval == GDK_KEY_KP_6)
-        keyval = MOD_NUM_KEYPAD | '6';
-    else if (event->keyval == GDK_KEY_KP_Home ||
-             event->keyval == GDK_KEY_KP_7)
-        keyval = MOD_NUM_KEYPAD | '7';
-    else if (event->keyval == GDK_KEY_KP_End ||
-             event->keyval == GDK_KEY_KP_1)
-        keyval = MOD_NUM_KEYPAD | '1';
-    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_KEY_KP_Page_Down ||
-             event->keyval == GDK_KEY_KP_3)
-        keyval = MOD_NUM_KEYPAD | '3';
-    else if (event->keyval == GDK_KEY_KP_Insert ||
-             event->keyval == GDK_KEY_KP_0)
-        keyval = MOD_NUM_KEYPAD | '0';
-    else if (event->keyval == GDK_KEY_KP_Begin ||
-             event->keyval == GDK_KEY_KP_5)
-        keyval = MOD_NUM_KEYPAD | '5';
-    else if (event->keyval == GDK_KEY_BackSpace ||
-             event->keyval == GDK_KEY_Delete ||
-             event->keyval == GDK_KEY_KP_Delete)
-        keyval = '\177';
-    else if ((event->keyval == 'z' || event->keyval == 'Z') && shift && ctrl)
-        keyval = UI_REDO;
-    else if (event->keyval == GDK_KEY_ISO_Left_Tab) {
-        /* SHIFT+TAB gets special handling. Ref:
-         * https://mail.gnome.org/archives/gtk-list/1999-August/msg00145.html */
-        keyval = '\t' | MOD_SHFT;
-    }
-    else if (event->string[0] && !event->string[1])
-        keyval = (unsigned char)event->string[0];
-    else
-        keyval = -1;
-
-    if (keyval >= 0 &&
-        midend_process_key(fe->me, 0, 0, keyval) == PKR_QUIT)
-        gtk_widget_destroy(fe->window);
-
-    return true;
-}
-
-static gint button_event(GtkWidget *widget, GdkEventButton *event,
-                         gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    int button;
-
-    if (!backing_store_ok(fe))
-        return true;
-
-    if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE)
-        return true;
-
-    if (event->button == 2 || (event->state & GDK_SHIFT_MASK))
-        button = MIDDLE_BUTTON;
-    else if (event->button == 3 || (event->state & GDK_MOD1_MASK))
-        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 && button >= LEFT_BUTTON)
-        button += LEFT_RELEASE - LEFT_BUTTON;
-
-    if (midend_process_key(fe->me, event->x - fe->ox,
-                           event->y - fe->oy, button) == PKR_QUIT)
-        gtk_widget_destroy(fe->window);
-
-    return true;
-}
-
-static gint motion_event(GtkWidget *widget, GdkEventMotion *event,
-                         gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    int button;
-
-    if (!backing_store_ok(fe))
-        return true;
-
-    if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK))
-        button = MIDDLE_DRAG;
-    else if (event->state & GDK_BUTTON1_MASK)
-        button = LEFT_DRAG;
-    else if (event->state & GDK_BUTTON3_MASK)
-        button = RIGHT_DRAG;
-    else
-        return false;                  /* don't even know what button! */
-
-    if (midend_process_key(fe->me, event->x - fe->ox,
-                           event->y - fe->oy, button) == PKR_QUIT)
-        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;
-
-    cairo_surface_t *target_surface = cairo_get_target(cr);
-    cairo_matrix_t m;
-    cairo_get_matrix(cr, &m);
-    double orig_sx, orig_sy;
-    cairo_surface_get_device_scale(target_surface, &orig_sx, &orig_sy);
-    cairo_surface_set_device_scale(target_surface, 1.0, 1.0);
-    cairo_translate(cr, m.x0 * (orig_sx - 1.0), m.y0 * (orig_sy - 1.0));
-
-    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);
-
-    cairo_surface_set_device_scale(target_surface, orig_sx, orig_sy);
-
-    return true;
-}
-#else
-static gint expose_area(GtkWidget *widget, GdkEventExpose *event,
-                        gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    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)
-{
-    frontend *fe = (frontend *)data;
-
-    /*
-     * Apparently we need to do this because otherwise the status
-     * bar will fail to update immediately. Annoying, but there we
-     * go.
-     */
-    gtk_widget_queue_draw(fe->window);
-
-    return true;
-}
-
-static void resize_puzzle_to_area(frontend *fe, int x, int y)
-{
-    int oldw = fe->w, oldpw = fe->pw, oldh = fe->h, oldph = fe->ph;
-    int oldps = fe->ps;
-
-    fe->w = x;
-    fe->h = y;
-    midend_size(fe->me, &x, &y, true, 1.0);
-    fe->pw = x;
-    fe->ph = y;
-#if GTK_CHECK_VERSION(3,10,0)
-    fe->ps = gtk_widget_get_scale_factor(fe->area);
-#else
-    fe->ps = 1;
-#endif
-    fe->ox = (fe->w - fe->pw) / 2;
-    fe->oy = (fe->h - fe->ph) / 2;
-
-    if (oldw != fe->w || oldpw != fe->pw || oldps != fe->ps ||
-        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);
-}
-
-static gint configure_area(GtkWidget *widget,
-                           GdkEventConfigure *event, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    resize_puzzle_to_area(fe, event->width, event->height);
-#if GTK_CHECK_VERSION(3,0,0)
-    fe->awaiting_resize_ack = false;
-#endif
-    return true;
-}
-
-#if GTK_CHECK_VERSION(3,0,0)
-static void window_size_alloc(GtkWidget *widget, GtkAllocation *allocation,
-                              gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    if (fe->awaiting_resize_ack) {
-        GtkAllocation a;
-        gtk_widget_get_allocation(fe->area, &a);
-        resize_puzzle_to_area(fe, a.width, a.height);
-        fe->awaiting_resize_ack = false;
-    }
-}
-#endif
-
-static gint timer_func(gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    if (fe->timer_active) {
-        struct timeval now;
-        float elapsed;
-        gettimeofday(&now, NULL);
-        elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F +
-                   (now.tv_sec - fe->last_time.tv_sec));
-        midend_timer(fe->me, elapsed);  /* may clear timer_active */
-        fe->last_time = now;
-    }
-
-    return fe->timer_active;
-}
-
-void deactivate_timer(frontend *fe)
-{
-    if (!fe)
-        return;                        /* can happen due to --generate */
-    if (fe->timer_active)
-        g_source_remove(fe->timer_id);
-    fe->timer_active = false;
-}
-
-void activate_timer(frontend *fe)
-{
-    if (!fe)
-        return;                        /* can happen due to --generate */
-    if (!fe->timer_active) {
-        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 gint win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
-{
-    GObject *cancelbutton = G_OBJECT(data);
-
-    /*
-     * `Escape' effectively clicks the cancel button
-     */
-    if (event->keyval == GDK_KEY_Escape) {
-        g_signal_emit_by_name(cancelbutton, "clicked");
-        return true;
-    }
-
-    return false;
-}
-
-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);
-#elif GTK_CHECK_VERSION(3,14,0)
-    gtk_widget_set_halign(GTK_WIDGET(label),
-                          x == 0 ? GTK_ALIGN_START :
-                          x == 1 ? GTK_ALIGN_END : GTK_ALIGN_CENTER);
-    gtk_widget_set_valign(GTK_WIDGET(label),
-                          y == 0 ? GTK_ALIGN_START :
-                          y == 1 ? GTK_ALIGN_END : GTK_ALIGN_CENTER);
-#else
-    gtk_misc_set_alignment(GTK_MISC(label), x, y);
-#endif
-}
-
-#if GTK_CHECK_VERSION(3,0,0)
-static bool message_box(GtkWidget *parent, const char *title, const char *msg,
-                        bool 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));
-}
-
-bool message_box(GtkWidget *parent, const char *title, const char *msg,
-                 bool centre, int type)
-{
-    GtkWidget *window, *hbox, *text, *button;
-    const char *titles;
-    int i, def, cancel;
-
-    window = gtk_dialog_new();
-    text = gtk_label_new(msg);
-    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_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 = LABEL_OK "\0";
-        def = cancel = 0;
-    } else {
-        assert(type == MB_YESNO);
-        titles = LABEL_NO "\0" LABEL_YES "\0";
-        def = 1;
-        cancel = 0;
-    }
-    i = 0;
-    
-    while (*titles) {
-        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_can_default(button, true);
-            gtk_window_set_default(GTK_WINDOW(window), button);
-        }
-        if (i == cancel) {
-            g_signal_connect(G_OBJECT(window), "key_press_event",
-                             G_CALLBACK(win_key_press), button);
-        }
-        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++;
-    }
-    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 == 1 : true);
-}
-#endif /* GTK_CHECK_VERSION(3,0,0) */
-
-static void error_box(GtkWidget *parent, const char *msg)
-{
-    message_box(parent, "Error", msg, false, MB_OK);
-}
-
-static void config_ok_button_clicked(GtkButton *button, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    const char *err;
-
-    err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
-
-    if (err)
-        error_box(fe->cfgbox, err);
-    else {
-        if (fe->cfg_which == CFG_PREFS) {
-            char *prefs_err = save_prefs(fe);
-            if (prefs_err) {
-                error_box(fe->cfgbox, prefs_err);
-                sfree(prefs_err);
-            }
-        }
-        fe->cfgret = true;
-        gtk_widget_destroy(fe->cfgbox);
-        if (fe->cfg_which != CFG_PREFS)
-            changed_preset(fe);
-    }
-}
-
-static void config_cancel_button_clicked(GtkButton *button, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    gtk_widget_destroy(fe->cfgbox);
-}
-
-static gint editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data)
-{
-    /*
-     * GtkEntry has a nasty habit of eating the Return key, which
-     * is unhelpful since it doesn't actually _do_ anything with it
-     * (it calls gtk_widget_activate, but our edit boxes never need
-     * activating). So I catch Return before GtkEntry sees it, and
-     * pass it straight on to the parent widget. Effect: hitting
-     * Return in an edit box will now activate the default button
-     * in the dialog just like it will everywhere else.
-     */
-    if (event->keyval == GDK_KEY_Return &&
-        gtk_widget_get_parent(widget) != NULL) {
-        gint 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;
-}
-
-static void editbox_changed(GtkEditable *ed, gpointer data)
-{
-    config_item *i = (config_item *)data;
-
-    assert(i->type == C_STRING);
-    sfree(i->u.string.sval);
-    i->u.string.sval = dupstr(gtk_entry_get_text(GTK_ENTRY(ed)));
-}
-
-static void button_toggled(GtkToggleButton *tb, gpointer data)
-{
-    config_item *i = (config_item *)data;
-
-    assert(i->type == C_BOOLEAN);
-    i->u.boolean.bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb));
-}
-
-static void droplist_sel(GtkComboBox *combo, gpointer data)
-{
-    config_item *i = (config_item *)data;
-
-    assert(i->type == C_CHOICES);
-    i->u.choices.selected = gtk_combo_box_get_active(combo);
-}
-
-static bool get_config(frontend *fe, int which)
-{
-    GtkWidget *w, *table, *cancel;
-    GtkBox *content_box, *button_box;
-    char *title;
-    config_item *i;
-    int y;
-
-    fe->cfg = midend_get_config(fe->me, which, &title);
-    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_our_label(LABEL_CANCEL);
-    gtk_box_pack_end(button_box, w, false, false, 0);
-    gtk_widget_show(w);
-    g_signal_connect(G_OBJECT(w), "clicked",
-                     G_CALLBACK(config_cancel_button_clicked), fe);
-    cancel = w;
-
-    w = gtk_button_new_with_our_label(LABEL_OK);
-    gtk_box_pack_end(button_box, w, false, false, 0);
-    gtk_widget_show(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_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:
-            /*
-             * Edit box with a label beside it.
-             */
-
-            w = gtk_label_new(i->name);
-            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_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->u.string.sval);
-            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;
-
-          case C_BOOLEAN:
-            /*
-             * Simple checkbox.
-             */
-            w = gtk_check_button_new_with_label(i->name);
-            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->u.boolean.bval);
-            gtk_widget_show(w);
-            break;
-
-          case C_CHOICES:
-            /*
-             * Drop-down list (GtkComboBox).
-             */
-
-            w = gtk_label_new(i->name);
-            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_SHRINK | GTK_FILL,
-                             GTK_EXPAND | GTK_SHRINK | GTK_FILL ,
-                             3, 3);
-#endif
-            gtk_widget_show(w);
-
-            {
-                int c;
-                const char *p, *q;
-                char *name;
-                GtkListStore *model;
-                GtkCellRenderer *cr;
-                GtkTreeIter iter;
-
-                model = gtk_list_store_new(1, G_TYPE_STRING);
-
-                c = *i->u.choices.choicenames;
-                p = i->u.choices.choicenames+1;
-
-                while (*p) {
-                    q = p;
-                    while (*q && *q != c)
-                        q++;
-
-                    name = snewn(q-p+1, char);
-                    strncpy(name, p, q-p);
-                    name[q-p] = '\0';
-
-                    if (*q) q++;       /* eat delimiter */
-
-                    gtk_list_store_append(model, &iter);
-                    gtk_list_store_set(model, &iter, 0, name, -1);
-
-                    p = q;
-                }
-
-                w = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
-
-                gtk_combo_box_set_active(GTK_COMBO_BOX(w),
-                                         i->u.choices.selected);
-
-                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++;
-    }
-
-    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));
-    /* set_transient_window_pos(fe->window, fe->cfgbox); */
-    gtk_widget_show(fe->cfgbox);
-    gtk_main();
-
-    free_cfg(fe->cfg);
-
-    return fe->cfgret;
-}
-
-static void menu_key_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    int key = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem),
-                                                "user-data"));
-    if (midend_process_key(fe->me, 0, 0, key) == PKR_QUIT)
-        gtk_widget_destroy(fe->window);
-}
-
-static void get_size(frontend *fe, int *px, int *py)
-{
-    int x, y;
-
-    /*
-     * Currently I don't want to make the GTK port scale large
-     * puzzles to fit on the screen. This is because X does permit
-     * extremely large windows and many window managers provide a
-     * means of navigating round them, and the users I consulted
-     * before deciding said that they'd rather have enormous puzzle
-     * windows spanning multiple screen pages than have them
-     * shrunk. I could change my mind later or introduce
-     * configurability; this would be the place to do so, by
-     * replacing the initial values of x and y with the screen
-     * dimensions.
-     */
-    x = INT_MAX;
-    y = INT_MAX;
-    midend_size(fe->me, &x, &y, false, 1.0);
-    *px = x;
-    *py = y;
-}
-
-#if !GTK_CHECK_VERSION(2,0,0)
-#define gtk_window_resize(win, x, y) \
-        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;
-        GSList *found = NULL;
-
-        for (gs = fe->preset_radio; gs; gs = gs->next) {
-            struct preset_menu_entry *entry =
-                (struct preset_menu_entry *)g_object_get_data(
-                    G_OBJECT(gs->data), "user-data");
-            if (!entry || entry->id != n)
-                gtk_check_menu_item_set_active(
-                    GTK_CHECK_MENU_ITEM(gs->data), false);
-            else
-                found = gs;
-        }
-        if (found)
-            gtk_check_menu_item_set_active(
-                GTK_CHECK_MENU_ITEM(found->data), true);
-    }
-    fe->preset_threaded = false;
-
-    /*
-     * Update the greying on the Copy menu option.
-     */
-    if (fe->copy_menu_item) {
-        bool 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 bool 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;
-}
-
-#if GTK_CHECK_VERSION(3,0,0)
-static int window_extra_height(frontend *fe)
-{
-    int ret = 0;
-    if (fe->menubar) {
-        GtkRequisition req;
-        gtk_widget_get_preferred_size(fe->menubar, &req, NULL);
-        ret += req.height;
-    }
-    if (fe->statusbar) {
-        GtkRequisition req;
-        gtk_widget_get_preferred_size(fe->statusbar, &req, NULL);
-        ret += req.height;
-    }
-    return ret;
-}
-#endif
-
-static void resize_fe(frontend *fe)
-{
-    int x, y;
-
-    get_size(fe, &x, &y);
-
-#if GTK_CHECK_VERSION(3,0,0)
-    gtk_window_resize(GTK_WINDOW(fe->window), x, y + window_extra_height(fe));
-    fe->awaiting_resize_ack = true;
-#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);
-    }
-    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;
-    struct preset_menu_entry *entry =
-        (struct preset_menu_entry *)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, entry->params);
-    midend_new_game(fe->me);
-    changed_preset(fe);
-    resize_fe(fe);
-    midend_redraw(fe->me);
-}
-
-static GdkAtom compound_text_atom, utf8_string_atom;
-static bool paste_initialised = false;
-
-static void set_selection(frontend *fe, GdkAtom selection)
-{
-    if (!paste_initialised) {
-        compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", false);
-        utf8_string_atom = gdk_atom_intern("UTF8_STRING", false);
-        paste_initialised = true;
-    }
-
-    /*
-     * 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.
-     */
-
-    if (gtk_selection_owner_set(fe->window, selection, CurrentTime)) {
-        gtk_selection_clear_targets(fe->window, selection);
-        gtk_selection_add_target(fe->window, selection,
-                                 GDK_SELECTION_TYPE_STRING, 1);
-        gtk_selection_add_target(fe->window, selection, compound_text_atom, 1);
-        gtk_selection_add_target(fe->window, selection, utf8_string_atom, 1);
-    }
-}
-
-static void write_clip(frontend *fe, char *data)
-{
-    if (fe->paste_data)
-        sfree(fe->paste_data);
-
-    fe->paste_data = data;
-    fe->paste_data_len = strlen(data);
-
-    set_selection(fe, GDK_SELECTION_PRIMARY);
-    set_selection(fe, GDK_SELECTION_CLIPBOARD);
-}
-
-static void selection_get(GtkWidget *widget, GtkSelectionData *seldata,
-                          guint info, guint time_stamp, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    gtk_selection_data_set(seldata, gtk_selection_data_get_target(seldata), 8,
-                           fe->paste_data, fe->paste_data_len);
-}
-
-static gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
-                            gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    if (fe->paste_data)
-        sfree(fe->paste_data);
-    fe->paste_data = NULL;
-    fe->paste_data_len = 0;
-    return true;
-}
-
-static void menu_copy_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    char *text;
-
-    text = midend_text_format(fe->me);
-
-    if (text) {
-        write_clip(fe, text);
-    } else {
-        gdk_display_beep(gdk_display_get_default());
-    }
-}
-
-#ifdef OLD_FILESEL
-
-static void filesel_ok(GtkButton *button, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    gpointer filesel = g_object_get_data(G_OBJECT(button), "user-data");
-
-    const char *name =
-        gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel));
-
-    fe->filesel_name = dupstr(name);
-}
-
-static char *file_selector(frontend *fe, const char *title, int save)
-{
-    GtkWidget *filesel =
-        gtk_file_selection_new(title);
-
-    fe->filesel_name = NULL;
-
-    gtk_window_set_modal(GTK_WINDOW(filesel), true);
-    g_object_set_data
-        (G_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "user-data",
-         (gpointer)filesel);
-    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();
-
-    return fe->filesel_name;
-}
-
-#else
-
-static char *file_selector(frontend *fe, const char *title, bool 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
-
-#ifdef USE_PRINTING
-static GObject *create_print_widget(GtkPrintOperation *print, gpointer data)
-{
-    GtkLabel *count_label, *width_label, *height_label,
-        *scale_llabel, *scale_rlabel;
-    GtkBox *scale_hbox;
-    GtkWidget *grid;
-    frontend *fe = (frontend *)data;
-
-    fe->printcount_spin_button =
-        GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 999, 1));
-    gtk_spin_button_set_numeric(fe->printcount_spin_button, true);
-    gtk_spin_button_set_snap_to_ticks(fe->printcount_spin_button, true);
-    fe->printw_spin_button =
-        GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 99, 1));
-    gtk_spin_button_set_numeric(fe->printw_spin_button, true);
-    gtk_spin_button_set_snap_to_ticks(fe->printw_spin_button, true);
-    fe->printh_spin_button =
-        GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 99, 1));
-    gtk_spin_button_set_numeric(fe->printh_spin_button, true);
-    gtk_spin_button_set_snap_to_ticks(fe->printh_spin_button, true);
-    fe->printscale_spin_button =
-        GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 1000, 1));
-    gtk_spin_button_set_digits(fe->printscale_spin_button, 1);
-    gtk_spin_button_set_numeric(fe->printscale_spin_button, true);
-    if (thegame.can_solve) {
-        fe->soln_check_button =
-            GTK_CHECK_BUTTON(
-                gtk_check_button_new_with_label("Print solutions"));
-    }
-    if (thegame.can_print_in_colour) {
-        fe->colour_check_button =
-            GTK_CHECK_BUTTON(
-                gtk_check_button_new_with_label("Print in color"));
-    }
-
-    /* Set defaults to what was selected last time. */
-    gtk_spin_button_set_value(fe->printcount_spin_button,
-                              (gdouble)fe->printcount);
-    gtk_spin_button_set_value(fe->printw_spin_button,
-                              (gdouble)fe->printw);
-    gtk_spin_button_set_value(fe->printh_spin_button,
-                              (gdouble)fe->printh);
-    gtk_spin_button_set_value(fe->printscale_spin_button,
-                              (gdouble)fe->printscale);
-    if (thegame.can_solve) {
-        gtk_toggle_button_set_active(
-            GTK_TOGGLE_BUTTON(fe->soln_check_button), fe->printsolns);
-    }
-    if (thegame.can_print_in_colour) {
-        gtk_toggle_button_set_active(
-            GTK_TOGGLE_BUTTON(fe->colour_check_button), fe->printcolour);
-    }
-
-    count_label = GTK_LABEL(gtk_label_new("Puzzles to print:"));
-    width_label = GTK_LABEL(gtk_label_new("Puzzles across:"));
-    height_label = GTK_LABEL(gtk_label_new("Puzzles down:"));
-    scale_llabel = GTK_LABEL(gtk_label_new("Puzzle scale:"));
-    scale_rlabel = GTK_LABEL(gtk_label_new("%"));
-#if GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_set_halign(GTK_WIDGET(count_label), GTK_ALIGN_START);
-    gtk_widget_set_halign(GTK_WIDGET(width_label), GTK_ALIGN_START);
-    gtk_widget_set_halign(GTK_WIDGET(height_label), GTK_ALIGN_START);
-    gtk_widget_set_halign(GTK_WIDGET(scale_llabel), GTK_ALIGN_START);
-#else
-    gtk_misc_set_alignment(GTK_MISC(count_label), 0, 0);
-    gtk_misc_set_alignment(GTK_MISC(width_label), 0, 0);
-    gtk_misc_set_alignment(GTK_MISC(height_label), 0, 0);
-    gtk_misc_set_alignment(GTK_MISC(scale_llabel), 0, 0);
-#endif
-
-    scale_hbox = GTK_BOX(gtk_hbox_new(false, 6));
-    gtk_box_pack_start(scale_hbox, GTK_WIDGET(fe->printscale_spin_button),
-                       false, false, 0);
-    gtk_box_pack_start(scale_hbox, GTK_WIDGET(scale_rlabel),
-                       false, false, 0);
-
-#if GTK_CHECK_VERSION(3,0,0)
-    grid = gtk_grid_new();
-    gtk_grid_set_column_spacing(GTK_GRID(grid), 18);
-    gtk_grid_set_row_spacing(GTK_GRID(grid), 18);
-    gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(count_label), 0, 0, 1, 1);
-    gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(width_label), 0, 1, 1, 1);
-    gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(height_label), 0, 2, 1, 1);
-    gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(scale_llabel), 0, 3, 1, 1);
-    gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->printcount_spin_button),
-                    1, 0, 1, 1);
-    gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->printw_spin_button),
-                    1, 1, 1, 1);
-    gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->printh_spin_button),
-                    1, 2, 1, 1);
-    gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(scale_hbox), 1, 3, 1, 1);
-    if (thegame.can_solve) {
-        gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->soln_check_button),
-                        0, 4, 1, 1);
-    }
-    if (thegame.can_print_in_colour) {
-        gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(fe->colour_check_button),
-                        thegame.can_solve, 4, 1, 1);
-    }
-#else
-    grid = gtk_table_new((thegame.can_solve || thegame.can_print_in_colour) ?
-                         5 : 4, 2, false);
-    gtk_table_set_col_spacings(GTK_TABLE(grid), 18);
-    gtk_table_set_row_spacings(GTK_TABLE(grid), 18);
-    gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(count_label), 0, 1, 0, 1,
-                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(width_label), 0, 1, 1, 2,
-                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(height_label), 0, 1, 2, 3,
-                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(scale_llabel), 0, 1, 3, 4,
-                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->printcount_spin_button),
-                     1, 2, 0, 1,
-                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->printw_spin_button),
-                     1, 2, 1, 2,
-                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->printh_spin_button),
-                     1, 2, 2, 3,
-                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(scale_hbox), 1, 2, 3, 4,
-                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    if (thegame.can_solve) {
-        gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->soln_check_button),
-                         0, 1, 4, 5,
-                         GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    }
-    if (thegame.can_print_in_colour) {
-        gtk_table_attach(GTK_TABLE(grid), GTK_WIDGET(fe->colour_check_button),
-                         thegame.can_solve, thegame.can_solve + 1, 4, 5,
-                         GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
-    }
-#endif
-    gtk_container_set_border_width(GTK_CONTAINER(grid), 12);
-
-    gtk_widget_show_all(grid);
-
-    return G_OBJECT(grid);
-}
-
-static void apply_print_widget(GtkPrintOperation *print,
-                               GtkWidget *widget, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    /* We ignore `widget' because it is easier and faster to store the
-       widgets we need in `fe' then to get the children of `widget'. */
-    fe->printcount =
-        gtk_spin_button_get_value_as_int(fe->printcount_spin_button);
-    fe->printw = gtk_spin_button_get_value_as_int(fe->printw_spin_button);
-    fe->printh = gtk_spin_button_get_value_as_int(fe->printh_spin_button);
-    fe->printscale = gtk_spin_button_get_value(fe->printscale_spin_button);
-    if (thegame.can_solve) {
-        fe->printsolns =
-            gtk_toggle_button_get_active(
-                GTK_TOGGLE_BUTTON(fe->soln_check_button));
-    }
-    if (thegame.can_print_in_colour) {
-        fe->printcolour =
-            gtk_toggle_button_get_active(
-                GTK_TOGGLE_BUTTON(fe->colour_check_button));
-    }
-}
-
-static void print_begin(GtkPrintOperation *printop,
-                        GtkPrintContext *context, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    midend *nme = NULL;  /* non-interactive midend for bulk puzzle generation */
-    int i;
-
-    fe->printcontext = context;
-    fe->cr = gtk_print_context_get_cairo_context(context);
-
-    /*
-     * Create our document structure and fill it up with puzzles.
-     */
-    fe->doc = document_new(fe->printw, fe->printh, fe->printscale / 100.0F);
-
-    for (i = 0; i < fe->printcount; i++) {
-        const char *err;
-
-        if (i == 0) {
-            err = midend_print_puzzle(fe->me, fe->doc, fe->printsolns);
-        } else {
-            if (!nme) {
-                game_params *params;
-
-                nme = midend_new(NULL, &thegame, NULL, NULL);
-
-                /*
-                 * Set the non-interactive mid-end to have the same
-                 * parameters as the standard one.
-                 */
-                params = midend_get_params(fe->me);
-                midend_set_params(nme, params);
-                thegame.free_params(params);
-            }
-
-            load_prefs(fe);
-
-            midend_new_game(nme);
-            err = midend_print_puzzle(nme, fe->doc, fe->printsolns);
-        }
-
-        if (err) {
-            error_box(fe->window, err);
-            return;
-        }
-    }
-
-    if (nme)
-        midend_free(nme);
-
-    /* Begin the document. */
-    document_begin(fe->doc, fe->print_dr);
-}
-
-static void draw_page(GtkPrintOperation *printop,
-                      GtkPrintContext *context,
-                      gint page_nr, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    document_print_page(fe->doc, fe->print_dr, page_nr);
-}
-
-static void print_end(GtkPrintOperation *printop,
-                      GtkPrintContext *context, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    /* End and free the document. */
-    document_end(fe->doc, fe->print_dr);
-    document_free(fe->doc);
-    fe->doc = NULL;
-}
-
-static void print_dialog(frontend *fe)
-{
-    GError *error;
-    static GtkPrintSettings *settings = NULL;
-    static GtkPageSetup *page_setup = NULL;
-#ifndef USE_EMBED_PAGE_SETUP
-    GtkPageSetup *new_page_setup;
-#endif
-
-    fe->printop = gtk_print_operation_new();
-    gtk_print_operation_set_use_full_page(fe->printop, true);
-    gtk_print_operation_set_custom_tab_label(fe->printop, "Puzzle Settings");
-    g_signal_connect(fe->printop, "create-custom-widget",
-                     G_CALLBACK(create_print_widget), fe);
-    g_signal_connect(fe->printop, "custom-widget-apply",
-                     G_CALLBACK(apply_print_widget), fe);
-    g_signal_connect(fe->printop, "begin-print", G_CALLBACK(print_begin), fe);
-    g_signal_connect(fe->printop, "draw-page", G_CALLBACK(draw_page), fe);
-    g_signal_connect(fe->printop, "end-print", G_CALLBACK(print_end), fe);
-#ifdef USE_EMBED_PAGE_SETUP
-    gtk_print_operation_set_embed_page_setup(fe->printop, true);
-#else
-    if (page_setup == NULL) {
-        page_setup =
-            g_object_ref(
-                gtk_print_operation_get_default_page_setup(fe->printop));
-    }
-    if (settings == NULL) {
-        settings =
-            g_object_ref(gtk_print_operation_get_print_settings(fe->printop));
-    }
-    new_page_setup = gtk_print_run_page_setup_dialog(GTK_WINDOW(fe->window),
-                                                     page_setup, settings);
-    g_object_unref(page_setup);
-    page_setup = new_page_setup;
-    gtk_print_operation_set_default_page_setup(fe->printop, page_setup);
-#endif
-
-    if (settings != NULL)
-        gtk_print_operation_set_print_settings(fe->printop, settings);
-    if (page_setup != NULL)
-        gtk_print_operation_set_default_page_setup(fe->printop, page_setup);
-
-    switch (gtk_print_operation_run(fe->printop,
-                                    GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
-                                    GTK_WINDOW(fe->window), &error)) {
-    case GTK_PRINT_OPERATION_RESULT_ERROR:
-        error_box(fe->window, error->message);
-        g_error_free(error);
-        break;
-    case GTK_PRINT_OPERATION_RESULT_APPLY:
-        if (settings != NULL)
-            g_object_unref(settings);
-        settings =
-            g_object_ref(gtk_print_operation_get_print_settings(fe->printop));
-#ifdef USE_EMBED_PAGE_SETUP
-        if (page_setup != NULL)
-            g_object_unref(page_setup);
-        page_setup =
-            g_object_ref(
-                gtk_print_operation_get_default_page_setup(fe->printop));
-#endif
-        break;
-    default:
-        /* Don't error out on -Werror=switch. */
-        break;
-    }
-
-    g_object_unref(fe->printop);
-    fe->printop = NULL;
-    fe->printcontext = NULL;
-}
-#endif /* USE_PRINTING */
-
-struct savefile_write_ctx {
-    FILE *fp;
-    int error;
-};
-
-static void savefile_write(void *wctx, const void *buf, int len)
-{
-    struct savefile_write_ctx *ctx = (struct savefile_write_ctx *)wctx;
-    if (fwrite(buf, 1, len, ctx->fp) < len)
-        ctx->error = errno;
-}
-
-static bool savefile_read(void *wctx, void *buf, int len)
-{
-    FILE *fp = (FILE *)wctx;
-    int ret;
-
-    ret = fread(buf, 1, len, fp);
-    return (ret == len);
-}
-
-static void menu_save_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    char *name;
-
-    name = file_selector(fe, "Enter name of game file to save", true);
-
-    if (name) {
-        FILE *fp;
-
-        if ((fp = fopen(name, "r")) != NULL) {
-            char buf[256 + FILENAME_MAX];
-            fclose(fp);
-            /* file exists */
-
-            sprintf(buf, "Are you sure you want to overwrite the"
-                    " file \"%.*s\"?",
-                    FILENAME_MAX, name);
-            if (!message_box(fe->window, "Question", buf, true, MB_YESNO))
-                goto free_and_return;
-        }
-
-        fp = fopen(name, "w");
-
-        if (!fp) {
-            error_box(fe->window, "Unable to open save file");
-            goto free_and_return;
-        }
-
-        {
-            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(ctx.error));
-                error_box(fe->window, boxmsg);
-                goto free_and_return;
-            }
-        }
-    free_and_return:
-        sfree(name);
-    }
-}
-
-static void menu_load_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    char *name;
-    const char *err;
-
-    name = file_selector(fe, "Enter name of saved game file to load", false);
-
-    if (name) {
-        FILE *fp = fopen(name, "r");
-        sfree(name);
-
-        if (!fp) {
-            error_box(fe->window, "Unable to open saved game file");
-            return;
-        }
-
-        err = midend_deserialise(fe->me, savefile_read, fp);
-
-        fclose(fp);
-
-        if (err) {
-            error_box(fe->window, err);
-            return;
-        }
-
-        changed_preset(fe);
-        resize_fe(fe);
-        midend_redraw(fe->me);
-    }
-}
-
-static char *prefs_dir(void)
-{
-    const char *var;
-    if ((var = getenv("SGT_PUZZLES_DIR")) != NULL)
-        return dupstr(var);
-    if ((var = getenv("XDG_CONFIG_HOME")) != NULL) {
-        size_t size = strlen(var) + 20;
-        char *dir = snewn(size, char);
-        sprintf(dir, "%s/sgt-puzzles", var);
-        return dir;
-    }
-    if ((var = getenv("HOME")) != NULL) {
-        size_t size = strlen(var) + 32;
-        char *dir = snewn(size, char);
-        sprintf(dir, "%s/.config/sgt-puzzles", var);
-        return dir;
-    }
-    return NULL;
-}
-
-static char *prefs_path_general(const game *game, const char *suffix)
-{
-    char *dir, *path;
-
-    dir = prefs_dir();
-    if (!dir)
-        return NULL;
-
-    path = make_prefs_path(dir, "/", game, suffix);
-
-    sfree(dir);
-    return path;
-}
-
-static char *prefs_path(const game *game)
-{
-    return prefs_path_general(game, ".conf");
-}
-
-static char *prefs_tmp_path(const game *game)
-{
-    return prefs_path_general(game, ".conf.tmp");
-}
-
-static void load_prefs(frontend *fe)
-{
-    const game *game = midend_which_game(fe->me);
-    char *path = prefs_path(game);
-    if (!path)
-        return;
-    FILE *fp = fopen(path, "r");
-    if (!fp)
-        return;
-    const char *err = midend_load_prefs(fe->me, savefile_read, fp);
-    fclose(fp);
-    if (err)
-        fprintf(stderr, "Unable to load preferences file %s:\n%s\n",
-                path, err);
-    sfree(path);
-}
-
-static char *save_prefs(frontend *fe)
-{
-    const game *game = midend_which_game(fe->me);
-    char *dir_path = prefs_dir();
-    char *file_path = prefs_path(game);
-    char *tmp_path = prefs_tmp_path(game);
-    struct savefile_write_ctx wctx[1];
-    int fd;
-    bool cleanup_dir = false, cleanup_tmpfile = false;
-    char *err = NULL;
-
-    if (!dir_path || !file_path || !tmp_path) {
-        sprintf(err = snewn(256, char),
-                "Unable to save preferences:\n"
-                "Could not determine pathname for configuration files");
-        goto out;
-    }
-
-    if (mkdir(dir_path, 0777) < 0) {
-        /* Ignore errors while trying to make the directory. It may
-         * well already exist, and even if we got some error code
-         * other than EEXIST, it's still worth at least _trying_ to
-         * make the file inside it, and see if that goes wrong. */
-    } else {
-        cleanup_dir = true;
-    }
-
-    fd = open(tmp_path, O_CREAT | O_WRONLY | O_TRUNC | O_EXCL, 0666);
-    if (fd < 0) {
-        const char *os_err = strerror(errno);
-        sprintf(err = snewn(256 + strlen(tmp_path) + strlen(os_err), char),
-                "Unable to save preferences:\n"
-                "Unable to create file '%s': %s", tmp_path, os_err);
-        goto out;
-    } else {
-        cleanup_tmpfile = true;
-    }
-
-    wctx->error = 0;
-    wctx->fp = fdopen(fd, "w");
-    midend_save_prefs(fe->me, savefile_write, wctx);
-    fclose(wctx->fp);
-    if (wctx->error) {
-        const char *os_err = strerror(wctx->error);
-        sprintf(err = snewn(80 + strlen(tmp_path) + strlen(os_err), char),
-                "Unable to write file '%s': %s", tmp_path, os_err);
-        goto out;
-    }
-
-    if (rename(tmp_path, file_path) < 0) {
-        const char *os_err = strerror(errno);
-        sprintf(err = snewn(256 + strlen(tmp_path) + strlen(file_path) +
-                            strlen(os_err), char),
-                "Unable to save preferences:\n"
-                "Unable to rename '%s' to '%s': %s", tmp_path, file_path,
-                os_err);
-        goto out;
-    } else {
-        cleanup_dir = false;
-        cleanup_tmpfile = false;
-    }
-
-  out:
-    if (cleanup_tmpfile) {
-        if (unlink(tmp_path) < 0) { /* can't do anything about this */ }
-    }
-    if (cleanup_dir) {
-        if (rmdir(dir_path) < 0) { /* can't do anything about this */ }
-    }
-    sfree(dir_path);
-    sfree(file_path);
-    sfree(tmp_path);
-    return err;
-}
-
-static bool delete_prefs(const game *game, char **msg)
-{
-    char *dir_path = prefs_dir();
-    char *file_path = prefs_path(game);
-    char *tmp_path = prefs_tmp_path(game);
-    char *msgs[3];
-    int i, len, nmsgs = 0;
-    char *p;
-    bool ok = true;
-
-    if (unlink(file_path) == 0) {
-        sprintf(msgs[nmsgs++] = snewn(256 + strlen(file_path), char),
-                "Removed preferences file %s\n", file_path);
-    } else if (errno != ENOENT) {
-        const char *os_err = strerror(errno);
-        sprintf(msgs[nmsgs++] = snewn(256 + strlen(file_path) + strlen(os_err),
-                                      char),
-                "Failed to remove preferences file %s: %s\n",
-                file_path, os_err);
-        ok = false;
-    }
-
-    if (unlink(tmp_path) == 0) {
-        sprintf(msgs[nmsgs++] = snewn(256 + strlen(tmp_path), char),
-                "Removed temporary file %s\n", tmp_path);
-    } else if (errno != ENOENT) {
-        const char *os_err = strerror(errno);
-        sprintf(msgs[nmsgs++] = snewn(256 + strlen(tmp_path) + strlen(os_err),
-                                      char),
-                "Failed to remove temporary file %s: %s\n", tmp_path, os_err);
-        ok = false;
-    }
-
-    if (rmdir(dir_path) == 0) {
-        sprintf(msgs[nmsgs++] = snewn(256 + strlen(dir_path), char),
-                "Removed empty preferences directory %s\n", dir_path);
-    } else if (errno != ENOENT && errno != ENOTEMPTY) {
-        const char *os_err = strerror(errno);
-        sprintf(msgs[nmsgs++] = snewn(256 + strlen(dir_path) + strlen(os_err),
-                                      char),
-                "Failed to remove preferences directory %s: %s\n",
-                dir_path, os_err);
-        ok = false;
-    }
-
-    for (i = len = 0; i < nmsgs; i++)
-        len += strlen(msgs[i]);
-    *msg = snewn(len + 1, char);
-    p = *msg;
-    for (i = len = 0; i < nmsgs; i++) {
-        size_t len = strlen(msgs[i]);
-        memcpy(p, msgs[i], len);
-        p += len;
-        sfree(msgs[i]);
-    }
-    *p = '\0';
-
-    sfree(dir_path);
-    sfree(file_path);
-    sfree(tmp_path);
-
-    return ok;
-}
-
-#ifdef USE_PRINTING
-static void menu_print_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    print_dialog(fe);
-}
-#endif
-
-static void menu_solve_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-    const char *msg;
-
-    msg = midend_solve(fe->me);
-
-    if (msg)
-        error_box(fe->window, msg);
-}
-
-static void menu_restart_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-    midend_restart_game(fe->me);
-}
-
-static void menu_config_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)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;
-
-    if (which != CFG_PREFS)
-        midend_new_game(fe->me);
-
-    resize_fe(fe);
-    midend_redraw(fe->me);
-}
-
-#ifndef HELP_BROWSER_PATH
-#define HELP_BROWSER_PATH "xdg-open:sensible-browser:$BROWSER"
-#endif
-
-static bool try_show_help(const char *browser, const char *help_name)
-{
-    const char *argv[3] = { browser, help_name, NULL };
-
-    return g_spawn_async(NULL, (char **)argv, NULL,
-                         G_SPAWN_SEARCH_PATH,
-                         NULL, NULL, NULL, NULL);
-}
-
-static void show_help(frontend *fe, const char *topic)
-{
-    char *path = dupstr(HELP_BROWSER_PATH);
-    char *path_entry;
-    char *help_name;
-    size_t help_name_size;
-    bool succeeded = true;
-
-    help_name_size = strlen(HELP_DIR) + 4 + strlen(topic) + 6;
-    help_name = snewn(help_name_size, char);
-    sprintf(help_name, "%s/en/%s.html",
-            HELP_DIR, topic);
-
-    if (access(help_name, R_OK)) {
-        error_box(fe->window, "Help file is not installed");
-        sfree(path);
-        sfree(help_name);
-        return;
-    }
-
-    path_entry = path;
-    for (;;) {
-        size_t len;
-        bool last;
-
-        len = strcspn(path_entry, ":");
-        last = path_entry[len] == 0;
-        path_entry[len] = 0;
-
-        if (path_entry[0] == '$') {
-            const char *command = getenv(path_entry + 1);
-
-            if (command)
-                succeeded = try_show_help(command, help_name);
-        } else {
-            succeeded = try_show_help(path_entry, help_name);
-        }
-
-        if (last || succeeded)
-            break;
-        path_entry += len + 1;
-    }
-
-    if (!succeeded)
-        error_box(fe->window, "Failed to start a help browser");
-    sfree(path);
-    sfree(help_name);
-}
-
-static void menu_help_contents_event(GtkMenuItem *menuitem, gpointer data)
-{
-    show_help((frontend *)data, "index");
-}
-
-static void menu_help_specific_event(GtkMenuItem *menuitem, gpointer data)
-{
-    show_help((frontend *)data, thegame.htmlhelp_topic);
-}
-
-static void menu_about_event(GtkMenuItem *menuitem, gpointer data)
-{
-    frontend *fe = (frontend *)data;
-
-#if GTK_CHECK_VERSION(3,0,0)
-# define ABOUT_PARAMS                                               \
-    "program-name", thegame.name,                                   \
-    "version", ver,                                                 \
-    "comments", "Part of Simon Tatham's Portable Puzzle Collection"
-
-    if (n_xpm_icons) {
-        GdkPixbuf *icon = gdk_pixbuf_new_from_xpm_data
-            ((const gchar **)xpm_icons[0]);
-
-        gtk_show_about_dialog
-            (GTK_WINDOW(fe->window),
-             ABOUT_PARAMS,
-             "logo", icon,
-             (const gchar *)NULL);
-        g_object_unref(G_OBJECT(icon));
-    }
-    else {
-        gtk_show_about_dialog
-            (GTK_WINDOW(fe->window),
-             ABOUT_PARAMS,
-             (const gchar *)NULL);
-    }
-#else
-    char titlebuf[256];
-    char textbuf[1024];
-
-    sprintf(titlebuf, "About %.200s", thegame.name);
-    sprintf(textbuf,
-            "%.200s\n\n"
-            "from Simon Tatham's Portable Puzzle Collection\n\n"
-            "%.500s", thegame.name, ver);
-
-    message_box(fe->window, titlebuf, textbuf, true, MB_OK);
-#endif
-}
-
-static GtkWidget *add_menu_ui_item(
-    frontend *fe, GtkContainer *cont, const char *text, int action,
-    int accel_key, int accel_keyqual)
-{
-    GtkWidget *menuitem = gtk_menu_item_new_with_label(text);
-    gtk_container_add(cont, menuitem);
-    g_object_set_data(G_OBJECT(menuitem), "user-data",
-                      GINT_TO_POINTER(action));
-    g_signal_connect(G_OBJECT(menuitem), "activate",
-                     G_CALLBACK(menu_key_event), fe);
-
-    if (accel_key) {
-        /*
-         * Display a keyboard accelerator alongside this menu item.
-         * Actually this won't be processed via the usual GTK
-         * accelerator system, because we add it to a dummy
-         * accelerator group which is never actually activated on the
-         * main window; this permits back ends to override special
-         * keys like 'n' and 'r' and 'u' in some UI states. So
-         * whatever keystroke we display here will still go to
-         * key_event and be handled in the normal way.
-         */
-        gtk_widget_add_accelerator(menuitem,
-                                   "activate", fe->dummy_accelgroup,
-                                   accel_key, accel_keyqual,
-                                   GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
-    }
-
-    gtk_widget_show(menuitem);
-    return menuitem;
-}
-
-static void add_menu_separator(GtkContainer *cont)
-{
-    GtkWidget *menuitem = gtk_menu_item_new();
-    gtk_container_add(cont, menuitem);
-    gtk_widget_show(menuitem);
-}
-
-static void populate_gtk_preset_menu(frontend *fe, struct preset_menu *menu,
-                                     GtkWidget *gtkmenu)
-{
-    int i;
-
-    for (i = 0; i < menu->n_entries; i++) {
-        struct preset_menu_entry *entry = &menu->entries[i];
-        GtkWidget *menuitem;
-
-        if (entry->params) {
-            menuitem = gtk_radio_menu_item_new_with_label(
-                fe->preset_radio, entry->title);
-            fe->preset_radio = gtk_radio_menu_item_get_group(
-                GTK_RADIO_MENU_ITEM(menuitem));
-            g_object_set_data(G_OBJECT(menuitem), "user-data", entry);
-            g_signal_connect(G_OBJECT(menuitem), "activate",
-                             G_CALLBACK(menu_preset_event), fe);
-        } else {
-            GtkWidget *submenu;
-            menuitem = gtk_menu_item_new_with_label(entry->title);
-            submenu = gtk_menu_new();
-            gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
-            populate_gtk_preset_menu(fe, entry->submenu, submenu);
-        }
-
-        gtk_container_add(GTK_CONTAINER(gtkmenu), menuitem);
-        gtk_widget_show(menuitem);
-    }
-}
-
-enum { ARG_EITHER, ARG_SAVE, ARG_ID }; /* for argtype */
-
-static frontend *new_window(
-    char *arg, int argtype, char **error, bool headless)
-{
-    frontend *fe;
-#ifdef USE_PRINTING
-    frontend *print_fe = NULL;
-#endif
-    GtkBox *vbox, *hbox;
-    GtkWidget *menu, *menuitem;
-    GList *iconlist;
-    int x, y, n;
-    char errbuf[1024];
-    struct preset_menu *preset_menu;
-
-    fe = snew(frontend);
-    memset(fe, 0, sizeof(frontend));
-
-#ifndef USE_CAIRO
-    if (headless) {
-        fprintf(stderr, "headless mode not supported for non-Cairo drawing\n");
-        exit(1);
-    }
-#else
-    fe->headless = headless;
-    fe->ps = 1; /* in headless mode, configure_area won't have set this */
-#endif
-
-    fe->timer_active = false;
-    fe->timer_id = -1;
-
-    fe->me = midend_new(fe, &thegame, &gtk_drawing, fe);
-    load_prefs(fe);
-
-    fe->dr_api = &internal_drawing;
-
-#ifdef USE_PRINTING
-    if (thegame.can_print) {
-        print_fe = snew(frontend);
-        memset(print_fe, 0, sizeof(frontend));
-
-        /* Defaults */
-        print_fe->printcount = print_fe->printw = print_fe->printh = 1;
-        print_fe->printscale = 100;
-        print_fe->printsolns = false;
-        print_fe->printcolour = thegame.can_print_in_colour;
-
-        /*
-         * We need to use the same midend as the main frontend because
-         * we need midend_print_puzzle() to be able to print the
-         * current puzzle.
-         */
-        print_fe->me = fe->me;
-
-        print_fe->print_dr = drawing_new(&gtk_drawing, print_fe->me, print_fe);
-
-        print_fe->dr_api = &internal_printing;
-    }
-#endif
-
-    if (arg) {
-        const char *err;
-        FILE *fp;
-
-        errbuf[0] = '\0';
-
-        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, "Error opening file: %.800s", strerror(errno));
-            } else {
-                err = midend_deserialise(fe->me, savefile_read, fp);
-                if (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);
-            sfree(fe);
-#ifdef USE_PRINTING
-            if (thegame.can_print) {
-                drawing_free(print_fe->print_dr);
-                sfree(print_fe);
-            }
-#endif
-            return NULL;
-        }
-
-    } else {
-        midend_new_game(fe->me);
-    }
-
-    if (headless) {
-        snaffle_colours(fe);
-        get_size(fe, &fe->pw, &fe->ph);
-        setup_backing_store(fe);
-        return fe;
-    }
-
-#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
-
-#if GTK_CHECK_VERSION(3,0,0)
-    fe->awaiting_resize_ack = false;
-#endif
-
-    fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
-    gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name);
-
-    vbox = GTK_BOX(gtk_vbox_new(false, 0));
-    gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox));
-    gtk_widget_show(GTK_WIDGET(vbox));
-
-    fe->dummy_accelgroup = gtk_accel_group_new();
-    /*
-     * Intentionally _not_ added to the window via
-     * gtk_window_add_accel_group; see menu_key_event
-     */
-
-    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_mnemonic("_Game");
-    gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem);
-    gtk_widget_show(menuitem);
-
-    menu = gtk_menu_new();
-    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
-
-    add_menu_ui_item(fe, GTK_CONTAINER(menu), "New", UI_NEWGAME, 'n', 0);
-
-    menuitem = gtk_menu_item_new_with_label("Restart");
-    gtk_container_add(GTK_CONTAINER(menu), menuitem);
-    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...");
-    g_object_set_data(G_OBJECT(menuitem), "user-data",
-                      GINT_TO_POINTER(CFG_DESC));
-    gtk_container_add(GTK_CONTAINER(menu), menuitem);
-    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...");
-    g_object_set_data(G_OBJECT(menuitem), "user-data",
-                      GINT_TO_POINTER(CFG_SEED));
-    gtk_container_add(GTK_CONTAINER(menu), menuitem);
-    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->preset_threaded = false;
-
-    preset_menu = midend_get_presets(fe->me, NULL);
-    if (preset_menu->n_entries > 0 || thegame.can_configure) {
-        GtkWidget *submenu;
-
-        menuitem = gtk_menu_item_new_with_mnemonic("_Type");
-        gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem);
-        gtk_widget_show(menuitem);
-
-        submenu = gtk_menu_new();
-        gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
-
-        populate_gtk_preset_menu(fe, preset_menu, submenu);
-
-        if (thegame.can_configure) {
-            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);
-            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);
-    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);
-    g_signal_connect(G_OBJECT(menuitem), "activate",
-                     G_CALLBACK(menu_save_event), fe);
-    gtk_widget_show(menuitem);
-#ifdef USE_PRINTING
-    if (thegame.can_print) {
-        add_menu_separator(GTK_CONTAINER(menu));
-        menuitem = gtk_menu_item_new_with_label("Print...");
-        gtk_container_add(GTK_CONTAINER(menu), menuitem);
-        g_signal_connect(G_OBJECT(menuitem), "activate",
-                         G_CALLBACK(menu_print_event), print_fe);
-        gtk_widget_show(menuitem);
-    }
-#endif
-#ifndef STYLUS_BASED
-    add_menu_separator(GTK_CONTAINER(menu));
-    add_menu_ui_item(fe, GTK_CONTAINER(menu), "Undo", UI_UNDO, 'u', 0);
-    add_menu_ui_item(fe, GTK_CONTAINER(menu), "Redo", UI_REDO, 'r', 0);
-#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);
-        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);
-        g_signal_connect(G_OBJECT(menuitem), "activate",
-                         G_CALLBACK(menu_solve_event), fe);
-        gtk_widget_show(menuitem);
-    }
-
-    add_menu_separator(GTK_CONTAINER(menu));
-    menuitem = gtk_menu_item_new_with_label("Preferences...");
-    gtk_container_add(GTK_CONTAINER(menu), menuitem);
-    g_object_set_data(G_OBJECT(menuitem), "user-data",
-                      GINT_TO_POINTER(CFG_PREFS));
-    g_signal_connect(G_OBJECT(menuitem), "activate",
-                     G_CALLBACK(menu_config_event), fe);
-    gtk_widget_show(menuitem);
-
-    add_menu_separator(GTK_CONTAINER(menu));
-    add_menu_ui_item(fe, GTK_CONTAINER(menu), "Exit", UI_QUIT, 'q', 0);
-
-    menuitem = gtk_menu_item_new_with_mnemonic("_Help");
-    gtk_container_add(GTK_CONTAINER(fe->menubar), menuitem);
-    gtk_widget_show(menuitem);
-
-    menu = gtk_menu_new();
-    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
-
-    menuitem = gtk_menu_item_new_with_label("Contents");
-    gtk_container_add(GTK_CONTAINER(menu), menuitem);
-    g_signal_connect(G_OBJECT(menuitem), "activate",
-                     G_CALLBACK(menu_help_contents_event), fe);
-    gtk_widget_show(menuitem);
-
-    if (thegame.htmlhelp_topic) {
-        char *item;
-        assert(thegame.name);
-        item = snewn(9 + strlen(thegame.name), char);
-        sprintf(item, "Help on %s", thegame.name);
-        menuitem = gtk_menu_item_new_with_label(item);
-        sfree(item);
-        gtk_container_add(GTK_CONTAINER(menu), menuitem);
-        g_signal_connect(G_OBJECT(menuitem), "activate",
-                         G_CALLBACK(menu_help_specific_event), fe);
-        gtk_widget_show(menuitem);
-    }
-
-    menuitem = gtk_menu_item_new_with_label("About");
-    gtk_container_add(GTK_CONTAINER(menu), menuitem);
-    g_signal_connect(G_OBJECT(menuitem), "activate",
-                     G_CALLBACK(menu_about_event), fe);
-    gtk_widget_show(menuitem);
-
-#ifdef STYLUS_BASED
-    menuitem=gtk_button_new_with_mnemonic("_Redo");
-    g_object_set_data(G_OBJECT(menuitem), "user-data",
-                      GINT_TO_POINTER(UI_REDO));
-    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(UI_UNDO));
-    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;
-        GtkRequisition req;
-
-        viewport = gtk_viewport_new(NULL, NULL);
-        gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
-        fe->statusbar = gtk_statusbar_new();
-        gtk_container_add(GTK_CONTAINER(viewport), fe->statusbar);
-        gtk_widget_show(viewport);
-        gtk_box_pack_end(vbox, viewport, false, false, 0);
-        gtk_widget_show(fe->statusbar);
-        fe->statusctx = gtk_statusbar_get_context_id
-            (GTK_STATUSBAR(fe->statusbar), "game");
-        gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx,
-                           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);
-#endif
-        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 = 0;
-#if GTK_CHECK_VERSION(3,0,0)
-        geom.base_height = window_extra_height(fe);
-        gtk_window_set_geometry_hints(GTK_WINDOW(fe->window), NULL,
-                                      &geom, GDK_HINT_BASE_SIZE);
-#else
-        geom.base_height = 0;
-        gtk_window_set_geometry_hints(GTK_WINDOW(fe->window), fe->area,
-                                      &geom, GDK_HINT_BASE_SIZE);
-#endif
-    }
-    fe->w = -1;
-    fe->h = -1;
-    get_size(fe, &x, &y);
-#if GTK_CHECK_VERSION(3,0,0)
-    gtk_window_set_default_size(GTK_WINDOW(fe->window),
-                                x, y + window_extra_height(fe));
-#else
-    fe->drawing_area_shrink_pending = false;
-    gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y);
-#endif
-
-    gtk_box_pack_end(vbox, fe->area, true, true, 0);
-
-    clear_backing_store(fe);
-    fe->fonts = NULL;
-    fe->nfonts = fe->fontsize = 0;
-
-    fe->paste_data = NULL;
-    fe->paste_data_len = 0;
-
-    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->window), "selection_get",
-                     G_CALLBACK(selection_get), fe);
-    g_signal_connect(G_OBJECT(fe->window), "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);
-#if GTK_CHECK_VERSION(3,0,0)
-    g_signal_connect(G_OBJECT(fe->window), "size_allocate",
-                     G_CALLBACK(window_size_alloc), fe);
-#endif
-
-    gtk_widget_add_events(GTK_WIDGET(fe->area),
-                          GDK_BUTTON_PRESS_MASK |
-                          GDK_BUTTON_RELEASE_MASK |
-                          GDK_BUTTON_MOTION_MASK |
-                          GDK_POINTER_MOTION_HINT_MASK);
-
-    if (n_xpm_icons) {
-        gtk_window_set_icon(GTK_WINDOW(fe->window),
-                            gdk_pixbuf_new_from_xpm_data
-                            ((const gchar **)xpm_icons[n_xpm_icons-1]));
-
-        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]));
-        }
-        gtk_window_set_icon_list(GTK_WINDOW(fe->window), iconlist);
-    }
-
-    gtk_widget_show(fe->area);
-    gtk_widget_show(fe->window);
-
-#if !GTK_CHECK_VERSION(3,0,0)
-    fe->drawing_area_shrink_pending = true;
-    try_shrink_drawing_area(fe);
-#endif
-
-    set_window_background(fe, 0);
-
-    return fe;
-}
-
-static void list_presets_from_menu(struct preset_menu *menu)
-{
-    int i;
-
-    for (i = 0; i < menu->n_entries; i++) {
-        if (menu->entries[i].params) {
-            char *paramstr = thegame.encode_params(
-                menu->entries[i].params, true);
-            printf("%s %s\n", paramstr, menu->entries[i].title);
-            sfree(paramstr);
-        } else {
-            list_presets_from_menu(menu->entries[i].submenu);
-        }
-    }
-}
-
-int main(int argc, char **argv)
-{
-    char *pname = argv[0];
-    int ngenerate = 0, px = 1, py = 1;
-    bool print = false;
-    bool time_generation = false, test_solve = false, list_presets = false;
-    bool delete_prefs_action = false;
-    bool soln = false, colour = false;
-    float scale = 1.0F;
-    float redo_proportion = 0.0F;
-    const char *savefile = NULL, *savesuffix = NULL;
-    char *arg = NULL;
-    int argtype = ARG_EITHER;
-    char *screenshot_file = NULL;
-    bool doing_opts = true;
-    int ac = argc;
-    char **av = argv;
-    char errbuf[500];
-
-    /*
-     * Command line parsing in this function is rather fiddly,
-     * because GTK wants to have a go at argc/argv _first_ - and
-     * yet we can't let it, because gtk_init() will bomb out if it
-     * can't open an X display, whereas in fact we want to permit
-     * our --generate and --print modes to run without an X
-     * display.
-     * 
-     * So what we do is:
-     *  - we parse the command line ourselves, without modifying
-     *    argc/argv
-     *  - if we encounter an error which might plausibly be the
-     *    result of a GTK command line (i.e. not detailed errors in
-     *    particular options of ours) we store the error message
-     *    and terminate parsing.
-     *  - if we got enough out of the command line to know it
-     *    specifies a non-X mode of operation, we either display
-     *    the stored error and return failure, or if there is no
-     *    stored error we do the non-X operation and return
-     *    success.
-     *  - otherwise, we go straight to gtk_init().
-     */
-
-    errbuf[0] = '\0';
-    while (--ac > 0) {
-        char *p = *++av;
-        if (doing_opts && !strcmp(p, "--version")) {
-            printf("%s, from Simon Tatham's Portable Puzzle Collection\n%s\n",
-                   thegame.name, ver);
-            return 0;
-        } else if (doing_opts && !strcmp(p, "--generate")) {
-            if (--ac > 0) {
-                ngenerate = atoi(*++av);
-                if (!ngenerate) {
-                    fprintf(stderr, "%s: '--generate' expected a number\n",
-                            pname);
-                    return 1;
-                }
-            } 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, "--delete-prefs") ||
-                                  !strcmp(p, "--delete-preferences"))) {
-            delete_prefs_action = 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",
-                        pname);
-                return 1;
-            }
-            print = true;
-            if (--ac > 0) {
-                char *dim = *++av;
-                if (sscanf(dim, "%dx%d", &px, &py) != 2) {
-                    fprintf(stderr, "%s: unable to parse argument '%s' to "
-                            "'--print'\n", pname, dim);
-                    return 1;
-                }
-            } else {
-                px = py = 1;
-            }
-        } else if (doing_opts && !strcmp(p, "--scale")) {
-            if (--ac > 0) {
-                scale = atof(*++av);
-            } else {
-                fprintf(stderr, "%s: no argument supplied to '--scale'\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") ||
-                                  !strcmp(p, "--with-soln") ||
-                                  !strcmp(p, "--solutions") ||
-                                  !strcmp(p, "--solution") ||
-                                  !strcmp(p, "--solns") ||
-                                  !strcmp(p, "--soln"))) {
-            soln = true;
-        } else if (doing_opts && !strcmp(p, "--colour")) {
-            if (!thegame.can_print_in_colour) {
-                fprintf(stderr, "%s: this game does not support colour"
-                        " printing\n", pname);
-                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 (arg) {
-                fprintf(stderr, "%s: more than one argument supplied\n",
-                        pname);
-                return 1;
-            }
-            arg = p;
-        } else {
-            sprintf(errbuf, "%.100s: unrecognised option '%.100s'\n",
-                    pname, p);
-            break;
-        }
-    }
-
-    /*
-     * Special standalone mode for generating puzzle IDs on the
-     * command line. Useful for generating puzzles to be printed
-     * out and solved offline (for puzzles where that even makes
-     * sense - Solo, for example, is a lot more pencil-and-paper
-     * friendly than Twiddle!)
-     * 
-     * Usage:
-     * 
-     *   <puzzle-name> --generate [<n> [<params>]]
-     * 
-     * <n>, if present, is the number of puzzle IDs to generate.
-     * <params>, if present, is the same type of parameter string
-     * you would pass to the puzzle when running it in GUI mode,
-     * including optional extras such as the expansion factor in
-     * Rectangles and the difficulty level in Solo.
-     * 
-     * If you specify <params>, you must also specify <n> (although
-     * 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 || 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);
-
-        /*
-         * In this loop, we either generate a game ID or read one
-         * from stdin depending on whether we're in generate mode;
-         * then we either write it to stdout or print it, depending
-         * on whether we're in print mode. Thus, this loop handles
-         * generate-to-stdout, print-from-stdin and generate-and-
-         * immediately-print modes.
-         * 
-         * (It could also handle a copy-stdin-to-stdout mode,
-         * although there's currently no combination of options
-         * which will cause this loop to be activated in that mode.
-         * It wouldn't be _entirely_ pointless, though, because
-         * stdin could contain bare params strings or random-seed
-         * IDs, and stdout would contain nothing but fully
-         * generated descriptive game IDs.)
-         */
-        while (ngenerate == 0 || i < n) {
-            char *pstr, *seed;
-            const char *err;
-            struct rusage before, after;
-
-            if (ngenerate == 0) {
-                pstr = fgetline(stdin);
-                if (!pstr)
-                    break;
-                pstr[strcspn(pstr, "\r\n")] = '\0';
-            } else {
-                if (arg) {
-                    pstr = snewn(strlen(arg) + 40, char);
-
-                    strcpy(pstr, arg);
-                    if (i > 0 && strchr(arg, '#'))
-                        sprintf(pstr + strlen(pstr), "-%d", i);
-                } else
-                    pstr = NULL;
-            }
-
-            if (pstr) {
-                err = midend_game_id(me, pstr);
-                if (err) {
-                    fprintf(stderr, "%s: error parsing '%s': %s\n",
-                            pname, pstr, err);
-                    return 1;
-                }
-            }
-
-            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;
-
-                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);
-                if (err) {
-                    fprintf(stderr, "%s: error in printing: %s\n", pname, err);
-                    return 1;
-                }
-            }
-            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) {
-                    const 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);
-            }
-
-            i++;
-        }
-
-        if (doc) {
-            psdata *ps = ps_init(stdout, colour);
-            document_print(doc, ps_drawing_api(ps));
-            document_free(doc);
-            ps_free(ps);
-        }
-
-        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.
-         */
-        midend *me;
-        struct preset_menu *menu;
-
-        me = midend_new(NULL, &thegame, NULL, NULL);
-        menu = midend_get_presets(me, NULL);
-        list_presets_from_menu(menu);
-        midend_free(me);
-        return 0;
-    } else if (delete_prefs_action) {
-        char *msg = NULL;
-        bool ok = delete_prefs(&thegame, &msg);
-        if (!ok) {
-            fputs(msg, stderr);
-            return 1;
-        } else {
-            fputs(msg, stdout);
-            return 0;
-        }
-    } else {
-        frontend *fe;
-        bool headless = screenshot_file != NULL;
-        char *error = NULL;
-
-        if (!headless)
-            gtk_init(&argc, &argv);
-
-        fe = new_window(arg, argtype, &error, headless);
-
-        if (!fe) {
-            fprintf(stderr, "%s: %s\n", pname, error);
-            sfree(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) {
-            save_screenshot_png(fe, screenshot_file);
-            exit(0);
-        }
-
-        gtk_main();
-    }
-
-    return 0;
-}
diff --git a/apps/plugins/puzzles/src/list.c b/apps/plugins/puzzles/src/list.c
deleted file mode 100644
index 28cefca017..0000000000
--- a/apps/plugins/puzzles/src/list.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * list.c: List of pointers to puzzle structures, for monolithic
- * platforms.
- *
- * This file depends on the header "generated-games.h", which is
- * constructed by CMakeLists.txt.
- */
-
-#include "puzzles.h"
-
-#define GAME(x) &x,
-const game *gamelist[] = {
-#include "generated-games.h"
-};
-#undef GAME
-
-const int gamecount = lenof(gamelist);
diff --git a/apps/plugins/puzzles/src/malloc.c b/apps/plugins/puzzles/src/malloc.c
deleted file mode 100644
index 39bcfac25b..0000000000
--- a/apps/plugins/puzzles/src/malloc.c
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * malloc.c: safe wrappers around malloc, realloc, free, strdup
- */
-
-#ifndef NO_STDINT_H
-#include <stdint.h>
-#endif
-#include <stdlib.h>
-#include <string.h>
-#include "puzzles.h"
-
-/*
- * smalloc should guarantee to return a useful pointer - we
- * can do nothing except die when it's out of memory anyway.
- */
-void *smalloc(size_t size) {
-    void *p;
-#ifdef PTRDIFF_MAX
-    if (size > PTRDIFF_MAX)
-        fatal("allocation too large");
-#endif
-    p = malloc(size);
-    if (!p)
-        fatal("out of memory");
-    return p;
-}
-
-/*
- * sfree should guaranteeably deal gracefully with freeing NULL
- */
-void sfree(void *p) {
-    if (p) {
-        free(p);
-    }
-}
-
-/*
- * srealloc should guaranteeably be able to realloc NULL
- */
-void *srealloc(void *p, size_t size) {
-    void *q;
-#ifdef PTRDIFF_MAX
-    if (size > PTRDIFF_MAX)
-        fatal("allocation too large");
-#endif
-    if (p) {
-        q = realloc(p, size);
-    } else {
-        q = malloc(size);
-    }
-    if (!q)
-        fatal("out of memory");
-    return q;
-}
-
-/*
- * dupstr is like strdup, but with the never-return-NULL property
- * of smalloc (and also reliably defined in all environments :-)
- */
-char *dupstr(const char *s) {
-    char *r = smalloc(1+strlen(s));
-    strcpy(r,s);
-    return r;
-}
diff --git a/apps/plugins/puzzles/src/nestedvm.c b/apps/plugins/puzzles/src/nestedvm.c
deleted file mode 100644
index 0a9fdbcfed..0000000000
--- a/apps/plugins/puzzles/src/nestedvm.c
+++ /dev/null
@@ -1,486 +0,0 @@
-/*
- * nestedvm.c: NestedVM front end for my puzzle collection.
- */
-
-#include <stdio.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <time.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-
-#include <sys/time.h>
-
-#include "puzzles.h"
-
-extern void _pause();
-extern int _call_java(int cmd, int arg1, int arg2, int arg3);
-
-void fatal(const char *fmt, ...)
-{
-    va_list ap;
-    fprintf(stderr, "fatal error: ");
-    va_start(ap, fmt);
-    vfprintf(stderr, fmt, ap);
-    va_end(ap);
-    fprintf(stderr, "\n");
-    exit(1);
-}
-
-struct frontend {
-    // TODO kill unneeded members!
-    midend *me;
-    bool timer_active;
-    struct timeval last_time;
-    config_item *cfg;
-    int cfg_which;
-    bool cfgret;
-    int ox, oy, w, h;
-};
-
-static frontend *_fe;
-
-void get_random_seed(void **randseed, int *randseedsize)
-{
-    struct timeval *tvp = snew(struct timeval);
-    gettimeofday(tvp, NULL);
-    *randseed = (void *)tvp;
-    *randseedsize = sizeof(struct timeval);
-}
-
-void frontend_default_colour(frontend *fe, float *output)
-{
-    output[0] = output[1]= output[2] = 0.8f;
-}
-
-void nestedvm_status_bar(void *handle, const char *text)
-{
-    _call_java(4,0,(int)text,0);
-}
-
-void nestedvm_start_draw(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-    _call_java(5, 0, fe->w, fe->h);
-    _call_java(4, 1, fe->ox, fe->oy);
-}
-
-void nestedvm_clip(void *handle, int x, int y, int w, int h)
-{
-    frontend *fe = (frontend *)handle;
-    _call_java(5, w, h, 0);
-    _call_java(4, 3, x + fe->ox, y + fe->oy);
-}
-
-void nestedvm_unclip(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-    _call_java(4, 4, fe->ox, fe->oy);
-}
-
-void nestedvm_draw_text(void *handle, int x, int y, int fonttype, int fontsize,
-                        int align, int colour, const char *text)
-{
-    frontend *fe = (frontend *)handle;
-    _call_java(5, x + fe->ox, y + fe->oy, 
-               (fonttype == FONT_FIXED ? 0x10 : 0x0) | align);
-    _call_java(7, fontsize, colour, (int)text);
-}
-
-void nestedvm_draw_rect(void *handle, int x, int y, int w, int h, int colour)
-{
-    frontend *fe = (frontend *)handle;
-    _call_java(5, w, h, colour);
-    _call_java(4, 5, x + fe->ox, y + fe->oy);
-}
-
-void nestedvm_draw_line(void *handle, int x1, int y1, int x2, int y2, 
-                        int colour)
-{
-    frontend *fe = (frontend *)handle;
-    _call_java(5, x2 + fe->ox, y2 + fe->oy, colour);
-    _call_java(4, 6, x1 + fe->ox, y1 + fe->oy);
-}
-
-void nestedvm_draw_poly(void *handle, int *coords, int npoints,
-                        int fillcolour, int outlinecolour)
-{
-    frontend *fe = (frontend *)handle;
-    int i;
-    _call_java(4, 7, npoints, 0);
-    for (i = 0; i < npoints; i++) {
-        _call_java(6, i, coords[i*2] + fe->ox, coords[i*2+1] + fe->oy);
-    }
-    _call_java(4, 8, outlinecolour, fillcolour);
-}
-
-void nestedvm_draw_circle(void *handle, int cx, int cy, int radius,
-                     int fillcolour, int outlinecolour)
-{
-    frontend *fe = (frontend *)handle;
-    _call_java(5, cx+fe->ox, cy+fe->oy, radius);
-    _call_java(4, 9, outlinecolour, fillcolour);
-}
-
-struct blitter {
-    int handle, w, h, x, y;
-};
-
-blitter *nestedvm_blitter_new(void *handle, int w, int h)
-{
-    blitter *bl = snew(blitter);
-    bl->handle = -1;
-    bl->w = w;
-    bl->h = h;
-    return bl;
-}
-
-void nestedvm_blitter_free(void *handle, blitter *bl)
-{
-    if (bl->handle != -1)
-        _call_java(4, 11, bl->handle, 0);
-    sfree(bl);
-}
-
-void nestedvm_blitter_save(void *handle, blitter *bl, int x, int y)
-{
-    frontend *fe = (frontend *)handle;    
-    if (bl->handle == -1)
-        bl->handle = _call_java(4,10,bl->w, bl->h);
-    bl->x = x;
-    bl->y = y;
-    _call_java(8, bl->handle, x + fe->ox, y + fe->oy);
-}
-
-void nestedvm_blitter_load(void *handle, blitter *bl, int x, int y)
-{
-    frontend *fe = (frontend *)handle;
-    assert(bl->handle != -1);
-    if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) {
-        x = bl->x;
-        y = bl->y;
-    }
-    _call_java(9, bl->handle, x + fe->ox, y + fe->oy);
-}
-
-void nestedvm_end_draw(void *handle)
-{
-    _call_java(4,2,0,0);
-}
-
-char *nestedvm_text_fallback(void *handle, const char *const *strings,
-                             int nstrings)
-{
-    /*
-     * We assume Java can cope with any UTF-8 likely to be emitted
-     * by a puzzle.
-     */
-    return dupstr(strings[0]);
-}
-
-const struct drawing_api nestedvm_drawing = {
-    nestedvm_draw_text,
-    nestedvm_draw_rect,
-    nestedvm_draw_line,
-    nestedvm_draw_poly,
-    nestedvm_draw_circle,
-    NULL, // draw_update,
-    nestedvm_clip,
-    nestedvm_unclip,
-    nestedvm_start_draw,
-    nestedvm_end_draw,
-    nestedvm_status_bar,
-    nestedvm_blitter_new,
-    nestedvm_blitter_free,
-    nestedvm_blitter_save,
-    nestedvm_blitter_load,
-    NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
-    NULL, NULL,                        /* line_width, line_dotted */
-    nestedvm_text_fallback,
-};
-
-int jcallback_key_event(int x, int y, int keyval)
-{
-    frontend *fe = (frontend *)_fe;
-    if (fe->ox == -1)
-        return 1;
-    if (keyval >= 0 &&
-        midend_process_key(fe->me, x - fe->ox, y - fe->oy, keyval) == PKR_QUIT)
-        return 42;
-    return 1;
-}
-
-int jcallback_resize(int width, int height)
-{
-    frontend *fe = (frontend *)_fe;
-    int x, y;
-    x = width;
-    y = height;
-    midend_size(fe->me, &x, &y, true, 1.0);
-    fe->ox = (width - x) / 2;
-    fe->oy = (height - y) / 2;
-    fe->w = x;
-    fe->h = y;
-    midend_force_redraw(fe->me);
-    return 0;
-}
-
-int jcallback_timer_func()
-{
-    frontend *fe = (frontend *)_fe;
-    if (fe->timer_active) {
-        struct timeval now;
-        float elapsed;
-        gettimeofday(&now, NULL);
-        elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F +
-                   (now.tv_sec - fe->last_time.tv_sec));
-        midend_timer(fe->me, elapsed);  /* may clear timer_active */
-        fe->last_time = now;
-    }
-    return fe->timer_active;
-}
-
-void deactivate_timer(frontend *fe)
-{
-    if (fe->timer_active)
-        _call_java(4, 13, 0, 0);
-    fe->timer_active = false;
-}
-
-void activate_timer(frontend *fe)
-{
-    if (!fe->timer_active) {
-        _call_java(4, 12, 0, 0);
-        gettimeofday(&fe->last_time, NULL);
-    }
-    fe->timer_active = true;
-}
-
-void jcallback_config_ok()
-{
-    frontend *fe = (frontend *)_fe;
-    const char *err;
-
-    err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
-
-    if (err)
-        _call_java(2, (int) "Error", (int)err, 1);
-    else {
-        fe->cfgret = true;
-    }
-}
-
-void jcallback_config_set_string(int item_ptr, int char_ptr) {
-    config_item *i = (config_item *)item_ptr;
-    char* newval = (char*) char_ptr;
-    assert(i->type == C_STRING);
-    sfree(i->u.string.sval);
-    i->u.string.sval = dupstr(newval);
-    free(newval);
-}
-
-void jcallback_config_set_boolean(int item_ptr, int selected) {
-    config_item *i = (config_item *)item_ptr;
-    assert(i->type == C_BOOLEAN);
-    i->u.boolean.bval = selected != 0 ? true : false;
-}
-
-void jcallback_config_set_choice(int item_ptr, int selected) {
-    config_item *i = (config_item *)item_ptr;
-    assert(i->type == C_CHOICES);
-    i->u.choices.selected = selected;
-}
-
-static bool get_config(frontend *fe, int which)
-{
-    char *title;
-    config_item *i;
-    fe->cfg = midend_get_config(fe->me, which, &title);
-    fe->cfg_which = which;
-    fe->cfgret = false;
-    _call_java(10, (int)title, 0, 0);
-    for (i = fe->cfg; i->type != C_END; i++) {
-        _call_java(5, (int)i, i->type, (int)i->name);
-        switch (i->type) {
-          case C_STRING:
-            _call_java(11, (int)i->u.string.sval, 0, 0);
-            break;
-          case C_BOOLEAN:
-            _call_java(11, 0, i->u.boolean.bval, 0);
-            break;
-          case C_CHOICES:
-            _call_java(11, (int)i->u.choices.choicenames,
-                       i->u.choices.selected, 0);
-            break;
-        }
-    }
-    _call_java(12,0,0,0);
-    free_cfg(fe->cfg);
-    return fe->cfgret;
-}
-
-int jcallback_newgame_event(void)
-{
-    frontend *fe = (frontend *)_fe;
-    if (midend_process_key(fe->me, 0, 0, UI_NEWGAME) == PKR_QUIT)
-        return 42;
-    return 0;
-}
-
-int jcallback_undo_event(void)
-{
-    frontend *fe = (frontend *)_fe;
-    if (midend_process_key(fe->me, 0, 0, UI_UNDO) == PKR_QUIT)
-        return 42;
-    return 0;
-}
-
-int jcallback_redo_event(void)
-{
-    frontend *fe = (frontend *)_fe;
-    if (midend_process_key(fe->me, 0, 0, UI_REDO) == PKR_QUIT)
-        return 42;
-    return 0;
-}
-
-int jcallback_quit_event(void)
-{
-    frontend *fe = (frontend *)_fe;
-    if (midend_process_key(fe->me, 0, 0, UI_QUIT) == PKR_QUIT)
-        return 42;
-    return 0;
-}
-
-static void resize_fe(frontend *fe)
-{
-    int x, y;
-
-    x = INT_MAX;
-    y = INT_MAX;
-    midend_size(fe->me, &x, &y, false, 1.0);
-    _call_java(3, x, y, 0);
-}
-
-int jcallback_preset_event(int ptr_game_params)
-{
-    frontend *fe = (frontend *)_fe;
-    game_params *params =
-        (game_params *)ptr_game_params;
-
-    midend_set_params(fe->me, params);
-    midend_new_game(fe->me);
-    resize_fe(fe);
-    _call_java(13, midend_which_preset(fe->me), 0, 0);
-    return 0;
-}
-
-int jcallback_solve_event()
-{
-    frontend *fe = (frontend *)_fe;
-    const char *msg;
-
-    msg = midend_solve(fe->me);
-
-    if (msg)
-        _call_java(2, (int) "Error", (int)msg, 1);
-    return 0;
-}
-
-int jcallback_restart_event()
-{
-    frontend *fe = (frontend *)_fe;
-
-    midend_restart_game(fe->me);
-    return 0;
-}
-
-int jcallback_config_event(int which)
-{
-    frontend *fe = (frontend *)_fe;
-    _call_java(13, midend_which_preset(fe->me), 0, 0);
-    if (!get_config(fe, which))
-        return 0;
-    midend_new_game(fe->me);
-    resize_fe(fe);
-    _call_java(13, midend_which_preset(fe->me), 0, 0);
-    return 0;
-}
-
-int jcallback_about_event()
-{
-    char titlebuf[256];
-    char textbuf[1024];
-
-    sprintf(titlebuf, "About %.200s", thegame.name);
-    sprintf(textbuf,
-            "%.200s\n\n"
-            "from Simon Tatham's Portable Puzzle Collection\n\n"
-            "%.500s", thegame.name, ver);
-    _call_java(2, (int)&titlebuf, (int)&textbuf, 0);
-    return 0;
-}
-
-void preset_menu_populate(struct preset_menu *menu, int menuid)
-{
-    int i;
-
-    for (i = 0; i < menu->n_entries; i++) {
-        struct preset_menu_entry *entry = &menu->entries[i];
-        if (entry->params) {
-            _call_java(5, (int)entry->params, 0, 0);
-            _call_java(1, (int)entry->title, menuid, entry->id);
-        } else {
-            _call_java(5, 0, 0, 0);
-            _call_java(1, (int)entry->title, menuid, entry->id);
-            preset_menu_populate(entry->submenu, entry->id);
-        }
-    }
-}
-
-int main(int argc, char **argv)
-{
-    int i, n;
-    float* colours;
-
-    _fe = snew(frontend);
-    _fe->timer_active = false;
-    _fe->me = midend_new(_fe, &thegame, &nestedvm_drawing, _fe);
-    if (argc > 1)
-        midend_game_id(_fe->me, argv[1]);   /* ignore failure */
-    midend_new_game(_fe->me);
-
-    {
-        struct preset_menu *menu;
-        int nids, topmenu;
-        menu = midend_get_presets(_fe->me, &nids);
-        topmenu = _call_java(1, 0, nids, 0);
-        preset_menu_populate(menu, topmenu);
-    }
-
-    colours = midend_colours(_fe->me, &n);
-    _fe->ox = -1;
-
-    _call_java(0, (int)thegame.name,
-               (thegame.can_configure ? 1 : 0) |
-               (midend_wants_statusbar(_fe->me) ? 2 : 0) |
-               (thegame.can_solve ? 4 : 0), n);    
-    for (i = 0; i < n; i++) {
-        _call_java(1024+ i,
-                   (int)(colours[i*3] * 0xFF),
-                   (int)(colours[i*3+1] * 0xFF),
-                   (int)(colours[i*3+2] * 0xFF));
-    }
-    resize_fe(_fe);
-
-    _call_java(13, midend_which_preset(_fe->me), 0, 0);
-
-    // Now pause the vm. The VM will be call()ed when
-    // an input event occurs.
-    _pause();
-
-    // shut down when the VM is resumed.
-    deactivate_timer(_fe);
-    midend_free(_fe->me);
-    return 0;
-}
diff --git a/apps/plugins/puzzles/src/no-icon.c b/apps/plugins/puzzles/src/no-icon.c
deleted file mode 100644
index 5091dca426..0000000000
--- a/apps/plugins/puzzles/src/no-icon.c
+++ /dev/null
@@ -1,10 +0,0 @@
-
-/*
- * Dummy source file which replaces the files generated in the
- * `icons' subdirectory, when they're absent.
- */
-
-#include "gtk.h"
-
-const char *const *const xpm_icons[] = { 0 };
-const int n_xpm_icons = 0;
diff --git a/apps/plugins/puzzles/src/nullfe.c b/apps/plugins/puzzles/src/nullfe.c
deleted file mode 100644
index 9a57832b6e..0000000000
--- a/apps/plugins/puzzles/src/nullfe.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * nullfe.c: Null front-end code containing a bunch of boring stub
- * functions. Used to ensure successful linking when building the
- * various stand-alone solver binaries.
- */
-
-#include <stdarg.h>
-
-#include "puzzles.h"
-
-void frontend_default_colour(frontend *fe, float *output) {}
-void get_random_seed(void **randseed, int *randseedsize)
-{ char *c = snewn(1, char); *c = 0; *randseed = c; *randseedsize = 1; }
-void deactivate_timer(frontend *fe) {}
-void activate_timer(frontend *fe) {}
-struct drawing { char dummy; };
-drawing *drawing_new(const drawing_api *api, midend *me, void *handle)
-{ return snew(drawing); }
-void drawing_free(drawing *dr) { sfree(dr); }
-void draw_text(drawing *dr, int x, int y, int fonttype, int fontsize,
-               int align, int colour, const char *text) {}
-void draw_rect(drawing *dr, int x, int y, int w, int h, int colour) {}
-void draw_line(drawing *dr, int x1, int y1, int x2, int y2, int colour) {}
-void draw_thick_line(drawing *dr, float thickness,
-                     float x1, float y1, float x2, float y2, int colour) {}
-void draw_polygon(drawing *dr, const int *coords, int npoints,
-                  int fillcolour, int outlinecolour) {}
-void draw_circle(drawing *dr, int cx, int cy, int radius,
-                 int fillcolour, int outlinecolour) {}
-char *text_fallback(drawing *dr, const char *const *strings, int nstrings)
-{ return dupstr(strings[0]); }
-void clip(drawing *dr, int x, int y, int w, int h) {}
-void unclip(drawing *dr) {}
-void start_draw(drawing *dr) {}
-void draw_update(drawing *dr, int x, int y, int w, int h) {}
-void end_draw(drawing *dr) {}
-struct blitter { char dummy; };
-blitter *blitter_new(drawing *dr, int w, int h) { return snew(blitter); }
-void blitter_free(drawing *dr, blitter *bl) { sfree(bl); }
-void blitter_save(drawing *dr, blitter *bl, int x, int y) {}
-void blitter_load(drawing *dr, blitter *bl, int x, int y) {}
-int print_mono_colour(drawing *dr, int grey) { return 0; }
-int print_grey_colour(drawing *dr, float grey) { return 0; }
-int print_hatched_colour(drawing *dr, int hatch) { return 0; }
-int print_rgb_mono_colour(drawing *dr, float r, float g, float b, int grey)
-{ return 0; }
-int print_rgb_grey_colour(drawing *dr, float r, float g, float b, float grey)
-{ return 0; }
-int print_rgb_hatched_colour(drawing *dr, float r, float g, float b, int hatch)
-{ return 0; }
-void print_line_width(drawing *dr, int width) {}
-void print_line_dotted(drawing *dr, bool dotted) {}
-void status_bar(drawing *dr, const char *text) {}
-void document_add_puzzle(document *doc, const game *game, game_params *par,
-                         game_ui *ui, game_state *st, game_state *st2) {}
-
-void fatal(const char *fmt, ...)
-{
-    va_list ap;
-
-    fprintf(stderr, "fatal error: ");
-
-    va_start(ap, fmt);
-    vfprintf(stderr, fmt, ap);
-    va_end(ap);
-
-    fprintf(stderr, "\n");
-    exit(1);
-}
-
-#ifdef DEBUGGING
-void debug_printf(const char *fmt, ...)
-{
-    va_list ap;
-    va_start(ap, fmt);
-    vfprintf(stdout, fmt, ap);
-    va_end(ap);
-}
-#endif
diff --git a/apps/plugins/puzzles/src/nullgame.c b/apps/plugins/puzzles/src/nullgame.c
deleted file mode 100644
index c1c2ed18fd..0000000000
--- a/apps/plugins/puzzles/src/nullgame.c
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * nullgame.c [FIXME]: Template defining the null game (in which no
- * moves are permitted and nothing is ever drawn). This file exists
- * solely as a basis for constructing new game definitions - it
- * helps to have something which will compile from the word go and
- * merely doesn't _do_ very much yet.
- * 
- * Parts labelled FIXME actually want _removing_ (e.g. the dummy
- * field in each of the required data structures, and this entire
- * comment itself) when converting this source file into one
- * describing a real game.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <ctype.h>
-#ifdef NO_TGMATH_H
-#  include <math.h>
-#else
-#  include <tgmath.h>
-#endif
-
-#include "puzzles.h"
-
-enum {
-    COL_BACKGROUND,
-    NCOLOURS
-};
-
-struct game_params {
-    int FIXME;
-};
-
-struct game_state {
-    int FIXME;
-};
-
-static game_params *default_params(void)
-{
-    game_params *ret = snew(game_params);
-
-    ret->FIXME = 0;
-
-    return ret;
-}
-
-static bool game_fetch_preset(int i, char **name, game_params **params)
-{
-    return false;
-}
-
-static void free_params(game_params *params)
-{
-    sfree(params);
-}
-
-static game_params *dup_params(const game_params *params)
-{
-    game_params *ret = snew(game_params);
-    *ret = *params;                    /* structure copy */
-    return ret;
-}
-
-static void decode_params(game_params *params, char const *string)
-{
-}
-
-static char *encode_params(const game_params *params, bool full)
-{
-    return dupstr("FIXME");
-}
-
-static const char *validate_params(const game_params *params, bool full)
-{
-    return NULL;
-}
-
-static char *new_game_desc(const game_params *params, random_state *rs,
-                           char **aux, bool interactive)
-{
-    return dupstr("FIXME");
-}
-
-static const char *validate_desc(const game_params *params, const char *desc)
-{
-    return NULL;
-}
-
-static game_state *new_game(midend *me, const game_params *params,
-                            const char *desc)
-{
-    game_state *state = snew(game_state);
-
-    state->FIXME = 0;
-
-    return state;
-}
-
-static game_state *dup_game(const game_state *state)
-{
-    game_state *ret = snew(game_state);
-
-    ret->FIXME = state->FIXME;
-
-    return ret;
-}
-
-static void free_game(game_state *state)
-{
-    sfree(state);
-}
-
-static game_ui *new_ui(const game_state *state)
-{
-    return NULL;
-}
-
-static void free_ui(game_ui *ui)
-{
-}
-
-static void game_changed_state(game_ui *ui, const game_state *oldstate,
-                               const game_state *newstate)
-{
-}
-
-struct game_drawstate {
-    int tilesize;
-    int FIXME;
-};
-
-static char *interpret_move(const game_state *state, game_ui *ui,
-                            const game_drawstate *ds,
-                            int x, int y, int button)
-{
-    return NULL;
-}
-
-static game_state *execute_move(const game_state *state, const char *move)
-{
-    return NULL;
-}
-
-/* ----------------------------------------------------------------------
- * Drawing routines.
- */
-
-static void game_compute_size(const game_params *params, int tilesize,
-                              const game_ui *ui, int *x, int *y)
-{
-    *x = *y = 10 * tilesize;           /* FIXME */
-}
-
-static void game_set_size(drawing *dr, game_drawstate *ds,
-                          const game_params *params, int tilesize)
-{
-    ds->tilesize = tilesize;
-}
-
-static float *game_colours(frontend *fe, int *ncolours)
-{
-    float *ret = snewn(3 * NCOLOURS, float);
-
-    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
-
-    *ncolours = NCOLOURS;
-    return ret;
-}
-
-static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
-{
-    struct game_drawstate *ds = snew(struct game_drawstate);
-
-    ds->tilesize = 0;
-    ds->FIXME = 0;
-
-    return ds;
-}
-
-static void game_free_drawstate(drawing *dr, game_drawstate *ds)
-{
-    sfree(ds);
-}
-
-static void game_redraw(drawing *dr, game_drawstate *ds,
-                        const game_state *oldstate, const game_state *state,
-                        int dir, const game_ui *ui,
-                        float animtime, float flashtime)
-{
-}
-
-static float game_anim_length(const game_state *oldstate,
-                              const game_state *newstate, int dir, game_ui *ui)
-{
-    return 0.0F;
-}
-
-static float game_flash_length(const game_state *oldstate,
-                               const game_state *newstate, int dir, game_ui *ui)
-{
-    return 0.0F;
-}
-
-static void game_get_cursor_location(const game_ui *ui,
-                                     const game_drawstate *ds,
-                                     const game_state *state,
-                                     const game_params *params,
-                                     int *x, int *y, int *w, int *h)
-{
-}
-
-static int game_status(const game_state *state)
-{
-    return 0;
-}
-
-#ifdef COMBINED
-#define thegame nullgame
-#endif
-
-const struct game thegame = {
-    "Null Game", NULL, NULL,
-    default_params,
-    game_fetch_preset, NULL,
-    decode_params,
-    encode_params,
-    free_params,
-    dup_params,
-    false, NULL, NULL, /* configure, custom_params */
-    validate_params,
-    new_game_desc,
-    validate_desc,
-    new_game,
-    dup_game,
-    free_game,
-    false, NULL, /* solve */
-    false, NULL, NULL, /* can_format_as_text_now, text_format */
-    NULL, NULL, /* get_prefs, set_prefs */
-    new_ui,
-    free_ui,
-    NULL, /* encode_ui */
-    NULL, /* decode_ui */
-    NULL, /* game_request_keys */
-    game_changed_state,
-    NULL, /* current_key_label */
-    interpret_move,
-    execute_move,
-    20 /* FIXME */, game_compute_size, game_set_size,
-    game_colours,
-    game_new_drawstate,
-    game_free_drawstate,
-    game_redraw,
-    game_anim_length,
-    game_flash_length,
-    game_get_cursor_location,
-    game_status,
-    false, false, NULL, NULL,          /* print_size, print */
-    false,                             /* wants_statusbar */
-    false, NULL,                       /* timing_state */
-    0,                                 /* flags */
-};
diff --git a/apps/plugins/puzzles/src/osx-help.but b/apps/plugins/puzzles/src/osx-help.but
deleted file mode 100644
index fa45996aee..0000000000
--- a/apps/plugins/puzzles/src/osx-help.but
+++ /dev/null
@@ -1,14 +0,0 @@
-\# Additional Halibut fragment to set up the HTML output
-\# appropriately for MacOS online help.
-
-\cfg{html-head-end}{
-<style type="text/css">
-body \{ font-family: "Lucida Grande", Helvetica, Arial; font-size: 9pt \}
-h1 \{ font-size: 12pt \}
-h2 \{ font-size: 10pt \}
-h3 \{ font-size: 9pt \}
-h4 \{ font-size: 9pt \}
-h5 \{ font-size: 9pt \}
-h6 \{ font-size: 9pt \}
-</style>
-}
diff --git a/apps/plugins/puzzles/src/ps.c b/apps/plugins/puzzles/src/ps.c
deleted file mode 100644
index d0ea0ff2b5..0000000000
--- a/apps/plugins/puzzles/src/ps.c
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
- * ps.c: PostScript printing functions.
- */
-
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-#include <assert.h>
-
-#include "puzzles.h"
-
-struct psdata {
-    FILE *fp;
-    bool colour;
-    int ytop;
-    bool clipped;
-    float hatchthick, hatchspace;
-    int gamewidth, gameheight;
-    drawing *drawing;
-};
-
-static void ps_printf(psdata *ps, const char *fmt, ...)
-{
-    va_list ap;
-
-    va_start(ap, fmt);
-    vfprintf(ps->fp, fmt, ap);
-    va_end(ap);
-}
-
-static void ps_fill(psdata *ps, int colour)
-{
-    int hatch;
-    float r, g, b;
-
-    print_get_colour(ps->drawing, colour, ps->colour, &hatch, &r, &g, &b);
-
-    if (hatch < 0) {
-        if (ps->colour)
-            ps_printf(ps, "%g %g %g setrgbcolor fill\n", r, g, b);
-        else
-            ps_printf(ps, "%g setgray fill\n", r);
-    } else {
-        /* Clip to the region. */
-        ps_printf(ps, "gsave clip\n");
-        /* Hatch the entire game printing area. */
-        ps_printf(ps, "newpath\n");
-        if (hatch == HATCH_VERT || hatch == HATCH_PLUS)
-            ps_printf(ps, "0 %g %d {\n"
-                      "  0 moveto 0 %d rlineto\n"
-                      "} for\n", ps->hatchspace, ps->gamewidth,
-                      ps->gameheight);
-        if (hatch == HATCH_HORIZ || hatch == HATCH_PLUS)
-            ps_printf(ps, "0 %g %d {\n"
-                      "  0 exch moveto %d 0 rlineto\n"
-                      "} for\n", ps->hatchspace, ps->gameheight,
-                      ps->gamewidth);
-        if (hatch == HATCH_SLASH || hatch == HATCH_X)
-            ps_printf(ps, "%d %g %d {\n"
-                      "  0 moveto %d dup rlineto\n"
-                      "} for\n", -ps->gameheight, ps->hatchspace * ROOT2,
-                      ps->gamewidth, max(ps->gamewidth, ps->gameheight));
-        if (hatch == HATCH_BACKSLASH || hatch == HATCH_X)
-            ps_printf(ps, "0 %g %d {\n"
-                      "  0 moveto %d neg dup neg rlineto\n"
-                      "} for\n", ps->hatchspace * ROOT2,
-                      ps->gamewidth+ps->gameheight,
-                      max(ps->gamewidth, ps->gameheight));
-        ps_printf(ps, "0 setgray %g setlinewidth stroke grestore\n",
-                  ps->hatchthick);
-    }
-}
-
-static void ps_setcolour_internal(psdata *ps, int colour, const char *suffix)
-{
-    int hatch;
-    float r, g, b;
-
-    print_get_colour(ps->drawing, colour, ps->colour, &hatch, &r, &g, &b);
-
-    /*
-     * Stroking in hatched colours is not permitted.
-     */
-    assert(hatch < 0);
-    
-    if (ps->colour)
-        ps_printf(ps, "%g %g %g setrgbcolor%s\n", r, g, b, suffix);
-    else
-        ps_printf(ps, "%g setgray%s\n", r, suffix);
-}
-
-static void ps_setcolour(psdata *ps, int colour)
-{
-    ps_setcolour_internal(ps, colour, "");
-}
-
-static void ps_stroke(psdata *ps, int colour)
-{
-    ps_setcolour_internal(ps, colour, " stroke");
-}
-
-static void ps_draw_text(void *handle, int x, int y, int fonttype,
-                         int fontsize, int align, int colour,
-                         const char *text)
-{
-    psdata *ps = (psdata *)handle;
-
-    y = ps->ytop - y;
-    ps_setcolour(ps, colour);
-    ps_printf(ps, "/%s findfont %d scalefont setfont\n",
-              fonttype == FONT_FIXED ? "Courier-L1" : "Helvetica-L1",
-              fontsize);
-    if (align & ALIGN_VCENTRE) {
-        ps_printf(ps, "newpath 0 0 moveto (X) true charpath flattenpath"
-                  " pathbbox\n"
-                  "3 -1 roll add 2 div %d exch sub %d exch moveto pop pop\n",
-                  y, x);
-    } else {
-        ps_printf(ps, "%d %d moveto\n", x, y);
-    }
-    ps_printf(ps, "(");
-    while (*text) {
-        if (*text == '\\' || *text == '(' || *text == ')')
-            ps_printf(ps, "\\");
-        ps_printf(ps, "%c", *text);
-        text++;
-    }
-    ps_printf(ps, ") ");
-    if (align & (ALIGN_HCENTRE | ALIGN_HRIGHT))
-        ps_printf(ps, "dup stringwidth pop %sneg 0 rmoveto show\n",
-                  (align & ALIGN_HCENTRE) ? "2 div " : "");
-    else
-        ps_printf(ps, "show\n");
-}
-
-static void ps_draw_rect(void *handle, int x, int y, int w, int h, int colour)
-{
-    psdata *ps = (psdata *)handle;
-
-    y = ps->ytop - y;
-    /*
-     * Offset by half a pixel for the exactness requirement.
-     */
-    ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
-              " %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
-    ps_fill(ps, colour);
-}
-
-static void ps_draw_line(void *handle, int x1, int y1, int x2, int y2,
-                         int colour)
-{
-    psdata *ps = (psdata *)handle;
-
-    y1 = ps->ytop - y1;
-    y2 = ps->ytop - y2;
-    ps_printf(ps, "newpath %d %d moveto %d %d lineto\n", x1, y1, x2, y2);
-    ps_stroke(ps, colour);
-}
-
-static void ps_draw_polygon(void *handle, const int *coords, int npoints,
-                            int fillcolour, int outlinecolour)
-{
-    psdata *ps = (psdata *)handle;
-
-    int i;
-
-    ps_printf(ps, "newpath %d %d moveto\n", coords[0], ps->ytop - coords[1]);
-
-    for (i = 1; i < npoints; i++)
-        ps_printf(ps, "%d %d lineto\n", coords[i*2], ps->ytop - coords[i*2+1]);
-
-    ps_printf(ps, "closepath\n");
-
-    if (fillcolour >= 0) {
-        ps_printf(ps, "gsave\n");
-        ps_fill(ps, fillcolour);
-        ps_printf(ps, "grestore\n");
-    }
-    ps_stroke(ps, outlinecolour);
-}
-
-static void ps_draw_circle(void *handle, int cx, int cy, int radius,
-                           int fillcolour, int outlinecolour)
-{
-    psdata *ps = (psdata *)handle;
-
-    cy = ps->ytop - cy;
-
-    ps_printf(ps, "newpath %d %d %d 0 360 arc closepath\n", cx, cy, radius);
-
-    if (fillcolour >= 0) {
-        ps_printf(ps, "gsave\n");
-        ps_fill(ps, fillcolour);
-        ps_printf(ps, "grestore\n");
-    }
-    ps_stroke(ps, outlinecolour);
-}
-
-static void ps_unclip(void *handle)
-{
-    psdata *ps = (psdata *)handle;
-
-    assert(ps->clipped);
-    ps_printf(ps, "grestore\n");
-    ps->clipped = false;
-}
- 
-static void ps_clip(void *handle, int x, int y, int w, int h)
-{
-    psdata *ps = (psdata *)handle;
-
-    if (ps->clipped)
-        ps_unclip(ps);
-
-    y = ps->ytop - y;
-    /*
-     * Offset by half a pixel for the exactness requirement.
-     */
-    ps_printf(ps, "gsave\n");
-    ps_printf(ps, "newpath %g %g moveto %d 0 rlineto 0 %d rlineto"
-              " %d 0 rlineto closepath\n", x - 0.5, y + 0.5, w, -h, -w);
-    ps_printf(ps, "clip\n");
-    ps->clipped = true;
-}
-
-static void ps_line_width(void *handle, float width)
-{
-    psdata *ps = (psdata *)handle;
-
-    ps_printf(ps, "%g setlinewidth\n", width);
-}
-
-static void ps_line_dotted(void *handle, bool dotted)
-{
-    psdata *ps = (psdata *)handle;
-
-    if (dotted) {
-        ps_printf(ps, "[ currentlinewidth 3 mul ] 0 setdash\n");
-    } else {
-        ps_printf(ps, "[ ] 0 setdash\n");
-    }
-}
-
-static char *ps_text_fallback(void *handle, const char *const *strings,
-                              int nstrings)
-{
-    /*
-     * We can handle anything in ISO 8859-1, and we'll manually
-     * translate it out of UTF-8 for the purpose.
-     */
-    int i, maxlen;
-    char *ret;
-
-    maxlen = 0;
-    for (i = 0; i < nstrings; i++) {
-        int len = strlen(strings[i]);
-        if (maxlen < len) maxlen = len;
-    }
-
-    ret = snewn(maxlen + 1, char);
-
-    for (i = 0; i < nstrings; i++) {
-        const char *p = strings[i];
-        char *q = ret;
-
-        while (*p) {
-            int c = (unsigned char)*p++;
-            if (c < 0x80) {
-                *q++ = c;              /* ASCII */
-            } else if ((c == 0xC2 || c == 0xC3) && (*p & 0xC0) == 0x80) {
-                *q++ = (c << 6) | (*p++ & 0x3F);   /* top half of 8859-1 */
-            } else {
-                break;
-            }
-        }
-
-        if (!*p) {
-            *q = '\0';
-            return ret;
-        }
-    }
-
-    assert(!"Should never reach here");
-    return NULL;
-}
-
-static void ps_begin_doc(void *handle, int pages)
-{
-    psdata *ps = (psdata *)handle;
-
-    fputs("%!PS-Adobe-3.0\n", ps->fp);
-    fputs("%%Creator: Simon Tatham's Portable Puzzle Collection\n", ps->fp);
-    fputs("%%DocumentData: Clean7Bit\n", ps->fp);
-    fputs("%%LanguageLevel: 1\n", ps->fp);
-    fprintf(ps->fp, "%%%%Pages: %d\n", pages);
-    fputs("%%DocumentNeededResources:\n", ps->fp);
-    fputs("%%+ font Helvetica\n", ps->fp);
-    fputs("%%+ font Courier\n", ps->fp);
-    fputs("%%EndComments\n", ps->fp);
-    fputs("%%BeginSetup\n", ps->fp);
-    fputs("%%IncludeResource: font Helvetica\n", ps->fp);
-    fputs("%%IncludeResource: font Courier\n", ps->fp);
-    fputs("%%EndSetup\n", ps->fp);
-    fputs("%%BeginProlog\n", ps->fp);
-    /*
-     * Re-encode Helvetica and Courier into ISO-8859-1, which gives
-     * us times and divide signs - and also (according to the
-     * Language Reference Manual) a bonus in that the ASCII '-' code
-     * point now points to a minus sign instead of a hyphen.
-     */
-    fputs("/Helvetica findfont " /* get the font dictionary */
-          "dup maxlength dict dup begin " /* create and open a new dict */
-          "exch " /* move the original font to top of stack */
-          "{1 index /FID ne {def} {pop pop} ifelse} forall "
-                                       /* copy everything except FID */
-          "/Encoding ISOLatin1Encoding def "
-                              /* set the thing we actually wanted to change */
-          "/FontName /Helvetica-L1 def " /* set a new font name */
-          "FontName end exch definefont" /* and define the font */
-          "\n", ps->fp);
-    fputs("/Courier findfont " /* get the font dictionary */
-          "dup maxlength dict dup begin " /* create and open a new dict */
-          "exch " /* move the original font to top of stack */
-          "{1 index /FID ne {def} {pop pop} ifelse} forall "
-                                       /* copy everything except FID */
-          "/Encoding ISOLatin1Encoding def "
-                              /* set the thing we actually wanted to change */
-          "/FontName /Courier-L1 def " /* set a new font name */
-          "FontName end exch definefont" /* and define the font */
-          "\n", ps->fp);
-    fputs("%%EndProlog\n", ps->fp);
-}
-
-static void ps_begin_page(void *handle, int number)
-{
-    psdata *ps = (psdata *)handle;
-
-    fprintf(ps->fp, "%%%%Page: %d %d\ngsave save\n%g dup scale\n",
-            number, number, 72.0 / 25.4);
-}
-
-static void ps_begin_puzzle(void *handle, float xm, float xc,
-                            float ym, float yc, int pw, int ph, float wmm)
-{
-    psdata *ps = (psdata *)handle;
-
-    fprintf(ps->fp, "gsave\n"
-            "clippath flattenpath pathbbox pop pop translate\n"
-            "clippath flattenpath pathbbox 4 2 roll pop pop\n"
-            "exch %g mul %g add exch dup %g mul %g add sub translate\n"
-            "%g dup scale\n"
-            "0 -%d translate\n", xm, xc, ym, yc, wmm/pw, ph);
-    ps->ytop = ph;
-    ps->clipped = false;
-    ps->gamewidth = pw;
-    ps->gameheight = ph;
-    ps->hatchthick = 0.2 * pw / wmm;
-    ps->hatchspace = 1.0 * pw / wmm;
-}
-
-static void ps_end_puzzle(void *handle)
-{
-    psdata *ps = (psdata *)handle;
-
-    fputs("grestore\n", ps->fp);
-}
-
-static void ps_end_page(void *handle, int number)
-{
-    psdata *ps = (psdata *)handle;
-
-    fputs("restore grestore showpage\n", ps->fp);
-}
-
-static void ps_end_doc(void *handle)
-{
-    psdata *ps = (psdata *)handle;
-
-    fputs("%%EOF\n", ps->fp);
-}
-
-static const struct drawing_api ps_drawing = {
-    ps_draw_text,
-    ps_draw_rect,
-    ps_draw_line,
-    ps_draw_polygon,
-    ps_draw_circle,
-    NULL /* draw_update */,
-    ps_clip,
-    ps_unclip,
-    NULL /* start_draw */,
-    NULL /* end_draw */,
-    NULL /* status_bar */,
-    NULL /* blitter_new */,
-    NULL /* blitter_free */,
-    NULL /* blitter_save */,
-    NULL /* blitter_load */,
-    ps_begin_doc,
-    ps_begin_page,
-    ps_begin_puzzle,
-    ps_end_puzzle,
-    ps_end_page,
-    ps_end_doc,
-    ps_line_width,
-    ps_line_dotted,
-    ps_text_fallback,
-};
-
-psdata *ps_init(FILE *outfile, bool colour)
-{
-    psdata *ps = snew(psdata);
-
-    ps->fp = outfile;
-    ps->colour = colour;
-    ps->ytop = 0;
-    ps->clipped = false;
-    ps->hatchthick = ps->hatchspace = ps->gamewidth = ps->gameheight = 0;
-    ps->drawing = drawing_new(&ps_drawing, NULL, ps);
-
-    return ps;
-}
-
-void ps_free(psdata *ps)
-{
-    drawing_free(ps->drawing);
-    sfree(ps);
-}
-
-drawing *ps_drawing_api(psdata *ps)
-{
-    return ps->drawing;
-}
diff --git a/apps/plugins/puzzles/src/windows.c b/apps/plugins/puzzles/src/windows.c
deleted file mode 100644
index 5273e17842..0000000000
--- a/apps/plugins/puzzles/src/windows.c
+++ /dev/null
@@ -1,3458 +0,0 @@
-/*
- * windows.c: Windows front end for my puzzle collection.
- */
-
-#include <windows.h>
-#include <commctrl.h>
-#ifndef NO_HTMLHELP
-#include <htmlhelp.h>
-#endif /* NO_HTMLHELP */
-#include <io.h>
-
-#include <stdio.h>
-#include <assert.h>
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <time.h>
-
-#include "puzzles.h"
-
-#define IDM_NEW       0x0010
-#define IDM_RESTART   0x0020
-#define IDM_UNDO      0x0030
-#define IDM_REDO      0x0040
-#define IDM_COPY      0x0050
-#define IDM_SOLVE     0x0060
-#define IDM_QUIT      0x0070
-#define IDM_CONFIG    0x0080
-#define IDM_DESC      0x0090
-#define IDM_SEED      0x00A0
-#define IDM_HELPC     0x00B0
-#define IDM_GAMEHELP  0x00C0
-#define IDM_ABOUT     0x00D0
-#define IDM_SAVE      0x00E0
-#define IDM_LOAD      0x00F0
-#define IDM_PRINT     0x0100
-#define IDM_PREFS     0x0110
-
-/* Menu items for preset game_params go up from IDM_PRESET_BASE in
- * steps of MENUITEM_STEP = 0x20. Menu items for selecting different
- * games (in -DCOMBINED mode) go up from IDM_GAME_BASE similarly. */
-#define IDM_PRESET_BASE   0x0120
-#define IDM_GAME_BASE     0x0130
-#define MENUITEM_STEP     0x0020
-
-#define HELP_FILE_NAME  "puzzles.hlp"
-#define HELP_CNT_NAME   "puzzles.cnt"
-#ifndef NO_HTMLHELP
-#define CHM_FILE_NAME   "puzzles.chm"
-#endif /* NO_HTMLHELP */
-
-#ifndef NO_HTMLHELP
-typedef HWND (CALLBACK *htmlhelp_t)(HWND, LPCSTR, UINT, DWORD);
-static htmlhelp_t htmlhelp;
-static HINSTANCE hh_dll;
-#endif /* NO_HTMLHELP */
-enum { NONE, HLP, CHM } help_type;
-char *help_path;
-bool help_has_contents;
-
-#ifndef FILENAME_MAX
-#define FILENAME_MAX    (260)
-#endif
-
-#ifndef HGDI_ERROR
-#define HGDI_ERROR ((HANDLE)GDI_ERROR)
-#endif
-
-#ifdef COMBINED
-#define CLASSNAME "Puzzles"
-#else
-#define CLASSNAME thegame.name
-#endif
-
-#ifdef DEBUGGING
-static FILE *debug_fp = NULL;
-static HANDLE debug_hdl = INVALID_HANDLE_VALUE;
-static int debug_got_console = 0;
-
-static void dputs(char *buf)
-{
-    /*DWORD dw;
-
-    if (!debug_got_console) {
-        if (AllocConsole()) {
-            debug_got_console = 1;
-            debug_hdl = GetStdHandle(STD_OUTPUT_HANDLE);
-        }
-    }
-    if (!debug_fp) {
-        debug_fp = fopen("debug.log", "w");
-    }
-
-    if (debug_hdl != INVALID_HANDLE_VALUE) {
-        WriteFile(debug_hdl, buf, strlen(buf), &dw, NULL);
-    }
-    if (debug_fp) {
-        fputs(buf, debug_fp);
-        fflush(debug_fp);
-    }*/
-    OutputDebugString(buf);
-}
-
-void debug_printf(const char *fmt, ...)
-{
-    char buf[4096];
-    va_list ap;
-    static int debugging = -1;
-
-    if (debugging == -1)
-        debugging = getenv_bool("DEBUG_PUZZLES", false);
-
-    if (debugging) {
-        va_start(ap, fmt);
-        _vsnprintf(buf, 4095, fmt, ap);
-        dputs(buf);
-        va_end(ap);
-    }
-}
-#endif
-
-#define WINFLAGS (WS_OVERLAPPEDWINDOW &~ \
-                      (WS_MAXIMIZEBOX | WS_OVERLAPPED))
-
-static void new_game_size(frontend *fe, float scale);
-static void load_prefs(midend *me);
-static char *save_prefs(midend *me);
-
-struct font {
-    HFONT font;
-    int type;
-    int size;
-};
-
-struct cfg_aux {
-    int ctlid;
-};
-
-struct blitter {
-    HBITMAP bitmap;
-    frontend *fe;
-    int x, y, w, h;
-};
-
-enum { CFG_PRINT = CFG_FRONTEND_SPECIFIC };
-
-struct preset_menuitemref {
-    HMENU which_menu;
-    int item_index;
-};
-
-struct frontend {
-    const game *game;
-    midend *me;
-    HWND hwnd, statusbar, cfgbox;
-    HINSTANCE inst;
-    HBITMAP bitmap, prevbm;
-    RECT bitmapPosition;  /* game bitmap position within game window */
-    HDC hdc;
-    COLORREF *colours;
-    HBRUSH *brushes;
-    HPEN *pens;
-    HRGN clip;
-    HMENU gamemenu, typemenu;
-    UINT timer;
-    DWORD timer_last_tickcount;
-    struct preset_menu *preset_menu;
-    struct preset_menuitemref *preset_menuitems;
-    int n_preset_menuitems;
-    struct font *fonts;
-    int nfonts, fontsize;
-    config_item *cfg;
-    struct cfg_aux *cfgaux;
-    int cfg_which, dlg_done;
-    HFONT cfgfont;
-    HBRUSH oldbr;
-    HPEN oldpen;
-    bool help_running;
-    enum { DRAWING, PRINTING, NOTHING } drawstatus;
-    DOCINFO di;
-    int printcount, printw, printh;
-    bool printsolns, printcurr, printcolour;
-    float printscale;
-    int printoffsetx, printoffsety;
-    float printpixelscale;
-    int fontstart;
-    int linewidth;
-    bool linedotted;
-    drawing *dr;
-    int xmin, ymin;
-    float puzz_scale;
-};
-
-void frontend_free(frontend *fe)
-{
-    midend_free(fe->me);
-
-    sfree(fe->colours);
-    sfree(fe->brushes);
-    sfree(fe->pens);
-    sfree(fe->fonts);
-
-    sfree(fe);
-}
-
-static void update_type_menu_tick(frontend *fe);
-static void update_copy_menu_greying(frontend *fe);
-
-void fatal(const char *fmt, ...)
-{
-    char buf[2048];
-    va_list ap;
-
-    va_start(ap, fmt);
-    vsprintf(buf, fmt, ap);
-    va_end(ap);
-
-    MessageBox(NULL, buf, "Fatal error", MB_ICONEXCLAMATION | MB_OK);
-
-    exit(1);
-}
-
-char *geterrstr(void)
-{
-    LPVOID lpMsgBuf;
-    DWORD dw = GetLastError();
-    char *ret;
-
-    FormatMessage(
-        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
-        FORMAT_MESSAGE_FROM_SYSTEM,
-        NULL,
-        dw,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-        (LPTSTR) &lpMsgBuf,
-        0, NULL );
-
-    ret = dupstr(lpMsgBuf);
-
-    LocalFree(lpMsgBuf);
-
-    return ret;
-}
-
-void get_random_seed(void **randseed, int *randseedsize)
-{
-    SYSTEMTIME *st = snew(SYSTEMTIME);
-
-    GetLocalTime(st);
-
-    *randseed = (void *)st;
-    *randseedsize = sizeof(SYSTEMTIME);
-}
-
-static void win_status_bar(void *handle, const char *text)
-{
-    frontend *fe = (frontend *)handle;
-
-    SetWindowText(fe->statusbar, text);
-}
-
-static blitter *win_blitter_new(void *handle, int w, int h)
-{
-    blitter *bl = snew(blitter);
-
-    memset(bl, 0, sizeof(blitter));
-    bl->w = w;
-    bl->h = h;
-    bl->bitmap = 0;
-
-    return bl;
-}
-
-static void win_blitter_free(void *handle, blitter *bl)
-{
-    if (bl->bitmap) DeleteObject(bl->bitmap);
-    sfree(bl);
-}
-
-static void blitter_mkbitmap(frontend *fe, blitter *bl)
-{
-    HDC hdc = GetDC(fe->hwnd);
-    bl->bitmap = CreateCompatibleBitmap(hdc, bl->w, bl->h);
-    ReleaseDC(fe->hwnd, hdc);
-}
-
-/* BitBlt(dstDC, dstX, dstY, dstW, dstH, srcDC, srcX, srcY, dType) */
-
-static void win_blitter_save(void *handle, blitter *bl, int x, int y)
-{
-    frontend *fe = (frontend *)handle;
-    HDC hdc_win, hdc_blit;
-    HBITMAP prev_blit;
-
-    assert(fe->drawstatus == DRAWING);
-
-    if (!bl->bitmap) blitter_mkbitmap(fe, bl);
-
-    bl->x = x; bl->y = y;
-
-    hdc_win = GetDC(fe->hwnd);
-    hdc_blit = CreateCompatibleDC(hdc_win);
-    if (!hdc_blit) fatal("hdc_blit failed: 0x%x", GetLastError());
-
-    prev_blit = SelectObject(hdc_blit, bl->bitmap);
-    if (prev_blit == NULL || prev_blit == HGDI_ERROR)
-        fatal("SelectObject for hdc_main failed: 0x%x", GetLastError());
-
-    if (!BitBlt(hdc_blit, 0, 0, bl->w, bl->h,
-                fe->hdc, x, y, SRCCOPY))
-        fatal("BitBlt failed: 0x%x", GetLastError());
-
-    SelectObject(hdc_blit, prev_blit);
-    DeleteDC(hdc_blit);
-    ReleaseDC(fe->hwnd, hdc_win);
-}
-
-static void win_blitter_load(void *handle, blitter *bl, int x, int y)
-{
-    frontend *fe = (frontend *)handle;
-    HDC hdc_win, hdc_blit;
-    HBITMAP prev_blit;
-
-    assert(fe->drawstatus == DRAWING);
-
-    assert(bl->bitmap); /* we should always have saved before loading */
-
-    if (x == BLITTER_FROMSAVED) x = bl->x;
-    if (y == BLITTER_FROMSAVED) y = bl->y;
-
-    hdc_win = GetDC(fe->hwnd);
-    hdc_blit = CreateCompatibleDC(hdc_win);
-
-    prev_blit = SelectObject(hdc_blit, bl->bitmap);
-
-    BitBlt(fe->hdc, x, y, bl->w, bl->h,
-           hdc_blit, 0, 0, SRCCOPY);
-
-    SelectObject(hdc_blit, prev_blit);
-    DeleteDC(hdc_blit);
-    ReleaseDC(fe->hwnd, hdc_win);
-}
-
-void frontend_default_colour(frontend *fe, float *output)
-{
-    DWORD c = GetSysColor(COLOR_MENU); /* ick */
-
-    output[0] = (float)(GetRValue(c) / 255.0);
-    output[1] = (float)(GetGValue(c) / 255.0);
-    output[2] = (float)(GetBValue(c) / 255.0);
-}
-
-static POINT win_transform_point(frontend *fe, int x, int y)
-{
-    POINT ret;
-
-    assert(fe->drawstatus != NOTHING);
-
-    if (fe->drawstatus == PRINTING) {
-        ret.x = (int)(fe->printoffsetx + fe->printpixelscale * x);
-        ret.y = (int)(fe->printoffsety + fe->printpixelscale * y);
-    } else {
-        ret.x = x;
-        ret.y = y;
-    }
-
-    return ret;
-}
-
-static void win_text_colour(frontend *fe, int colour)
-{
-    assert(fe->drawstatus != NOTHING);
-
-    if (fe->drawstatus == PRINTING) {
-        int hatch;
-        float r, g, b;
-        print_get_colour(fe->dr, colour, fe->printcolour, &hatch, &r, &g, &b);
-
-        /*
-         * Displaying text in hatched colours is not permitted.
-         */
-        assert(hatch < 0);
-
-        SetTextColor(fe->hdc, RGB(r * 255, g * 255, b * 255));
-    } else {
-        SetTextColor(fe->hdc, fe->colours[colour]);
-    }
-}
-
-static void win_set_brush(frontend *fe, int colour)
-{
-    HBRUSH br;
-    assert(fe->drawstatus != NOTHING);
-
-    if (fe->drawstatus == PRINTING) {
-        int hatch;
-        float r, g, b;
-        print_get_colour(fe->dr, colour, fe->printcolour, &hatch, &r, &g, &b);
-
-        if (hatch < 0) {
-            br = CreateSolidBrush(RGB(r * 255, g * 255, b * 255));
-        } else {
-            br = CreateHatchBrush(hatch == HATCH_BACKSLASH ? HS_FDIAGONAL :
-                                  hatch == HATCH_SLASH ? HS_BDIAGONAL :
-                                  hatch == HATCH_HORIZ ? HS_HORIZONTAL :
-                                  hatch == HATCH_VERT ? HS_VERTICAL :
-                                  hatch == HATCH_PLUS ? HS_CROSS :
-                                  /* hatch == HATCH_X ? */ HS_DIAGCROSS,
-                                  RGB(0,0,0));
-        }
-    } else {
-        br = fe->brushes[colour];
-    }
-    fe->oldbr = SelectObject(fe->hdc, br);
-}
-
-static void win_reset_brush(frontend *fe)
-{
-    HBRUSH br;
-
-    assert(fe->drawstatus != NOTHING);
-
-    br = SelectObject(fe->hdc, fe->oldbr);
-    if (fe->drawstatus == PRINTING)
-        DeleteObject(br);
-}
-
-static void win_set_pen(frontend *fe, int colour, bool thin)
-{
-    HPEN pen;
-    assert(fe->drawstatus != NOTHING);
-
-    if (fe->drawstatus == PRINTING) {
-        int hatch;
-        float r, g, b;
-        int width = thin ? 0 : fe->linewidth;
-
-        if (fe->linedotted)
-            width = 0;
-
-        print_get_colour(fe->dr, colour, fe->printcolour, &hatch, &r, &g, &b);
-        /*
-         * Stroking in hatched colours is not permitted.
-         */
-        assert(hatch < 0);
-        pen = CreatePen(fe->linedotted ? PS_DOT : PS_SOLID,
-                        width, RGB(r * 255, g * 255, b * 255));
-    } else {
-        pen = fe->pens[colour];
-    }
-    fe->oldpen = SelectObject(fe->hdc, pen);
-}
-
-static void win_reset_pen(frontend *fe)
-{
-    HPEN pen;
-
-    assert(fe->drawstatus != NOTHING);
-
-    pen = SelectObject(fe->hdc, fe->oldpen);
-    if (fe->drawstatus == PRINTING)
-        DeleteObject(pen);
-}
-
-static void win_clip(void *handle, int x, int y, int w, int h)
-{
-    frontend *fe = (frontend *)handle;
-    POINT p, q;
-
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    p = win_transform_point(fe, x, y);
-    q = win_transform_point(fe, x+w, y+h);
-    IntersectClipRect(fe->hdc, p.x, p.y, q.x, q.y);
-}
-
-static void win_unclip(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    SelectClipRgn(fe->hdc, NULL);
-}
-
-static void win_draw_text(void *handle, int x, int y, int fonttype,
-                          int fontsize, int align, int colour,
-                          const char *text)
-{
-    frontend *fe = (frontend *)handle;
-    POINT xy;
-    int i;
-    LOGFONT lf;
-
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    if (fe->drawstatus == PRINTING)
-        fontsize = (int)(fontsize * fe->printpixelscale);
-
-    xy = win_transform_point(fe, x, y);
-
-    /*
-     * Find or create the font.
-     */
-    for (i = fe->fontstart; 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;
-
-        memset (&lf, 0, sizeof(LOGFONT));
-        lf.lfHeight = -fontsize;
-        lf.lfWeight = (fe->drawstatus == PRINTING ? 0 : FW_BOLD);
-        lf.lfCharSet = DEFAULT_CHARSET;
-        lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
-        lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
-        lf.lfQuality = DEFAULT_QUALITY;
-        lf.lfPitchAndFamily = (fonttype == FONT_FIXED ?
-                               FIXED_PITCH | FF_DONTCARE :
-                               VARIABLE_PITCH | FF_SWISS);
-
-        fe->fonts[i].font = CreateFontIndirect(&lf);
-    }
-
-    /*
-     * Position and draw the text.
-     */
-    {
-        HFONT oldfont;
-        TEXTMETRIC tm;
-        SIZE size;
-        WCHAR wText[256];
-        MultiByteToWideChar (CP_UTF8, 0, text, -1, wText, 256);
-
-        oldfont = SelectObject(fe->hdc, fe->fonts[i].font);
-        if (GetTextMetrics(fe->hdc, &tm)) {
-            if (align & ALIGN_VCENTRE)
-                xy.y -= (tm.tmAscent+tm.tmDescent)/2;
-            else
-                xy.y -= tm.tmAscent;
-        }
-        if (GetTextExtentPoint32W(fe->hdc, wText, wcslen(wText), &size))
-        {
-            if (align & ALIGN_HCENTRE)
-                xy.x -= size.cx / 2;
-            else if (align & ALIGN_HRIGHT)
-                xy.x -= size.cx;
-        }
-        SetBkMode(fe->hdc, TRANSPARENT);
-        win_text_colour(fe, colour);
-        ExtTextOutW(fe->hdc, xy.x, xy.y, 0, NULL, wText, wcslen(wText), NULL);
-        SelectObject(fe->hdc, oldfont);
-    }
-}
-
-static void win_draw_rect(void *handle, int x, int y, int w, int h, int colour)
-{
-    frontend *fe = (frontend *)handle;
-    POINT p, q;
-
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    if (fe->drawstatus == DRAWING && w == 1 && h == 1) {
-        /*
-         * Rectangle() appears to get uppity if asked to draw a 1x1
-         * rectangle, presumably on the grounds that that's beneath
-         * its dignity and you ought to be using SetPixel instead.
-         * So I will.
-         */
-        SetPixel(fe->hdc, x, y, fe->colours[colour]);
-    } else {
-        win_set_brush(fe, colour);
-        win_set_pen(fe, colour, true);
-        p = win_transform_point(fe, x, y);
-        q = win_transform_point(fe, x+w, y+h);
-        Rectangle(fe->hdc, p.x, p.y, q.x, q.y);
-        win_reset_brush(fe);
-        win_reset_pen(fe);
-    }
-}
-
-static void win_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour)
-{
-    frontend *fe = (frontend *)handle;
-    POINT pp[2];
-
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    win_set_pen(fe, colour, false);
-    pp[0] = win_transform_point(fe, x1, y1);
-    pp[1] = win_transform_point(fe, x2, y2);
-    Polyline(fe->hdc, pp, 2);
-    if (fe->drawstatus == DRAWING)
-        SetPixel(fe->hdc, pp[1].x, pp[1].y, fe->colours[colour]);
-    win_reset_pen(fe);
-}
-
-static void win_draw_circle(void *handle, int cx, int cy, int radius,
-                            int fillcolour, int outlinecolour)
-{
-    frontend *fe = (frontend *)handle;
-    POINT p, q;
-
-    assert(outlinecolour >= 0);
-
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    if (fillcolour >= 0)
-        win_set_brush(fe, fillcolour);
-    else
-        fe->oldbr = SelectObject(fe->hdc, GetStockObject(NULL_BRUSH));
-
-    win_set_pen(fe, outlinecolour, false);
-    p = win_transform_point(fe, cx - radius, cy - radius);
-    q = win_transform_point(fe, cx + radius, cy + radius);
-    Ellipse(fe->hdc, p.x, p.y, q.x+1, q.y+1);
-    win_reset_brush(fe);
-    win_reset_pen(fe);
-}
-
-static void win_draw_polygon(void *handle, const int *coords, int npoints,
-                             int fillcolour, int outlinecolour)
-{
-    frontend *fe = (frontend *)handle;
-    POINT *pts;
-    int i;
-
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    pts = snewn(npoints+1, POINT);
-
-    for (i = 0; i <= npoints; i++) {
-        int j = (i < npoints ? i : 0);
-        pts[i] = win_transform_point(fe, coords[j*2], coords[j*2+1]);
-    }
-
-    assert(outlinecolour >= 0);
-
-    if (fillcolour >= 0) {
-        win_set_brush(fe, fillcolour);
-        win_set_pen(fe, outlinecolour, false);
-        Polygon(fe->hdc, pts, npoints);
-        win_reset_brush(fe);
-        win_reset_pen(fe);
-    } else {
-        win_set_pen(fe, outlinecolour, false);
-        Polyline(fe->hdc, pts, npoints+1);
-        win_reset_pen(fe);
-    }
-
-    sfree(pts);
-}
-
-static void win_start_draw(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-    HDC hdc_win;
-
-    assert(fe->drawstatus == NOTHING);
-
-    hdc_win = GetDC(fe->hwnd);
-    fe->hdc = CreateCompatibleDC(hdc_win);
-    fe->prevbm = SelectObject(fe->hdc, fe->bitmap);
-    ReleaseDC(fe->hwnd, hdc_win);
-    fe->clip = NULL;
-    SetMapMode(fe->hdc, MM_TEXT);
-    fe->drawstatus = DRAWING;
-}
-
-static void win_draw_update(void *handle, int x, int y, int w, int h)
-{
-    frontend *fe = (frontend *)handle;
-    RECT r;
-
-    if (fe->drawstatus != DRAWING)
-        return;
-
-    r.left = x;
-    r.top = y;
-    r.right = x + w;
-    r.bottom = y + h;
-
-    OffsetRect(&r, fe->bitmapPosition.left, fe->bitmapPosition.top);
-    InvalidateRect(fe->hwnd, &r, false);
-}
-
-static void win_end_draw(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-    assert(fe->drawstatus == DRAWING);
-    SelectObject(fe->hdc, fe->prevbm);
-    DeleteDC(fe->hdc);
-    if (fe->clip) {
-        DeleteObject(fe->clip);
-        fe->clip = NULL;
-    }
-    fe->drawstatus = NOTHING;
-}
-
-static void win_line_width(void *handle, float width)
-{
-    frontend *fe = (frontend *)handle;
-
-    assert(fe->drawstatus != DRAWING);
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    fe->linewidth = (int)(width * fe->printpixelscale);
-}
-
-static void win_line_dotted(void *handle, bool dotted)
-{
-    frontend *fe = (frontend *)handle;
-
-    assert(fe->drawstatus != DRAWING);
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    fe->linedotted = dotted;
-}
-
-static void win_begin_doc(void *handle, int pages)
-{
-    frontend *fe = (frontend *)handle;
-
-    assert(fe->drawstatus != DRAWING);
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    if (StartDoc(fe->hdc, &fe->di) <= 0) {
-        char *e = geterrstr();
-        MessageBox(fe->hwnd, e, "Error starting to print",
-                   MB_ICONERROR | MB_OK);
-        sfree(e);
-        fe->drawstatus = NOTHING;
-    }
-
-    /*
-     * Push a marker on the font stack so that we won't use the
-     * same fonts for printing and drawing. (This is because
-     * drawing seems to look generally better in bold, but printing
-     * is better not in bold.)
-     */
-    fe->fontstart = fe->nfonts;
-}
-
-static void win_begin_page(void *handle, int number)
-{
-    frontend *fe = (frontend *)handle;
-
-    assert(fe->drawstatus != DRAWING);
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    if (StartPage(fe->hdc) <= 0) {
-        char *e = geterrstr();
-        MessageBox(fe->hwnd, e, "Error starting a page",
-                   MB_ICONERROR | MB_OK);
-        sfree(e);
-        fe->drawstatus = NOTHING;
-    }
-}
-
-static void win_begin_puzzle(void *handle, float xm, float xc,
-                             float ym, float yc, int pw, int ph, float wmm)
-{
-    frontend *fe = (frontend *)handle;
-    int ppw, pph, pox, poy;
-    float mmpw, mmph, mmox, mmoy;
-    float scale;
-
-    assert(fe->drawstatus != DRAWING);
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    ppw = GetDeviceCaps(fe->hdc, HORZRES);
-    pph = GetDeviceCaps(fe->hdc, VERTRES);
-    mmpw = (float)GetDeviceCaps(fe->hdc, HORZSIZE);
-    mmph = (float)GetDeviceCaps(fe->hdc, VERTSIZE);
-
-    /*
-     * Compute the puzzle's position on the logical page.
-     */
-    mmox = xm * mmpw + xc;
-    mmoy = ym * mmph + yc;
-
-    /*
-     * Work out what that comes to in pixels.
-     */
-    pox = (int)(mmox * (float)ppw / mmpw);
-    poy = (int)(mmoy * (float)pph / mmph);
-
-    /*
-     * And determine the scale.
-     * 
-     * I need a scale such that the maximum puzzle-coordinate
-     * extent of the rectangle (pw * scale) is equal to the pixel
-     * equivalent of the puzzle's millimetre width (wmm * ppw /
-     * mmpw).
-     */
-    scale = (wmm * ppw) / (mmpw * pw);
-
-    /*
-     * Now store pox, poy and scale for use in the main drawing
-     * functions.
-     */
-    fe->printoffsetx = pox;
-    fe->printoffsety = poy;
-    fe->printpixelscale = scale;
-
-    fe->linewidth = 1;
-    fe->linedotted = false;
-}
-
-static void win_end_puzzle(void *handle)
-{
-    /* Nothing needs to be done here. */
-}
-
-static void win_end_page(void *handle, int number)
-{
-    frontend *fe = (frontend *)handle;
-
-    assert(fe->drawstatus != DRAWING);
-
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    if (EndPage(fe->hdc) <= 0) {
-        char *e = geterrstr();
-        MessageBox(fe->hwnd, e, "Error finishing a page",
-                   MB_ICONERROR | MB_OK);
-        sfree(e);
-        fe->drawstatus = NOTHING;
-    }
-}
-
-static void win_end_doc(void *handle)
-{
-    frontend *fe = (frontend *)handle;
-
-    assert(fe->drawstatus != DRAWING);
-
-    /*
-     * Free all the fonts created since we began printing.
-     */
-    while (fe->nfonts > fe->fontstart) {
-        fe->nfonts--;
-        DeleteObject(fe->fonts[fe->nfonts].font);
-    }
-    fe->fontstart = 0;
-
-    /*
-     * The MSDN web site sample code doesn't bother to call EndDoc
-     * if an error occurs half way through printing. I expect doing
-     * so would cause the erroneous document to actually be
-     * printed, or something equally undesirable.
-     */
-    if (fe->drawstatus == NOTHING)
-        return;
-
-    if (EndDoc(fe->hdc) <= 0) {
-        char *e = geterrstr();
-        MessageBox(fe->hwnd, e, "Error finishing printing",
-                   MB_ICONERROR | MB_OK);
-        sfree(e);
-        fe->drawstatus = NOTHING;
-    }
-}
-
-char *win_text_fallback(void *handle, const char *const *strings, int nstrings)
-{
-    /*
-     * We assume Windows can cope with any UTF-8 likely to be
-     * emitted by a puzzle.
-     */
-    return dupstr(strings[0]);
-}
-
-const struct drawing_api win_drawing = {
-    win_draw_text,
-    win_draw_rect,
-    win_draw_line,
-    win_draw_polygon,
-    win_draw_circle,
-    win_draw_update,
-    win_clip,
-    win_unclip,
-    win_start_draw,
-    win_end_draw,
-    win_status_bar,
-    win_blitter_new,
-    win_blitter_free,
-    win_blitter_save,
-    win_blitter_load,
-    win_begin_doc,
-    win_begin_page,
-    win_begin_puzzle,
-    win_end_puzzle,
-    win_end_page,
-    win_end_doc,
-    win_line_width,
-    win_line_dotted,
-    win_text_fallback,
-};
-
-void print(frontend *fe)
-{
-    PRINTDLG pd;
-    char doctitle[256];
-    document *doc;
-    midend *nme = NULL;  /* non-interactive midend for bulk puzzle generation */
-    int i;
-    const char *err = NULL;
-
-    /*
-     * Create our document structure and fill it up with puzzles.
-     */
-    doc = document_new(fe->printw, fe->printh, fe->printscale / 100.0F);
-    for (i = 0; i < fe->printcount; i++) {
-        if (i == 0 && fe->printcurr) {
-            err = midend_print_puzzle(fe->me, doc, fe->printsolns);
-        } else {
-            if (!nme) {
-                game_params *params;
-
-                nme = midend_new(NULL, fe->game, NULL, NULL);
-                load_prefs(nme);
-
-                /*
-                 * Set the non-interactive mid-end to have the same
-                 * parameters as the standard one.
-                 */
-                params = midend_get_params(fe->me);
-                midend_set_params(nme, params);
-                fe->game->free_params(params);
-            }
-
-            midend_new_game(nme);
-            err = midend_print_puzzle(nme, doc, fe->printsolns);
-        }
-        if (err)
-            break;
-    }
-    if (nme)
-        midend_free(nme);
-
-    if (err) {
-        MessageBox(fe->hwnd, err, "Error preparing puzzles for printing",
-                   MB_ICONERROR | MB_OK);
-        document_free(doc);
-        return;
-    }
-
-    memset(&pd, 0, sizeof(pd));
-    pd.lStructSize = sizeof(pd);
-    pd.hwndOwner = fe->hwnd;
-    pd.hDevMode = NULL;
-    pd.hDevNames = NULL;
-    pd.Flags = PD_USEDEVMODECOPIESANDCOLLATE | PD_RETURNDC |
-        PD_NOPAGENUMS | PD_NOSELECTION;
-    pd.nCopies = 1;
-    pd.nFromPage = pd.nToPage = 0xFFFF;
-    pd.nMinPage = pd.nMaxPage = 1;
-
-    if (!PrintDlg(&pd)) {
-        document_free(doc);
-        return;
-    }
-
-    /*
-     * Now pd.hDC is a device context for the printer.
-     */
-
-    /*
-     * FIXME: IWBNI we put up an Abort box here.
-     */
-
-    memset(&fe->di, 0, sizeof(fe->di));
-    fe->di.cbSize = sizeof(fe->di);
-    sprintf(doctitle, "Printed puzzles from %s (from Simon Tatham's"
-            " Portable Puzzle Collection)", fe->game->name);
-    fe->di.lpszDocName = doctitle;
-    fe->di.lpszOutput = NULL;
-    fe->di.lpszDatatype = NULL;
-    fe->di.fwType = 0;
-
-    fe->drawstatus = PRINTING;
-    fe->hdc = pd.hDC;
-
-    fe->dr = drawing_new(&win_drawing, NULL, fe);
-    document_print(doc, fe->dr);
-    drawing_free(fe->dr);
-    fe->dr = NULL;
-
-    fe->drawstatus = NOTHING;
-
-    DeleteDC(pd.hDC);
-    document_free(doc);
-}
-
-void deactivate_timer(frontend *fe)
-{
-    if (!fe)
-        return;                        /* for non-interactive midend */
-    if (fe->hwnd) KillTimer(fe->hwnd, fe->timer);
-    fe->timer = 0;
-}
-
-void activate_timer(frontend *fe)
-{
-    if (!fe)
-        return;                        /* for non-interactive midend */
-    if (!fe->timer) {
-        fe->timer = SetTimer(fe->hwnd, 1, 20, NULL);
-        fe->timer_last_tickcount = GetTickCount();
-    }
-}
-
-void write_clip(HWND hwnd, char *data)
-{
-    HGLOBAL clipdata;
-    int len, i, j;
-    char *data2;
-    void *lock;
-
-    /*
-     * Windows expects CRLF in the clipboard, so we must convert
-     * any \n that has come out of the puzzle backend.
-     */
-    len = 0;
-    for (i = 0; data[i]; i++) {
-        if (data[i] == '\n')
-            len++;
-        len++;
-    }
-    data2 = snewn(len+1, char);
-    j = 0;
-    for (i = 0; data[i]; i++) {
-        if (data[i] == '\n')
-            data2[j++] = '\r';
-        data2[j++] = data[i];
-    }
-    assert(j == len);
-    data2[j] = '\0';
-
-    clipdata = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
-    if (!clipdata) {
-        sfree(data2);
-        return;
-    }
-    lock = GlobalLock(clipdata);
-    if (!lock) {
-        GlobalFree(clipdata);
-        sfree(data2);
-        return;
-    }
-    memcpy(lock, data2, len);
-    ((unsigned char *) lock)[len] = 0;
-    GlobalUnlock(clipdata);
-
-    if (OpenClipboard(hwnd)) {
-        EmptyClipboard();
-        SetClipboardData(CF_TEXT, clipdata);
-        CloseClipboard();
-    } else
-        GlobalFree(clipdata);
-
-    sfree(data2);
-}
-
-/*
- * Set up Help and see if we can find a help file.
- */
-static void init_help(void)
-{
-    char b[2048], *p, *q, *r;
-    FILE *fp;
-
-    /*
-     * Find the executable file path, so we can look alongside
-     * it for help files. Trim the filename off the end.
-     */
-    GetModuleFileName(NULL, b, sizeof(b) - 1);
-    r = b;
-    p = strrchr(b, '\\');
-    if (p && p >= r) r = p+1;
-    q = strrchr(b, ':');
-    if (q && q >= r) r = q+1;
-
-#ifndef NO_HTMLHELP
-    /*
-     * Try HTML Help first.
-     */
-    strcpy(r, CHM_FILE_NAME);
-    if ( (fp = fopen(b, "r")) != NULL) {
-        fclose(fp);
-
-        /*
-         * We have a .CHM. See if we can use it.
-         */
-        hh_dll = LoadLibrary("hhctrl.ocx");
-        if (hh_dll) {
-            htmlhelp = (htmlhelp_t)GetProcAddress(hh_dll, "HtmlHelpA");
-            if (!htmlhelp)
-                FreeLibrary(hh_dll);
-        }
-        if (htmlhelp) {
-            help_path = dupstr(b);
-            help_type = CHM;
-            return;
-        }
-    }
-#endif /* NO_HTMLHELP */
-
-    /*
-     * Now try old-style .HLP.
-     */
-    strcpy(r, HELP_FILE_NAME);
-    if ( (fp = fopen(b, "r")) != NULL) {
-        fclose(fp);
-
-        help_path = dupstr(b);
-        help_type = HLP;
-
-        /*
-         * See if there's a .CNT file alongside it.
-         */
-        strcpy(r, HELP_CNT_NAME);
-        if ( (fp = fopen(b, "r")) != NULL) {
-            fclose(fp);
-            help_has_contents = true;
-        } else
-            help_has_contents = false;
-
-        return;
-    }
-
-    help_type = NONE;          /* didn't find any */
-}
-
-/*
- * Start Help.
- */
-static void start_help(frontend *fe, const char *topic)
-{
-    char *str = NULL;
-    int cmd;
-
-    switch (help_type) {
-      case HLP:
-        assert(help_path);
-        if (topic) {
-            str = snewn(10+strlen(topic), char);
-            sprintf(str, "JI(`',`%s')", topic);
-            cmd = HELP_COMMAND;
-        } else if (help_has_contents) {
-            cmd = HELP_FINDER;
-        } else {
-            cmd = HELP_CONTENTS;
-        }
-        WinHelp(fe->hwnd, help_path, cmd, (ULONG_PTR)str);
-        fe->help_running = true;
-        break;
-      case CHM:
-#ifndef NO_HTMLHELP
-        assert(help_path);
-        assert(htmlhelp);
-        if (topic) {
-            str = snewn(20 + strlen(topic) + strlen(help_path), char);
-            sprintf(str, "%s::/%s.html>main", help_path, topic);
-        } else {
-            str = dupstr(help_path);
-        }
-        htmlhelp(fe->hwnd, str, HH_DISPLAY_TOPIC, 0);
-        fe->help_running = true;
-        break;
-#endif /* NO_HTMLHELP */
-      case NONE:
-        assert(!"This shouldn't happen");
-        break;
-    }
-
-    sfree(str);
-}
-
-/*
- * Stop Help on window cleanup.
- */
-static void stop_help(frontend *fe)
-{
-    if (fe->help_running) {
-        switch (help_type) {
-          case HLP:
-            WinHelp(fe->hwnd, help_path, HELP_QUIT, 0);
-            break;
-          case CHM:
-#ifndef NO_HTMLHELP
-            assert(htmlhelp);
-            htmlhelp(NULL, NULL, HH_CLOSE_ALL, 0);
-            break;
-#endif /* NO_HTMLHELP */
-          case NONE:
-            assert(!"This shouldn't happen");
-            break;
-        }
-        fe->help_running = false;
-    }
-}
-
-/*
- * Terminate Help on process exit.
- */
-static void cleanup_help(void)
-{
-    /* Nothing to do currently.
-     * (If we were running HTML Help single-threaded, this is where we'd
-     * call HH_UNINITIALIZE.) */
-}
-
-static int get_statusbar_height(frontend *fe)
-{
-    int sy;
-    if (fe->statusbar) {
-        RECT sr;
-        GetWindowRect(fe->statusbar, &sr);
-        sy = sr.bottom - sr.top;
-    } else {
-        sy = 0;
-    }
-    return sy;
-}
-
-static void adjust_statusbar(frontend *fe, RECT *r)
-{
-    int sy;
-
-    if (!fe->statusbar) return;
-
-    sy = get_statusbar_height(fe);
-    SetWindowPos(fe->statusbar, NULL, 0, r->bottom-r->top-sy, r->right-r->left,
-                 sy, SWP_NOZORDER);
-}
-
-static void get_menu_size(HWND wh, RECT *r)
-{
-    HMENU bar = GetMenu(wh);
-    RECT rect;
-    int i;
-
-    SetRect(r, 0, 0, 0, 0);
-    for (i = 0; i < GetMenuItemCount(bar); i++) {
-        GetMenuItemRect(wh, bar, i, &rect);
-        UnionRect(r, r, &rect);
-    }
-}
-
-/*
- * Given a proposed new puzzle size (cx,cy), work out the actual
- * puzzle size that would be (px,py) and the window size including
- * furniture (wx,wy).
- */
-
-static bool check_window_resize(frontend *fe, int cx, int cy,
-                                int *px, int *py, int *wx, int *wy)
-{
-    RECT r;
-    int x, y, sy = get_statusbar_height(fe);
-    bool changed = false;
-
-    /* disallow making window thinner than menu bar */
-    x = max(cx, fe->xmin);
-    y = max(cy - sy, fe->ymin);
-
-    /*
-     * See if we actually got the window size we wanted, and adjust
-     * the puzzle size if not.
-     */
-    midend_size(fe->me, &x, &y, true, 1.0);
-    if (x != cx || y != cy) {
-        /*
-         * Resize the window, now we know what size we _really_
-         * want it to be.
-         */
-        r.left = r.top = 0;
-        r.right = x;
-        r.bottom = y + sy;
-        AdjustWindowRectEx(&r, WINFLAGS, true, 0);
-        *wx = r.right - r.left;
-        *wy = r.bottom - r.top;
-        changed = true;
-    }
-
-    *px = x;
-    *py = y;
-
-    fe->puzz_scale =
-      (float)midend_tilesize(fe->me) / (float)fe->game->preferred_tilesize;
-
-    return changed;
-}
-
-/*
- * Given the current window size, make sure it's sane for the
- * current puzzle and resize if necessary.
- */
-
-static void check_window_size(frontend *fe, int *px, int *py)
-{
-    RECT r;
-    int wx, wy, cx, cy;
-
-    GetClientRect(fe->hwnd, &r);
-    cx = r.right - r.left;
-    cy = r.bottom - r.top;
-
-    if (check_window_resize(fe, cx, cy, px, py, &wx, &wy))
-        SetWindowPos(fe->hwnd, NULL, 0, 0, wx, wy, SWP_NOMOVE | SWP_NOZORDER);
-
-    GetClientRect(fe->hwnd, &r);
-    adjust_statusbar(fe, &r);
-}
-
-static void get_max_puzzle_size(frontend *fe, int *x, int *y)
-{
-    RECT r, sr;
-
-    if (SystemParametersInfo(SPI_GETWORKAREA, 0, &sr, false)) {
-        *x = sr.right - sr.left;
-        *y = sr.bottom - sr.top;
-        r.left = 100;
-        r.right = 200;
-        r.top = 100;
-        r.bottom = 200;
-        AdjustWindowRectEx(&r, WINFLAGS, true, 0);
-        *x -= r.right - r.left - 100;
-        *y -= r.bottom - r.top - 100;
-    } else {
-        *x = *y = INT_MAX;
-    }
-
-    if (fe->statusbar != NULL) {
-        GetWindowRect(fe->statusbar, &sr);
-        *y -= sr.bottom - sr.top;
-    }
-}
-
-/*
- * Allocate a new frontend structure and create its main window.
- */
-static frontend *frontend_new(HINSTANCE inst)
-{
-    frontend *fe;
-    const char *nogame = "Puzzles (no game selected)";
-
-    fe = snew(frontend);
-
-    fe->inst = inst;
-
-    fe->game = NULL;
-    fe->me = NULL;
-
-    fe->timer = 0;
-    fe->hwnd = NULL;
-
-    fe->help_running = false;
-
-    fe->drawstatus = NOTHING;
-    fe->dr = NULL;
-    fe->fontstart = 0;
-
-    fe->fonts = NULL;
-    fe->nfonts = fe->fontsize = 0;
-
-    fe->colours = NULL;
-    fe->brushes = NULL;
-    fe->pens = NULL;
-
-    fe->puzz_scale = 1.0;
-
-    fe->hwnd = CreateWindowEx(0, CLASSNAME, nogame,
-                              WS_OVERLAPPEDWINDOW &~
-                              (WS_MAXIMIZEBOX),
-                              CW_USEDEFAULT, CW_USEDEFAULT,
-                              CW_USEDEFAULT, CW_USEDEFAULT,
-                              NULL, NULL, inst, NULL);
-    if (!fe->hwnd) {
-        DWORD lerr = GetLastError();
-        printf("no window: 0x%x\n", (unsigned)lerr);
-    }
-
-    fe->gamemenu = NULL;
-    fe->preset_menu = NULL;
-
-    fe->statusbar = NULL;
-    fe->bitmap = NULL;
-
-    SetWindowLongPtr(fe->hwnd, GWLP_USERDATA, (LONG_PTR)fe);
-
-    return fe;
-}
-
-static void savefile_write(void *wctx, const void *buf, int len)
-{
-    FILE *fp = (FILE *)wctx;
-    fwrite(buf, 1, len, fp);
-}
-
-static bool savefile_read(void *wctx, void *buf, int len)
-{
-    FILE *fp = (FILE *)wctx;
-    int ret;
-
-    ret = fread(buf, 1, len, fp);
-    return (ret == len);
-}
-
-/*
- * Create an appropriate midend structure to go in a puzzle window,
- * given a game type and/or a command-line argument.
- *
- * 'arg' can be either a game ID string (descriptive, random, or a
- * plain set of parameters) or the filename of a save file. The two
- * boolean flag arguments indicate which possibilities are
- * permissible.
- */
-static midend *midend_for_new_game(frontend *fe, const game *cgame,
-                                   char *arg, bool maybe_game_id,
-                                   bool maybe_save_file, char **error)
-{
-    midend *me = NULL;
-
-    if (!arg) {
-        if (me) midend_free(me);
-        me = midend_new(fe, cgame, &win_drawing, fe);
-        load_prefs(me);
-        midend_new_game(me);
-    } else {
-        FILE *fp;
-        const char *err_param, *err_load;
-
-        /*
-         * See if arg is a valid filename of a save game file.
-         */
-        err_load = NULL;
-        if (maybe_save_file && (fp = fopen(arg, "r")) != NULL) {
-            const game *loadgame;
-
-#ifdef COMBINED
-            /*
-             * Find out what kind of game is stored in the save
-             * file; if we're going to end up loading that, it
-             * will have to override our caller's judgment as to
-             * what game to initialise our midend with.
-             */
-            char *id_name;
-            err_load = identify_game(&id_name, savefile_read, fp);
-            if (!err_load) {
-                int i;
-                for (i = 0; i < gamecount; i++)
-                    if (!strcmp(id_name, gamelist[i]->name))
-                        break;
-                if (i == gamecount) {
-                    err_load = "Save file is for a game not supported by"
-                        " this program";
-                } else {
-                    loadgame = gamelist[i];
-                    rewind(fp); /* go back to the start for actual load */
-                }
-            }
-#else
-            loadgame = cgame;
-#endif
-            if (!err_load) {
-                if (me) midend_free(me);
-                me = midend_new(fe, loadgame, &win_drawing, fe);
-                load_prefs(me);
-                err_load = midend_deserialise(me, savefile_read, fp);
-            }
-        } else {
-            err_load = "Unable to open file";
-        }
-
-        if (maybe_game_id && (!maybe_save_file || err_load)) {
-            /*
-             * See if arg is a game description.
-             */
-            if (me) midend_free(me);
-            me = midend_new(fe, cgame, &win_drawing, fe);
-            load_prefs(me);
-            err_param = midend_game_id(me, arg);
-            if (!err_param) {
-                midend_new_game(me);
-            } else {
-                if (maybe_save_file) {
-                    *error = snewn(256 + strlen(arg) + strlen(err_param) +
-                                   strlen(err_load), char);
-                    sprintf(*error, "Supplied argument \"%s\" is neither a"
-                            " game ID (%s) nor a save file (%s)",
-                            arg, err_param, err_load);
-                } else {
-                    *error = dupstr(err_param);
-                }
-                midend_free(me);
-                sfree(fe);
-                return NULL;
-            }
-        } else if (err_load) {
-            *error = dupstr(err_load);
-            midend_free(me);
-            sfree(fe);
-            return NULL;
-        }
-    }
-
-    return me;
-}
-
-static void populate_preset_menu(frontend *fe,
-                                 struct preset_menu *menu, HMENU winmenu)
-{
-    int i;
-    for (i = 0; i < menu->n_entries; i++) {
-        struct preset_menu_entry *entry = &menu->entries[i];
-        UINT_PTR id_or_sub;
-        UINT flags = MF_ENABLED;
-
-        if (entry->params) {
-            id_or_sub = (UINT_PTR)(
-                IDM_PRESET_BASE + MENUITEM_STEP * entry->id);
-
-            fe->preset_menuitems[entry->id].which_menu = winmenu;
-            fe->preset_menuitems[entry->id].item_index =
-                GetMenuItemCount(winmenu);
-        } else {
-            HMENU winsubmenu = CreateMenu();
-            id_or_sub = (UINT_PTR)winsubmenu;
-            flags |= MF_POPUP;
-
-            populate_preset_menu(fe, entry->submenu, winsubmenu);
-        }
-
-        /*
-         * FIXME: we ought to go through and do something with ampersands
-         * here.
-         */
-
-        AppendMenu(winmenu, flags, id_or_sub, entry->title);
-    }
-}
-
-/*
- * Populate a frontend structure with a new midend structure, and
- * create any window furniture that it needs.
- *
- * Previously-allocated memory and window furniture will be freed by
- * this function.
- *
- */
-static int fe_set_midend(frontend *fe, midend *me)
-{
-    int x, y;
-    RECT r;
-
-    if (fe->me) {
-        midend_free(fe->me);
-        fe->preset_menu = NULL;
-        sfree(fe->preset_menuitems);
-    }
-    fe->me = me;
-    fe->game = midend_which_game(fe->me);
-
-    {
-        int i, ncolours;
-        float *colours;
-
-        colours = midend_colours(fe->me, &ncolours);
-
-        if (fe->colours) sfree(fe->colours);
-        if (fe->brushes) sfree(fe->brushes);
-        if (fe->pens) sfree(fe->pens);
-
-        fe->colours = snewn(ncolours, COLORREF);
-        fe->brushes = snewn(ncolours, HBRUSH);
-        fe->pens = snewn(ncolours, HPEN);
-
-        for (i = 0; i < ncolours; i++) {
-            fe->colours[i] = RGB(255 * colours[i*3+0],
-                                 255 * colours[i*3+1],
-                                 255 * colours[i*3+2]);
-            fe->brushes[i] = CreateSolidBrush(fe->colours[i]);
-            fe->pens[i] = CreatePen(PS_SOLID, 1, fe->colours[i]);
-        }
-        sfree(colours);
-    }
-
-    if (fe->statusbar)
-        DestroyWindow(fe->statusbar);
-    if (midend_wants_statusbar(fe->me)) {
-        fe->statusbar = CreateWindowEx(0, STATUSCLASSNAME,
-                                       TEXT(DEFAULT_STATUSBAR_TEXT),
-                                       WS_CHILD | WS_VISIBLE,
-                                       0, 0, 0, 0, /* status bar does these */
-                                       NULL, NULL, fe->inst, NULL);
-    } else
-        fe->statusbar = NULL;
-
-    get_max_puzzle_size(fe, &x, &y);
-    midend_size(fe->me, &x, &y, false, 1.0);
-
-    r.left = r.top = 0;
-    r.right = x;
-    r.bottom = y;
-    AdjustWindowRectEx(&r, WINFLAGS, true, 0);
-
-    SetWindowText(fe->hwnd, fe->game->name);
-
-    if (fe->statusbar)
-        DestroyWindow(fe->statusbar);
-    if (midend_wants_statusbar(fe->me)) {
-        RECT sr;
-        fe->statusbar = CreateWindowEx(0, STATUSCLASSNAME, TEXT("ooh"),
-                                       WS_CHILD | WS_VISIBLE,
-                                       0, 0, 0, 0, /* status bar does these */
-                                       fe->hwnd, NULL, fe->inst, NULL);
-
-        /*
-         * Now resize the window to take account of the status bar.
-         */
-        GetWindowRect(fe->statusbar, &sr);
-        GetWindowRect(fe->hwnd, &r);
-        SetWindowPos(fe->hwnd, NULL, 0, 0, r.right - r.left,
-                     r.bottom - r.top + sr.bottom - sr.top,
-                     SWP_NOMOVE | SWP_NOZORDER);
-    } else {
-        fe->statusbar = NULL;
-    }
-
-    {
-        HMENU oldmenu = GetMenu(fe->hwnd);
-
-        HMENU bar = CreateMenu();
-        HMENU menu = CreateMenu();
-        RECT menusize;
-
-        AppendMenu(bar, MF_ENABLED|MF_POPUP, (UINT_PTR)menu, "&Game");
-        fe->gamemenu = menu;
-        AppendMenu(menu, MF_ENABLED, IDM_NEW, TEXT("&New"));
-        AppendMenu(menu, MF_ENABLED, IDM_RESTART, TEXT("&Restart"));
-        /* ...here I run out of sensible accelerator characters. */
-        AppendMenu(menu, MF_ENABLED, IDM_DESC, TEXT("Speci&fic..."));
-        AppendMenu(menu, MF_ENABLED, IDM_SEED, TEXT("Rando&m Seed..."));
-
-        assert(!fe->preset_menu);
-
-        fe->preset_menu = midend_get_presets(
-            fe->me, &fe->n_preset_menuitems);
-        fe->preset_menuitems = snewn(fe->n_preset_menuitems,
-                                     struct preset_menuitemref);
-        {
-            int i;
-            for (i = 0; i < fe->n_preset_menuitems; i++)
-                fe->preset_menuitems[i].which_menu = NULL;
-        }
-        if (fe->preset_menu->n_entries > 0 || fe->game->can_configure) {
-            HMENU sub = CreateMenu();
-
-            AppendMenu(bar, MF_ENABLED|MF_POPUP, (UINT_PTR)sub, "&Type");
-
-            populate_preset_menu(fe, fe->preset_menu, sub);
-
-            if (fe->game->can_configure) {
-                AppendMenu(sub, MF_ENABLED, IDM_CONFIG, TEXT("&Custom..."));
-            }
-
-            fe->typemenu = sub;
-        } else {
-            fe->typemenu = INVALID_HANDLE_VALUE;
-        }
-
-#ifdef COMBINED
-        {
-            HMENU games = CreateMenu();
-            int i;
-
-            AppendMenu(menu, MF_SEPARATOR, 0, 0);
-            AppendMenu(menu, MF_ENABLED|MF_POPUP, (UINT_PTR)games, "&Other");
-            for (i = 0; i < gamecount; i++) {
-                if (strcmp(gamelist[i]->name, fe->game->name) != 0) {
-                    /* only include those games that aren't the same as the
-                     * game we're currently playing. */
-                    AppendMenu(games, MF_ENABLED,
-                               IDM_GAME_BASE + MENUITEM_STEP * i,
-                               gamelist[i]->name);
-                }
-            }
-        }
-#endif
-
-        AppendMenu(menu, MF_SEPARATOR, 0, 0);
-        AppendMenu(menu, MF_ENABLED, IDM_LOAD, TEXT("&Load..."));
-        AppendMenu(menu, MF_ENABLED, IDM_SAVE, TEXT("&Save..."));
-        AppendMenu(menu, MF_SEPARATOR, 0, 0);
-        if (fe->game->can_print) {
-            AppendMenu(menu, MF_ENABLED, IDM_PRINT, TEXT("&Print..."));
-            AppendMenu(menu, MF_SEPARATOR, 0, 0);
-        }
-        AppendMenu(menu, MF_ENABLED, IDM_UNDO, TEXT("Undo"));
-        AppendMenu(menu, MF_ENABLED, IDM_REDO, TEXT("Redo"));
-        if (fe->game->can_format_as_text_ever) {
-            AppendMenu(menu, MF_SEPARATOR, 0, 0);
-            AppendMenu(menu, MF_ENABLED, IDM_COPY, TEXT("&Copy"));
-        }
-        if (fe->game->can_solve) {
-            AppendMenu(menu, MF_SEPARATOR, 0, 0);
-            AppendMenu(menu, MF_ENABLED, IDM_SOLVE, TEXT("Sol&ve"));
-        }
-        AppendMenu(menu, MF_SEPARATOR, 0, 0);
-        AppendMenu(menu, MF_ENABLED, IDM_PREFS, TEXT("Pre&ferences"));
-        AppendMenu(menu, MF_SEPARATOR, 0, 0);
-        AppendMenu(menu, MF_ENABLED, IDM_QUIT, TEXT("E&xit"));
-        menu = CreateMenu();
-        AppendMenu(bar, MF_ENABLED|MF_POPUP, (UINT_PTR)menu, TEXT("&Help"));
-        AppendMenu(menu, MF_ENABLED, IDM_ABOUT, TEXT("&About"));
-        if (help_type != NONE) {
-            char *item;
-            AppendMenu(menu, MF_SEPARATOR, 0, 0);
-            AppendMenu(menu, MF_ENABLED, IDM_HELPC, TEXT("&Contents"));
-            assert(fe->game->name);
-            item = snewn(10+strlen(fe->game->name), char); /*ick*/
-            sprintf(item, "&Help on %s", fe->game->name);
-            AppendMenu(menu, MF_ENABLED, IDM_GAMEHELP, item);
-            sfree(item);
-        }
-        DestroyMenu(oldmenu);
-        SetMenu(fe->hwnd, bar);
-        get_menu_size(fe->hwnd, &menusize);
-        fe->xmin = (menusize.right - menusize.left) + 25;
-    }
-
-    if (fe->bitmap) DeleteObject(fe->bitmap);
-    fe->bitmap = NULL;
-    new_game_size(fe, fe->puzz_scale); /* initialises fe->bitmap */
-
-    return 0;
-}
-
-static void show_window(frontend *fe)
-{
-    ShowWindow(fe->hwnd, SW_SHOWNORMAL);
-    SetForegroundWindow(fe->hwnd);
-
-    update_type_menu_tick(fe);
-    update_copy_menu_greying(fe);
-
-    midend_redraw(fe->me);
-}
-
-static int CALLBACK AboutDlgProc(HWND hwnd, UINT msg,
-                                 WPARAM wParam, LPARAM lParam)
-{
-    frontend *fe = (frontend *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
-
-    switch (msg) {
-      case WM_INITDIALOG:
-        return 1;
-
-      case WM_COMMAND:
-        if (LOWORD(wParam) == IDOK)
-            fe->dlg_done = 1;
-        return 0;
-
-      case WM_CLOSE:
-        fe->dlg_done = 1;
-        return 0;
-    }
-
-    return 0;
-}
-
-/*
- * Wrappers on midend_{get,set}_config, which extend the CFG_*
- * enumeration to add CFG_PRINT.
- */
-static config_item *frontend_get_config(frontend *fe, int which,
-                                        char **wintitle)
-{
-    if (which < CFG_FRONTEND_SPECIFIC) {
-        return midend_get_config(fe->me, which, wintitle);
-    } else if (which == CFG_PRINT) {
-        config_item *ret;
-        int i;
-
-        *wintitle = snewn(40 + strlen(fe->game->name), char);
-        sprintf(*wintitle, "%s print setup", fe->game->name);
-
-        ret = snewn(8, config_item);
-
-        i = 0;
-
-        ret[i].name = "Number of puzzles to print";
-        ret[i].type = C_STRING;
-        ret[i].u.string.sval = dupstr("1");
-        i++;
-
-        ret[i].name = "Number of puzzles across the page";
-        ret[i].type = C_STRING;
-        ret[i].u.string.sval = dupstr("1");
-        i++;
-
-        ret[i].name = "Number of puzzles down the page";
-        ret[i].type = C_STRING;
-        ret[i].u.string.sval = dupstr("1");
-        i++;
-
-        ret[i].name = "Percentage of standard size";
-        ret[i].type = C_STRING;
-        ret[i].u.string.sval = dupstr("100.0");
-        i++;
-
-        ret[i].name = "Include currently shown puzzle";
-        ret[i].type = C_BOOLEAN;
-        ret[i].u.boolean.bval = true;
-        i++;
-
-        ret[i].name = "Print solutions";
-        ret[i].type = C_BOOLEAN;
-        ret[i].u.boolean.bval = false;
-        i++;
-
-        if (fe->game->can_print_in_colour) {
-            ret[i].name = "Print in colour";
-            ret[i].type = C_BOOLEAN;
-            ret[i].u.boolean.bval = false;
-            i++;
-        }
-
-        ret[i].name = NULL;
-        ret[i].type = C_END;
-        i++;
-
-        return ret;
-    } else {
-        assert(!"We should never get here");
-        return NULL;
-    }
-}
-
-static const char *frontend_set_config(
-    frontend *fe, int which, config_item *cfg)
-{
-    if (which < CFG_FRONTEND_SPECIFIC) {
-        return midend_set_config(fe->me, which, cfg);
-    } else if (which == CFG_PRINT) {
-        if ((fe->printcount = atoi(cfg[0].u.string.sval)) <= 0)
-            return "Number of puzzles to print should be at least one";
-        if ((fe->printw = atoi(cfg[1].u.string.sval)) <= 0)
-            return "Number of puzzles across the page should be at least one";
-        if ((fe->printh = atoi(cfg[2].u.string.sval)) <= 0)
-            return "Number of puzzles down the page should be at least one";
-        if ((fe->printscale = (float)atof(cfg[3].u.string.sval)) <= 0)
-            return "Print size should be positive";
-        fe->printcurr = cfg[4].u.boolean.bval;
-        fe->printsolns = cfg[5].u.boolean.bval;
-        fe->printcolour = fe->game->can_print_in_colour &&
-            cfg[6].u.boolean.bval;
-        return NULL;
-    } else {
-        assert(!"We should never get here");
-        return "Internal error";
-    }
-}
-
-static int CALLBACK ConfigDlgProc(HWND hwnd, UINT msg,
-                                  WPARAM wParam, LPARAM lParam)
-{
-    frontend *fe = (frontend *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
-    config_item *i;
-    struct cfg_aux *j;
-
-    switch (msg) {
-      case WM_INITDIALOG:
-        return 1;
-
-      case WM_COMMAND:
-        /*
-         * OK and Cancel are special cases.
-         */
-        if ((LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)) {
-            if (LOWORD(wParam) == IDOK) {
-                const char *err = frontend_set_config(
-                    fe, fe->cfg_which, fe->cfg);
-
-                if (err) {
-                    MessageBox(hwnd, err, "Validation error",
-                               MB_ICONERROR | MB_OK);
-                } else {
-                    fe->dlg_done = 2;
-                }
-            } else {
-                fe->dlg_done = 1;
-            }
-            return 0;
-        }
-
-        /*
-         * First find the control whose id this is.
-         */
-        for (i = fe->cfg, j = fe->cfgaux; i->type != C_END; i++, j++) {
-            if (j->ctlid == LOWORD(wParam))
-                break;
-        }
-        if (i->type == C_END)
-            return 0;                  /* not our problem */
-
-        if (i->type == C_STRING && HIWORD(wParam) == EN_CHANGE) {
-            char buffer[4096];
-            GetDlgItemText(fe->cfgbox, j->ctlid, buffer, lenof(buffer));
-            buffer[lenof(buffer)-1] = '\0';
-            sfree(i->u.string.sval);
-            i->u.string.sval = dupstr(buffer);
-        } else if (i->type == C_BOOLEAN && 
-                   (HIWORD(wParam) == BN_CLICKED ||
-                    HIWORD(wParam) == BN_DBLCLK)) {
-            i->u.boolean.bval = IsDlgButtonChecked(fe->cfgbox, j->ctlid);
-        } else if (i->type == C_CHOICES &&
-                   HIWORD(wParam) == CBN_SELCHANGE) {
-            i->u.choices.selected = SendDlgItemMessage(fe->cfgbox, j->ctlid,
-                                                       CB_GETCURSEL, 0, 0);
-        }
-
-        return 0;
-
-      case WM_CLOSE:
-        fe->dlg_done = 1;
-        return 0;
-    }
-
-    return 0;
-}
-
-HWND mkctrl(frontend *fe, int x1, int x2, int y1, int y2,
-            char *wclass, int wstyle,
-            int exstyle, const char *wtext, INT_PTR wid)
-{
-    HWND ret;
-    ret = CreateWindowEx(exstyle, wclass, wtext,
-                         wstyle | WS_CHILD | WS_VISIBLE, x1, y1, x2-x1, y2-y1,
-                         fe->cfgbox, (HMENU) wid, fe->inst, NULL);
-    SendMessage(ret, WM_SETFONT, (WPARAM)fe->cfgfont, MAKELPARAM(true, 0));
-    return ret;
-}
-
-static void about(frontend *fe)
-{
-    int i;
-    WNDCLASS wc;
-    MSG msg;
-    TEXTMETRIC tm;
-    HDC hdc;
-    HFONT oldfont;
-    SIZE size;
-    int gm, id;
-    int winwidth, winheight, y;
-    int height, width, maxwid;
-    const char *strings[16];
-    int lengths[16];
-    int nstrings = 0;
-    char titlebuf[512];
-
-    sprintf(titlebuf, "About %.250s", fe->game->name);
-
-    strings[nstrings++] = fe->game->name;
-    strings[nstrings++] = "from Simon Tatham's Portable Puzzle Collection";
-    strings[nstrings++] = ver;
-
-    wc.style = CS_DBLCLKS | CS_SAVEBITS;
-    wc.lpfnWndProc = DefDlgProc;
-    wc.cbClsExtra = 0;
-    wc.cbWndExtra = DLGWINDOWEXTRA + 8;
-    wc.hInstance = fe->inst;
-    wc.hIcon = NULL;
-    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
-    wc.hbrBackground = (HBRUSH) (COLOR_BACKGROUND +1);
-    wc.lpszMenuName = NULL;
-    wc.lpszClassName = "GameAboutBox";
-    RegisterClass(&wc);
-
-    hdc = GetDC(fe->hwnd);
-    SetMapMode(hdc, MM_TEXT);
-
-    fe->dlg_done = 0;
-
-    fe->cfgfont = CreateFont(-MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72),
-                             0, 0, 0, 0,
-                             false, false, false, DEFAULT_CHARSET,
-                             OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
-                             DEFAULT_QUALITY,
-                             FF_SWISS,
-                             "MS Shell Dlg");
-
-    oldfont = SelectObject(hdc, fe->cfgfont);
-    if (GetTextMetrics(hdc, &tm)) {
-        height = tm.tmAscent + tm.tmDescent;
-        width = tm.tmAveCharWidth;
-    } else {
-        height = width = 30;
-    }
-
-    /*
-     * Figure out the layout of the About box by measuring the
-     * length of each piece of text.
-     */
-    maxwid = 0;
-    winheight = height/2;
-
-    for (i = 0; i < nstrings; i++) {
-        if (GetTextExtentPoint32(hdc, strings[i], strlen(strings[i]), &size))
-            lengths[i] = size.cx;
-        else
-            lengths[i] = 0;            /* *shrug* */
-        if (maxwid < lengths[i])
-            maxwid = lengths[i];
-        winheight += height * 3 / 2 + (height / 2);
-    }
-
-    winheight += height + height * 7 / 4;      /* OK button */
-    winwidth = maxwid + 4*width;
-
-    SelectObject(hdc, oldfont);
-    ReleaseDC(fe->hwnd, hdc);
-
-    /*
-     * Create the dialog, now that we know its size.
-     */
-    {
-        RECT r, r2;
-
-        r.left = r.top = 0;
-        r.right = winwidth;
-        r.bottom = winheight;
-
-        AdjustWindowRectEx(&r, (WS_OVERLAPPEDWINDOW /*|
-                                DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
-                                WS_CAPTION | WS_SYSMENU*/) &~
-                           (WS_MAXIMIZEBOX | WS_OVERLAPPED),
-                           false, 0);
-
-        /*
-         * Centre the dialog on its parent window.
-         */
-        r.right -= r.left;
-        r.bottom -= r.top;
-        GetWindowRect(fe->hwnd, &r2);
-        r.left = (r2.left + r2.right - r.right) / 2;
-        r.top = (r2.top + r2.bottom - r.bottom) / 2;
-        r.right += r.left;
-        r.bottom += r.top;
-
-        fe->cfgbox = CreateWindowEx(0, wc.lpszClassName, titlebuf,
-                                    DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
-                                    WS_CAPTION | WS_SYSMENU,
-                                    r.left, r.top,
-                                    r.right-r.left, r.bottom-r.top,
-                                    fe->hwnd, NULL, fe->inst, NULL);
-    }
-
-    SendMessage(fe->cfgbox, WM_SETFONT, (WPARAM)fe->cfgfont, false);
-
-    SetWindowLongPtr(fe->cfgbox, GWLP_USERDATA, (LONG_PTR)fe);
-    SetWindowLongPtr(fe->cfgbox, DWLP_DLGPROC, (LONG_PTR)AboutDlgProc);
-
-    id = 1000;
-    y = height/2;
-    for (i = 0; i < nstrings; i++) {
-        int border = width*2 + (maxwid - lengths[i]) / 2;
-        mkctrl(fe, border, border+lengths[i], y+height*1/8, y+height*9/8,
-               "Static", 0, 0, strings[i], id++);
-        y += height*3/2;
-
-        assert(y < winheight);
-        y += height/2;
-    }
-
-    y += height/2;                     /* extra space before OK */
-    mkctrl(fe, width*2, maxwid+width*2, y, y+height*7/4, "BUTTON",
-           BS_PUSHBUTTON | WS_TABSTOP | BS_DEFPUSHBUTTON, 0,
-           "OK", IDOK);
-
-    SendMessage(fe->cfgbox, WM_INITDIALOG, 0, 0);
-
-    EnableWindow(fe->hwnd, false);
-    ShowWindow(fe->cfgbox, SW_SHOWNORMAL);
-    while ((gm=GetMessage(&msg, NULL, 0, 0)) > 0) {
-        if (!IsDialogMessage(fe->cfgbox, &msg))
-            DispatchMessage(&msg);
-        if (fe->dlg_done)
-            break;
-    }
-    EnableWindow(fe->hwnd, true);
-    SetForegroundWindow(fe->hwnd);
-    DestroyWindow(fe->cfgbox);
-    DeleteObject(fe->cfgfont);
-}
-
-static bool get_config(frontend *fe, int which)
-{
-    config_item *i;
-    struct cfg_aux *j;
-    char *title;
-    WNDCLASS wc;
-    MSG msg;
-    TEXTMETRIC tm;
-    HDC hdc;
-    HFONT oldfont;
-    SIZE size;
-    HWND ctl;
-    int gm, id, nctrls;
-    int winwidth, winheight, col1l, col1r, col2l, col2r, y;
-    int height, width, maxlabel, maxcheckbox;
-
-    wc.style = CS_DBLCLKS | CS_SAVEBITS;
-    wc.lpfnWndProc = DefDlgProc;
-    wc.cbClsExtra = 0;
-    wc.cbWndExtra = DLGWINDOWEXTRA + 8;
-    wc.hInstance = fe->inst;
-    wc.hIcon = NULL;
-    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
-    wc.hbrBackground = (HBRUSH) (COLOR_BACKGROUND +1);
-    wc.lpszMenuName = NULL;
-    wc.lpszClassName = "GameConfigBox";
-    RegisterClass(&wc);
-
-    hdc = GetDC(fe->hwnd);
-    SetMapMode(hdc, MM_TEXT);
-
-    fe->dlg_done = 0;
-
-    fe->cfgfont = CreateFont(-MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72),
-                             0, 0, 0, 0,
-                             false, false, false, DEFAULT_CHARSET,
-                             OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
-                             DEFAULT_QUALITY,
-                             FF_SWISS,
-                             "MS Shell Dlg");
-
-    oldfont = SelectObject(hdc, fe->cfgfont);
-    if (GetTextMetrics(hdc, &tm)) {
-        height = tm.tmAscent + tm.tmDescent;
-        width = tm.tmAveCharWidth;
-    } else {
-        height = width = 30;
-    }
-
-    fe->cfg = frontend_get_config(fe, which, &title);
-    fe->cfg_which = which;
-
-    /*
-     * Figure out the layout of the config box by measuring the
-     * length of each piece of text.
-     */
-    maxlabel = maxcheckbox = 0;
-    winheight = height/2;
-
-    for (i = fe->cfg; i->type != C_END; i++) {
-        switch (i->type) {
-          case C_STRING:
-          case C_CHOICES:
-            /*
-             * Both these control types have a label filling only
-             * the left-hand column of the box.
-             */
-            if (GetTextExtentPoint32(hdc, i->name, strlen(i->name), &size) &&
-                maxlabel < size.cx)
-                maxlabel = size.cx;
-            winheight += height * 3 / 2 + (height / 2);
-            break;
-
-          case C_BOOLEAN:
-            /*
-             * Checkboxes take up the whole of the box width.
-             */
-            if (GetTextExtentPoint32(hdc, i->name, strlen(i->name), &size) &&
-                maxcheckbox < size.cx)
-                maxcheckbox = size.cx;
-            winheight += height + (height / 2);
-            break;
-        }
-    }
-
-    winheight += height + height * 7 / 4;      /* OK / Cancel buttons */
-
-    col1l = 2*width;
-    col1r = col1l + maxlabel;
-    col2l = col1r + 2*width;
-    col2r = col2l + 30*width;
-    if (col2r < col1l+2*height+maxcheckbox)
-        col2r = col1l+2*height+maxcheckbox;
-    winwidth = col2r + 2*width;
-
-    SelectObject(hdc, oldfont);
-    ReleaseDC(fe->hwnd, hdc);
-
-    /*
-     * Create the dialog, now that we know its size.
-     */
-    {
-        RECT r, r2;
-
-        r.left = r.top = 0;
-        r.right = winwidth;
-        r.bottom = winheight;
-
-        AdjustWindowRectEx(&r, (WS_OVERLAPPEDWINDOW /*|
-                                DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
-                                WS_CAPTION | WS_SYSMENU*/) &~
-                           (WS_MAXIMIZEBOX | WS_OVERLAPPED),
-                           false, 0);
-
-        /*
-         * Centre the dialog on its parent window.
-         */
-        r.right -= r.left;
-        r.bottom -= r.top;
-        GetWindowRect(fe->hwnd, &r2);
-        r.left = (r2.left + r2.right - r.right) / 2;
-        r.top = (r2.top + r2.bottom - r.bottom) / 2;
-        r.right += r.left;
-        r.bottom += r.top;
-
-        fe->cfgbox = CreateWindowEx(0, wc.lpszClassName, title,
-                                    DS_MODALFRAME | WS_POPUP | WS_VISIBLE |
-                                    WS_CAPTION | WS_SYSMENU,
-                                    r.left, r.top,
-                                    r.right-r.left, r.bottom-r.top,
-                                    fe->hwnd, NULL, fe->inst, NULL);
-        sfree(title);
-    }
-
-    SendMessage(fe->cfgbox, WM_SETFONT, (WPARAM)fe->cfgfont, false);
-
-    SetWindowLongPtr(fe->cfgbox, GWLP_USERDATA, (LONG_PTR)fe);
-    SetWindowLongPtr(fe->cfgbox, DWLP_DLGPROC, (LONG_PTR)ConfigDlgProc);
-
-    /*
-     * Count the controls so we can allocate cfgaux.
-     */
-    for (nctrls = 0, i = fe->cfg; i->type != C_END; i++)
-        nctrls++;
-    fe->cfgaux = snewn(nctrls, struct cfg_aux);
-
-    id = 1000;
-    y = height/2;
-    for (i = fe->cfg, j = fe->cfgaux; i->type != C_END; i++, j++) {
-        switch (i->type) {
-          case C_STRING:
-            /*
-             * Edit box with a label beside it.
-             */
-            mkctrl(fe, col1l, col1r, y+height*1/8, y+height*9/8,
-                   "Static", 0, 0, i->name, id++);
-            ctl = mkctrl(fe, col2l, col2r, y, y+height*3/2,
-                         "EDIT", WS_TABSTOP | ES_AUTOHSCROLL,
-                         WS_EX_CLIENTEDGE, "", (j->ctlid = id++));
-            SetWindowText(ctl, i->u.string.sval);
-            y += height*3/2;
-            break;
-
-          case C_BOOLEAN:
-            /*
-             * Simple checkbox.
-             */
-            mkctrl(fe, col1l, col2r, y, y+height, "BUTTON",
-                   BS_NOTIFY | BS_AUTOCHECKBOX | WS_TABSTOP,
-                   0, i->name, (j->ctlid = id++));
-            CheckDlgButton(fe->cfgbox, j->ctlid, i->u.boolean.bval);
-            y += height;
-            break;
-
-          case C_CHOICES:
-            /*
-             * Drop-down list with a label beside it.
-             */
-            mkctrl(fe, col1l, col1r, y+height*1/8, y+height*9/8,
-                   "STATIC", 0, 0, i->name, id++);
-            ctl = mkctrl(fe, col2l, col2r, y, y+height*41/2,
-                         "COMBOBOX", WS_TABSTOP |
-                         CBS_DROPDOWNLIST | CBS_HASSTRINGS,
-                         WS_EX_CLIENTEDGE, "", (j->ctlid = id++));
-            {
-                char c;
-                const char *p, *q;
-                char *str;
-
-                SendMessage(ctl, CB_RESETCONTENT, 0, 0);
-                p = i->u.choices.choicenames;
-                c = *p++;
-                while (*p) {
-                    q = p;
-                    while (*q && *q != c) q++;
-                    str = snewn(q-p+1, char);
-                    strncpy(str, p, q-p);
-                    str[q-p] = '\0';
-                    SendMessage(ctl, CB_ADDSTRING, 0, (LPARAM)str);
-                    sfree(str);
-                    if (*q) q++;
-                    p = q;
-                }
-            }
-
-            SendMessage(ctl, CB_SETCURSEL, i->u.choices.selected, 0);
-
-            y += height*3/2;
-            break;
-        }
-
-        assert(y < winheight);
-        y += height/2;
-    }
-
-    y += height/2;                     /* extra space before OK and Cancel */
-    mkctrl(fe, col1l, (col1l+col2r)/2-width, y, y+height*7/4, "BUTTON",
-           BS_PUSHBUTTON | WS_TABSTOP | BS_DEFPUSHBUTTON, 0,
-           "OK", IDOK);
-    mkctrl(fe, (col1l+col2r)/2+width, col2r, y, y+height*7/4, "BUTTON",
-           BS_PUSHBUTTON | WS_TABSTOP, 0, "Cancel", IDCANCEL);
-
-    SendMessage(fe->cfgbox, WM_INITDIALOG, 0, 0);
-
-    EnableWindow(fe->hwnd, false);
-    ShowWindow(fe->cfgbox, SW_SHOWNORMAL);
-    while ((gm=GetMessage(&msg, NULL, 0, 0)) > 0) {
-        if (!IsDialogMessage(fe->cfgbox, &msg))
-            DispatchMessage(&msg);
-        if (fe->dlg_done)
-            break;
-    }
-    EnableWindow(fe->hwnd, true);
-    SetForegroundWindow(fe->hwnd);
-    DestroyWindow(fe->cfgbox);
-    DeleteObject(fe->cfgfont);
-
-    free_cfg(fe->cfg);
-    sfree(fe->cfgaux);
-
-    return (fe->dlg_done == 2);
-}
-
-static void calculate_bitmap_position(frontend *fe, int x, int y)
-{
-    /* Plain Windows - position the game in the upper-left corner */
-    fe->bitmapPosition.left = 0;
-    fe->bitmapPosition.top = 0;
-    fe->bitmapPosition.right  = fe->bitmapPosition.left + x;
-    fe->bitmapPosition.bottom = fe->bitmapPosition.top  + y;
-}
-
-static void new_bitmap(frontend *fe, int x, int y)
-{
-    HDC hdc;
-
-    if (fe->bitmap) DeleteObject(fe->bitmap);
-
-    hdc = GetDC(fe->hwnd);
-    fe->bitmap = CreateCompatibleBitmap(hdc, x, y);
-    calculate_bitmap_position(fe, x, y);
-    ReleaseDC(fe->hwnd, hdc);
-}
-
-static void new_game_size(frontend *fe, float scale)
-{
-    RECT r, sr;
-    int x, y;
-
-    get_max_puzzle_size(fe, &x, &y);
-    midend_size(fe->me, &x, &y, false, 1.0);
-
-    if (scale != 1.0) {
-        x = (int)((float)x * fe->puzz_scale);
-        y = (int)((float)y * fe->puzz_scale);
-        midend_size(fe->me, &x, &y, true, 1.0);
-    }
-    fe->ymin = (fe->xmin * y) / x;
-
-    r.left = r.top = 0;
-    r.right = x;
-    r.bottom = y;
-    AdjustWindowRectEx(&r, WINFLAGS, true, 0);
-
-    if (fe->statusbar != NULL) {
-        GetWindowRect(fe->statusbar, &sr);
-    } else {
-        sr.left = sr.right = sr.top = sr.bottom = 0;
-    }
-    SetWindowPos(fe->hwnd, NULL, 0, 0,
-                 r.right - r.left,
-                 r.bottom - r.top + sr.bottom - sr.top,
-                 SWP_NOMOVE | SWP_NOZORDER);
-
-    check_window_size(fe, &x, &y);
-
-    if (fe->statusbar != NULL)
-        SetWindowPos(fe->statusbar, NULL, 0, y, x,
-                     sr.bottom - sr.top, SWP_NOZORDER);
-
-    new_bitmap(fe, x, y);
-
-    midend_redraw(fe->me);
-}
-
-/*
- * Given a proposed new window rect, work out the resulting
- * difference in client size (from current), and use to try
- * and resize the puzzle, returning (wx,wy) as the actual
- * new window size.
- */
-
-static void adjust_game_size(frontend *fe, RECT *proposed, bool isedge,
-                             int *wx_r, int *wy_r)
-{
-    RECT cr, wr;
-    int nx, ny, xdiff, ydiff, wx, wy;
-
-    /* Work out the current window sizing, and thus the
-     * difference in size we're asking for. */
-    GetClientRect(fe->hwnd, &cr);
-    wr = cr;
-    AdjustWindowRectEx(&wr, WINFLAGS, true, 0);
-
-    xdiff = (proposed->right - proposed->left) - (wr.right - wr.left);
-    ydiff = (proposed->bottom - proposed->top) - (wr.bottom - wr.top);
-
-    if (isedge) {
-        /* These next four lines work around the fact that midend_size
-         * is happy to shrink _but not grow_ if you change one dimension
-         * but not the other. */
-        if (xdiff > 0 && ydiff == 0)
-            ydiff = (xdiff * (wr.right - wr.left)) / (wr.bottom - wr.top);
-        if (xdiff == 0 && ydiff > 0)
-            xdiff = (ydiff * (wr.bottom - wr.top)) / (wr.right - wr.left);
-    }
-
-    if (check_window_resize(fe,
-                            (cr.right - cr.left) + xdiff,
-                            (cr.bottom - cr.top) + ydiff,
-                            &nx, &ny, &wx, &wy)) {
-        new_bitmap(fe, nx, ny);
-        midend_force_redraw(fe->me);
-    } else {
-        /* reset size to current window size */
-        wx = wr.right - wr.left;
-        wy = wr.bottom - wr.top;
-    }
-    /* Re-fetch rectangle; size limits mean we might not have
-     * taken it quite to the mouse drag positions. */
-    GetClientRect(fe->hwnd, &cr);
-    adjust_statusbar(fe, &cr);
-
-    *wx_r = wx; *wy_r = wy;
-}
-
-static void update_type_menu_tick(frontend *fe)
-{
-    int total, n, i;
-
-    if (fe->typemenu == INVALID_HANDLE_VALUE)
-        return;
-
-    n = midend_which_preset(fe->me);
-
-    for (i = 0; i < fe->n_preset_menuitems; i++) {
-        if (fe->preset_menuitems[i].which_menu) {
-            int flag = (i == n ? MF_CHECKED : MF_UNCHECKED);
-            CheckMenuItem(fe->preset_menuitems[i].which_menu,
-                          fe->preset_menuitems[i].item_index,
-                          MF_BYPOSITION | flag);
-        }
-    }
-
-    if (fe->game->can_configure) {
-        int flag = (n < 0 ? MF_CHECKED : MF_UNCHECKED);
-        /* "Custom" menu item is at the bottom of the top-level Type menu */
-        total = GetMenuItemCount(fe->typemenu);
-        CheckMenuItem(fe->typemenu, total - 1, MF_BYPOSITION | flag);
-    }
-
-    DrawMenuBar(fe->hwnd);
-}
-
-static char *prefs_dir(void)
-{
-    const char *var;
-    if ((var = getenv("APPDATA")) != NULL) {
-        size_t size = strlen(var) + 80;
-        char *dir = snewn(size, char);
-        sprintf(dir, "%s\\Simon Tatham's Portable Puzzle Collection", var);
-        return dir;
-    }
-    return NULL;
-}
-
-static char *prefs_path_general(const game *game, const char *suffix)
-{
-    char *dir, *path;
-
-    dir = prefs_dir();
-    if (!dir)
-        return NULL;
-
-    path = make_prefs_path(dir, "\\", game, suffix);
-
-    sfree(dir);
-    return path;
-}
-
-static char *prefs_path(const game *game)
-{
-    return prefs_path_general(game, ".conf");
-}
-
-static char *prefs_tmp_path(const game *game)
-{
-    return prefs_path_general(game, ".tmp");
-}
-
-static void load_prefs(midend *me)
-{
-    const game *game = midend_which_game(me);
-    char *path = prefs_path(game);
-    if (!path)
-        return;
-    FILE *fp = fopen(path, "r");
-    if (!fp)
-        return;
-    const char *err = midend_load_prefs(me, savefile_read, fp);
-    fclose(fp);
-    if (err)
-        fprintf(stderr, "Unable to load preferences file %s:\n%s\n",
-                path, err);
-    sfree(path);
-}
-
-static char *save_prefs(midend *me)
-{
-    const game *game = midend_which_game(me);
-    char *dir_path = prefs_dir();
-    char *file_path = prefs_path(game);
-    char *tmp_path = prefs_tmp_path(game);
-    HANDLE fh;
-    FILE *fp;
-    bool cleanup_dir = false, cleanup_tmpfile = false;
-    char *err = NULL;
-
-    if (!dir_path || !file_path || !tmp_path) {
-        sprintf(err = snewn(256, char),
-                "Unable to save preferences:\n"
-                "Could not determine pathname for configuration files");
-        goto out;
-    }
-
-    if (!CreateDirectory(dir_path, NULL)) {
-        /* Ignore errors while trying to make the directory. It may
-         * well already exist, and even if we got some error code
-         * other than EEXIST, it's still worth at least _trying_ to
-         * make the file inside it, and see if that goes wrong. */
-    } else {
-        cleanup_dir = true;
-    }
-
-    fh = CreateFile(tmp_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
-                    FILE_ATTRIBUTE_NORMAL, NULL);
-    if (fh == INVALID_HANDLE_VALUE) {
-        char *os_err = geterrstr();
-        sprintf(err = snewn(256 + strlen(tmp_path) + strlen(os_err), char),
-                "Unable to save preferences:\n"
-                "Unable to create file '%s':\n%s", tmp_path, os_err);
-        sfree(os_err);
-        goto out;
-    } else {
-        cleanup_tmpfile = true;
-    }
-
-    fp = _fdopen(_open_osfhandle((intptr_t)fh, 0), "w");
-    SetLastError(0);
-    midend_save_prefs(me, savefile_write, fp);
-    fclose(fp);
-    if (GetLastError()) {
-        char *os_err = geterrstr();
-        sprintf(err = snewn(80 + strlen(tmp_path) + strlen(os_err), char),
-                "Unable to write file '%s':\n%s", tmp_path, os_err);
-        sfree(os_err);
-        goto out;
-    }
-
-    if (MoveFileEx(tmp_path, file_path, MOVEFILE_REPLACE_EXISTING) < 0) {
-        char *os_err = geterrstr();
-        sprintf(err = snewn(256 + strlen(tmp_path) + strlen(file_path) +
-                            strlen(os_err), char),
-                "Unable to save preferences:\n"
-                "Unable to rename '%s' to '%s':\n%s", tmp_path, file_path,
-                os_err);
-        sfree(os_err);
-        goto out;
-    } else {
-        cleanup_dir = false;
-        cleanup_tmpfile = false;
-    }
-
-  out:
-    if (cleanup_tmpfile) {
-        if (!DeleteFile(tmp_path)) { /* can't do anything about this */ }
-    }
-    if (cleanup_dir) {
-        if (!RemoveDirectory(dir_path)) { /* can't do anything about this */ }
-    }
-    sfree(dir_path);
-    sfree(file_path);
-    sfree(tmp_path);
-    return err;
-}
-
-static void update_copy_menu_greying(frontend *fe)
-{
-    UINT enable = (midend_can_format_as_text_now(fe->me) ?
-                   MF_ENABLED : MF_GRAYED);
-    EnableMenuItem(fe->gamemenu, IDM_COPY, MF_BYCOMMAND | enable);
-}
-
-static void new_game_type(frontend *fe)
-{
-    midend_new_game(fe->me);
-    new_game_size(fe, 1.0);
-    update_type_menu_tick(fe);
-    update_copy_menu_greying(fe);
-}
-
-static bool is_alt_pressed(void)
-{
-    BYTE keystate[256];
-    int r = GetKeyboardState(keystate);
-    if (!r)
-        return false;
-    if (keystate[VK_MENU] & 0x80)
-        return true;
-    if (keystate[VK_RMENU] & 0x80)
-        return true;
-    return false;
-}
-
-static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
-                                WPARAM wParam, LPARAM lParam)
-{
-    frontend *fe = (frontend *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
-    int cmd;
-
-    switch (message) {
-      case WM_CLOSE:
-        DestroyWindow(hwnd);
-        return 0;
-      case WM_COMMAND:
-        cmd = wParam & ~0xF;           /* low 4 bits reserved to Windows */
-        switch (cmd) {
-          case IDM_NEW:
-            if (midend_process_key(fe->me, 0, 0, UI_NEWGAME) == PKR_QUIT)
-                PostQuitMessage(0);
-            break;
-          case IDM_RESTART:
-            midend_restart_game(fe->me);
-            break;
-          case IDM_UNDO:
-            if (midend_process_key(fe->me, 0, 0, UI_UNDO) == PKR_QUIT)
-                PostQuitMessage(0);
-            break;
-          case IDM_REDO:
-            if (midend_process_key(fe->me, 0, 0, UI_REDO) == PKR_QUIT)
-                PostQuitMessage(0);
-            break;
-          case IDM_COPY:
-            {
-                char *text = midend_text_format(fe->me);
-                if (text)
-                    write_clip(hwnd, text);
-                else
-                    MessageBeep(MB_ICONWARNING);
-                sfree(text);
-            }
-            break;
-          case IDM_SOLVE:
-            {
-                const char *msg = midend_solve(fe->me);
-                if (msg)
-                    MessageBox(hwnd, msg, "Unable to solve",
-                               MB_ICONERROR | MB_OK);
-            }
-            break;
-          case IDM_QUIT:
-            if (midend_process_key(fe->me, 0, 0, UI_QUIT) == PKR_QUIT)
-                PostQuitMessage(0);
-            break;
-          case IDM_CONFIG:
-            if (get_config(fe, CFG_SETTINGS))
-                new_game_type(fe);
-            break;
-          case IDM_SEED:
-            if (get_config(fe, CFG_SEED))
-                new_game_type(fe);
-            break;
-          case IDM_DESC:
-            if (get_config(fe, CFG_DESC))
-                new_game_type(fe);
-            break;
-          case IDM_PRINT:
-            if (get_config(fe, CFG_PRINT))
-                print(fe);
-            break;
-          case IDM_PREFS:
-            if (get_config(fe, CFG_PREFS)) {
-                char *prefs_err = save_prefs(fe->me);
-                if (prefs_err) {
-                    MessageBox(fe->hwnd, prefs_err, "Error saving preferences",
-                               MB_ICONERROR | MB_OK);
-                    sfree(prefs_err);
-                }
-            }
-            break;
-          case IDM_ABOUT:
-            about(fe);
-            break;
-          case IDM_LOAD:
-          case IDM_SAVE:
-            {
-                OPENFILENAME of;
-                char filename[FILENAME_MAX];
-                int ret;
-
-                memset(&of, 0, sizeof(of));
-                of.hwndOwner = hwnd;
-                of.lpstrFilter = "All Files (*.*)\0*\0\0\0";
-                of.lpstrCustomFilter = NULL;
-                of.nFilterIndex = 1;
-                of.lpstrFile = filename;
-                filename[0] = '\0';
-                of.nMaxFile = lenof(filename);
-                of.lpstrFileTitle = NULL;
-                of.lpstrTitle = (cmd == IDM_SAVE ?
-                                 "Enter name of game file to save" :
-                                 "Enter name of saved game file to load");
-                of.Flags = 0;
-#ifdef OPENFILENAME_SIZE_VERSION_400
-                of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
-#else
-                of.lStructSize = sizeof(of);
-#endif
-                of.lpstrInitialDir = NULL;
-
-                if (cmd == IDM_SAVE)
-                    ret = GetSaveFileName(&of);
-                else
-                    ret = GetOpenFileName(&of);
-
-                if (ret) {
-                    if (cmd == IDM_SAVE) {
-                        FILE *fp;
-
-                        if ((fp = fopen(filename, "r")) != NULL) {
-                            char buf[256 + FILENAME_MAX];
-                            fclose(fp);
-                            /* file exists */
-
-                            sprintf(buf, "Are you sure you want to overwrite"
-                                    " the file \"%.*s\"?",
-                                    FILENAME_MAX, filename);
-                            if (MessageBox(hwnd, buf, "Question",
-                                           MB_YESNO | MB_ICONQUESTION)
-                                != IDYES)
-                                break;
-                        }
-
-                        fp = fopen(filename, "w");
-
-                        if (!fp) {
-                            MessageBox(hwnd, "Unable to open save file",
-                                       "Error", MB_ICONERROR | MB_OK);
-                            break;
-                        }
-
-                        midend_serialise(fe->me, savefile_write, fp);
-
-                        fclose(fp);
-                    } else {
-                        FILE *fp = fopen(filename, "r");
-                        const char *err = NULL;
-                        char *err_w = NULL;
-                        midend *me = fe->me;
-#ifdef COMBINED
-                        char *id_name;
-#endif
-
-                        if (!fp) {
-                            MessageBox(hwnd, "Unable to open saved game file",
-                                       "Error", MB_ICONERROR | MB_OK);
-                            break;
-                        }
-
-#ifdef COMBINED
-                        /*
-                         * This save file might be from a different
-                         * game.
-                         */
-                        err = identify_game(&id_name, savefile_read, fp);
-                        if (!err) {
-                            int i;
-                            for (i = 0; i < gamecount; i++)
-                                if (!strcmp(id_name, gamelist[i]->name))
-                                    break;
-                            if (i == gamecount) {
-                                err = "Save file is for a game not "
-                                    "supported by this program";
-                            } else {
-                                me = midend_for_new_game(fe, gamelist[i], NULL,
-                                                         false, false, &err_w);
-                                err = err_w;
-                                rewind(fp); /* for the actual load */
-                            }
-                            sfree(id_name);
-                        }
-#endif
-                        if (!err)
-                            err = midend_deserialise(me, savefile_read, fp);
-
-                        fclose(fp);
-
-                        if (err) {
-                            MessageBox(hwnd, err, "Error", MB_ICONERROR|MB_OK);
-                            sfree(err_w);
-                            break;
-                        }
-
-                        if (fe->me != me)
-                            fe_set_midend(fe, me);
-                        new_game_size(fe, 1.0);
-                    }
-                }
-            }
-
-            break;
-          case IDM_HELPC:
-            start_help(fe, NULL);
-            break;
-          case IDM_GAMEHELP:
-            assert(help_type != NONE);
-            start_help(fe, help_type == CHM ?
-                       fe->game->htmlhelp_topic : fe->game->winhelp_topic);
-            break;
-          default: {
-            unsigned n;
-
-#ifdef COMBINED
-            n = (wParam - IDM_GAME_BASE) / MENUITEM_STEP;
-            if (n < gamecount && wParam == IDM_GAME_BASE + MENUITEM_STEP * n) {
-                char *error = NULL;
-                fe_set_midend(fe, midend_for_new_game(fe, gamelist[n], NULL,
-                                                      false, false, &error));
-                sfree(error);
-                break;
-            }
-#endif
-
-            n = (wParam - IDM_PRESET_BASE) / MENUITEM_STEP;
-            if (wParam == IDM_PRESET_BASE + MENUITEM_STEP * n) {
-                game_params *preset = preset_menu_lookup_by_id(
-                    fe->preset_menu, n);
-
-                if (preset) {
-                    midend_set_params(fe->me, preset);
-                    new_game_type(fe);
-                    break;
-                }
-            }
-
-            break;
-          }
-        }
-        break;
-      case WM_DESTROY:
-        stop_help(fe);
-        frontend_free(fe);
-        PostQuitMessage(0);
-        return 0;
-      case WM_PAINT:
-        {
-            PAINTSTRUCT p;
-            HDC hdc, hdc2;
-            HBITMAP prevbm;
-            RECT rcDest;
-
-            hdc = BeginPaint(hwnd, &p);
-            hdc2 = CreateCompatibleDC(hdc);
-            prevbm = SelectObject(hdc2, fe->bitmap);
-            IntersectRect(&rcDest, &(fe->bitmapPosition), &(p.rcPaint));
-            BitBlt(hdc,
-                   rcDest.left, rcDest.top,
-                   rcDest.right - rcDest.left,
-                   rcDest.bottom - rcDest.top,
-                   hdc2,
-                   rcDest.left - fe->bitmapPosition.left,
-                   rcDest.top - fe->bitmapPosition.top,
-                   SRCCOPY);
-            SelectObject(hdc2, prevbm);
-            DeleteDC(hdc2);
-            EndPaint(hwnd, &p);
-        }
-        return 0;
-      case WM_KEYDOWN:
-        {
-            int key = -1;
-            BYTE keystate[256];
-            int r = GetKeyboardState(keystate);
-            int shift = (r && (keystate[VK_SHIFT] & 0x80)) ? MOD_SHFT : 0;
-            int ctrl = (r && (keystate[VK_CONTROL] & 0x80)) ? MOD_CTRL : 0;
-
-            switch (wParam) {
-              case VK_LEFT:
-                if (!(lParam & 0x01000000))
-                    key = MOD_NUM_KEYPAD | '4';
-                else
-                    key = shift | ctrl | CURSOR_LEFT;
-                break;
-              case VK_RIGHT:
-                if (!(lParam & 0x01000000))
-                    key = MOD_NUM_KEYPAD | '6';
-                else
-                    key = shift | ctrl | CURSOR_RIGHT;
-                break;
-              case VK_UP:
-                if (!(lParam & 0x01000000))
-                    key = MOD_NUM_KEYPAD | '8';
-                else
-                    key = shift | ctrl | CURSOR_UP;
-                break;
-              case VK_DOWN:
-                if (!(lParam & 0x01000000))
-                    key = MOD_NUM_KEYPAD | '2';
-                else
-                    key = shift | ctrl | CURSOR_DOWN;
-                break;
-                /*
-                 * Diagonal keys on the numeric keypad.
-                 */
-              case VK_PRIOR:
-                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '9';
-                break;
-              case VK_NEXT:
-                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '3';
-                break;
-              case VK_HOME:
-                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '7';
-                break;
-              case VK_END:
-                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '1';
-                break;
-              case VK_INSERT:
-                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '0';
-                break;
-              case VK_CLEAR:
-                if (!(lParam & 0x01000000)) key = MOD_NUM_KEYPAD | '5';
-                break;
-                /*
-                 * Numeric keypad keys with Num Lock on.
-                 */
-              case VK_NUMPAD4: key = MOD_NUM_KEYPAD | '4'; break;
-              case VK_NUMPAD6: key = MOD_NUM_KEYPAD | '6'; break;
-              case VK_NUMPAD8: key = MOD_NUM_KEYPAD | '8'; break;
-              case VK_NUMPAD2: key = MOD_NUM_KEYPAD | '2'; break;
-              case VK_NUMPAD5: key = MOD_NUM_KEYPAD | '5'; break;
-              case VK_NUMPAD9: key = MOD_NUM_KEYPAD | '9'; break;
-              case VK_NUMPAD3: key = MOD_NUM_KEYPAD | '3'; break;
-              case VK_NUMPAD7: key = MOD_NUM_KEYPAD | '7'; break;
-              case VK_NUMPAD1: key = MOD_NUM_KEYPAD | '1'; break;
-              case VK_NUMPAD0: key = MOD_NUM_KEYPAD | '0'; break;
-            }
-
-            if (key != -1) {
-                if (midend_process_key(fe->me, 0, 0, key) == PKR_QUIT)
-                    PostQuitMessage(0);
-            } else {
-                MSG m;
-                m.hwnd = hwnd;
-                m.message = WM_KEYDOWN;
-                m.wParam = wParam;
-                m.lParam = lParam & 0xdfff;
-                TranslateMessage(&m);
-            }
-        }
-        break;
-      case WM_LBUTTONDOWN:
-      case WM_RBUTTONDOWN:
-      case WM_MBUTTONDOWN:
-        {
-            int button;
-
-            /*
-             * Shift-clicks count as middle-clicks, since otherwise
-             * two-button Windows users won't have any kind of
-             * middle click to use.
-             */
-            if (message == WM_MBUTTONDOWN || (wParam & MK_SHIFT))
-                button = MIDDLE_BUTTON;
-            else if (message == WM_RBUTTONDOWN || is_alt_pressed())
-                button = RIGHT_BUTTON;
-            else
-                button = LEFT_BUTTON;
-
-            if (midend_process_key(fe->me,
-                                   (signed short)LOWORD(lParam) - fe->bitmapPosition.left,
-                                   (signed short)HIWORD(lParam) - fe->bitmapPosition.top,
-                                    button) == PKR_QUIT)
-                PostQuitMessage(0);
-
-            SetCapture(hwnd);
-        }
-        break;
-      case WM_LBUTTONUP:
-      case WM_RBUTTONUP:
-      case WM_MBUTTONUP:
-        {
-            int button;
-
-            /*
-             * Shift-clicks count as middle-clicks, since otherwise
-             * two-button Windows users won't have any kind of
-             * middle click to use.
-             */
-            if (message == WM_MBUTTONUP || (wParam & MK_SHIFT))
-                button = MIDDLE_RELEASE;
-            else if (message == WM_RBUTTONUP || is_alt_pressed())
-                button = RIGHT_RELEASE;
-            else
-                button = LEFT_RELEASE;
-
-            if (midend_process_key(fe->me,
-                                   (signed short)LOWORD(lParam) - fe->bitmapPosition.left,
-                                   (signed short)HIWORD(lParam) - fe->bitmapPosition.top,
-                                    button) == PKR_QUIT)
-                PostQuitMessage(0);
-
-            ReleaseCapture();
-        }
-        break;
-      case WM_MOUSEMOVE:
-        {
-            int button;
-
-            if (wParam & (MK_MBUTTON | MK_SHIFT))
-                button = MIDDLE_DRAG;
-            else if (wParam & MK_RBUTTON || is_alt_pressed())
-                button = RIGHT_DRAG;
-            else
-                button = LEFT_DRAG;
-            
-            if (midend_process_key(fe->me,
-                                   (signed short)LOWORD(lParam) - fe->bitmapPosition.left,
-                                   (signed short)HIWORD(lParam) - fe->bitmapPosition.top,
-                                   button) == PKR_QUIT)
-                PostQuitMessage(0);
-        }
-        break;
-      case WM_CHAR:
-        {
-            int key = (unsigned char)wParam;
-            if (key == '\x1A') {
-                BYTE keystate[256];
-                if (GetKeyboardState(keystate) &&
-                    (keystate[VK_SHIFT] & 0x80) &&
-                    (keystate[VK_CONTROL] & 0x80))
-                    key = UI_REDO;
-            }
-            if (midend_process_key(fe->me, 0, 0, key) == PKR_QUIT)
-                PostQuitMessage(0);
-        }
-        return 0;
-      case WM_TIMER:
-        if (fe->timer) {
-            DWORD now = GetTickCount();
-            float elapsed = (float) (now - fe->timer_last_tickcount) * 0.001F;
-            midend_timer(fe->me, elapsed);
-            fe->timer_last_tickcount = now;
-        }
-        return 0;
-      case WM_SIZING:
-        {
-            RECT *sr = (RECT *)lParam;
-            int wx, wy;
-            bool isedge = false;
-
-            if (wParam == WMSZ_TOP ||
-                wParam == WMSZ_RIGHT ||
-                wParam == WMSZ_BOTTOM ||
-                wParam == WMSZ_LEFT) isedge = true;
-            adjust_game_size(fe, sr, isedge, &wx, &wy);
-
-            /* Given the window size the puzzles constrain
-             * us to, work out which edge we should be moving. */
-            if (wParam == WMSZ_TOP ||
-                wParam == WMSZ_TOPLEFT ||
-                wParam == WMSZ_TOPRIGHT) {
-                sr->top = sr->bottom - wy;
-            } else {
-                sr->bottom = sr->top + wy;
-            }
-            if (wParam == WMSZ_LEFT ||
-                wParam == WMSZ_TOPLEFT ||
-                wParam == WMSZ_BOTTOMLEFT) {
-                sr->left = sr->right - wx;
-            } else {
-                sr->right = sr->left + wx;
-            }
-            return true;
-        }
-        break;
-    }
-
-    return DefWindowProc(hwnd, message, wParam, lParam);
-}
-
-/*
- * Split a complete command line into argc/argv, attempting to do it
- * exactly the same way the Visual Studio C library would do it (so
- * that our console utilities, which receive argc and argv already
- * broken apart by the C library, will have their command lines
- * processed in the same way as the GUI utilities which get a whole
- * command line and must call this function).
- * 
- * Does not modify the input command line.
- * 
- * The final parameter (argstart) is used to return a second array
- * of char * pointers, the same length as argv, each one pointing
- * at the start of the corresponding element of argv in the
- * original command line. So if you get half way through processing
- * your command line in argc/argv form and then decide you want to
- * treat the rest as a raw string, you can. If you don't want to,
- * `argstart' can be safely left NULL.
- */
-void split_into_argv(char *cmdline, int *argc, char ***argv,
-                     char ***argstart)
-{
-    char *p;
-    char *outputline, *q;
-    char **outputargv, **outputargstart;
-    int outputargc;
-
-    /*
-     * These argument-breaking rules apply to Visual Studio 7, which
-     * is currently the compiler expected to be used for the Windows
-     * port of my puzzles. Visual Studio 10 has different rules,
-     * lacking the curious mod 3 behaviour of consecutive quotes
-     * described below; I presume they fixed a bug. As and when we
-     * migrate to a newer compiler, we'll have to adjust this to
-     * match; however, for the moment we faithfully imitate in our GUI
-     * utilities what our CLI utilities can't be prevented from doing.
-     *
-     * When I investigated this, at first glance the rules appeared to
-     * be:
-     *
-     *  - Single quotes are not special characters.
-     *
-     *  - Double quotes are removed, but within them spaces cease
-     *    to be special.
-     *
-     *  - Backslashes are _only_ special when a sequence of them
-     *    appear just before a double quote. In this situation,
-     *    they are treated like C backslashes: so \" just gives a
-     *    literal quote, \\" gives a literal backslash and then
-     *    opens or closes a double-quoted segment, \\\" gives a
-     *    literal backslash and then a literal quote, \\\\" gives
-     *    two literal backslashes and then opens/closes a
-     *    double-quoted segment, and so forth. Note that this
-     *    behaviour is identical inside and outside double quotes.
-     *
-     *  - Two successive double quotes become one literal double
-     *    quote, but only _inside_ a double-quoted segment.
-     *    Outside, they just form an empty double-quoted segment
-     *    (which may cause an empty argument word).
-     *
-     *  - That only leaves the interesting question of what happens
-     *    when one or more backslashes precedes two or more double
-     *    quotes, starting inside a double-quoted string. And the
-     *    answer to that appears somewhat bizarre. Here I tabulate
-     *    number of backslashes (across the top) against number of
-     *    quotes (down the left), and indicate how many backslashes
-     *    are output, how many quotes are output, and whether a
-     *    quoted segment is open at the end of the sequence:
-     * 
-     *                      backslashes
-     * 
-     *               0         1      2      3      4
-     * 
-     *         0   0,0,y  |  1,0,y  2,0,y  3,0,y  4,0,y
-     *            --------+-----------------------------
-     *         1   0,0,n  |  0,1,y  1,0,n  1,1,y  2,0,n
-     *    q    2   0,1,n  |  0,1,n  1,1,n  1,1,n  2,1,n
-     *    u    3   0,1,y  |  0,2,n  1,1,y  1,2,n  2,1,y
-     *    o    4   0,1,n  |  0,2,y  1,1,n  1,2,y  2,1,n
-     *    t    5   0,2,n  |  0,2,n  1,2,n  1,2,n  2,2,n
-     *    e    6   0,2,y  |  0,3,n  1,2,y  1,3,n  2,2,y
-     *    s    7   0,2,n  |  0,3,y  1,2,n  1,3,y  2,2,n
-     *         8   0,3,n  |  0,3,n  1,3,n  1,3,n  2,3,n
-     *         9   0,3,y  |  0,4,n  1,3,y  1,4,n  2,3,y
-     *        10   0,3,n  |  0,4,y  1,3,n  1,4,y  2,3,n
-     *        11   0,4,n  |  0,4,n  1,4,n  1,4,n  2,4,n
-     * 
-     * 
-     *      [Test fragment was of the form "a\\\"""b c" d.]
-     * 
-     * There is very weird mod-3 behaviour going on here in the
-     * number of quotes, and it even applies when there aren't any
-     * backslashes! How ghastly.
-     * 
-     * With a bit of thought, this extremely odd diagram suddenly
-     * coalesced itself into a coherent, if still ghastly, model of
-     * how things work:
-     * 
-     *  - As before, backslashes are only special when one or more
-     *    of them appear contiguously before at least one double
-     *    quote. In this situation the backslashes do exactly what
-     *    you'd expect: each one quotes the next thing in front of
-     *    it, so you end up with n/2 literal backslashes (if n is
-     *    even) or (n-1)/2 literal backslashes and a literal quote
-     *    (if n is odd). In the latter case the double quote
-     *    character right after the backslashes is used up.
-     * 
-     *  - After that, any remaining double quotes are processed. A
-     *    string of contiguous unescaped double quotes has a mod-3
-     *    behaviour:
-     * 
-     *     * inside a quoted segment, a quote ends the segment.
-     *     * _immediately_ after ending a quoted segment, a quote
-     *       simply produces a literal quote.
-     *     * otherwise, outside a quoted segment, a quote begins a
-     *       quoted segment.
-     * 
-     *    So, for example, if we started inside a quoted segment
-     *    then two contiguous quotes would close the segment and
-     *    produce a literal quote; three would close the segment,
-     *    produce a literal quote, and open a new segment. If we
-     *    started outside a quoted segment, then two contiguous
-     *    quotes would open and then close a segment, producing no
-     *    output (but potentially creating a zero-length argument);
-     *    but three quotes would open and close a segment and then
-     *    produce a literal quote.
-     */
-
-    /*
-     * First deal with the simplest of all special cases: if there
-     * aren't any arguments, return 0,NULL,NULL.
-     */
-    while (*cmdline && isspace(*cmdline)) cmdline++;
-    if (!*cmdline) {
-        if (argc) *argc = 0;
-        if (argv) *argv = NULL;
-        if (argstart) *argstart = NULL;
-        return;
-    }
-
-    /*
-     * This will guaranteeably be big enough; we can realloc it
-     * down later.
-     */
-    outputline = snewn(1+strlen(cmdline), char);
-    outputargv = snewn(strlen(cmdline)+1 / 2, char *);
-    outputargstart = snewn(strlen(cmdline)+1 / 2, char *);
-
-    p = cmdline; q = outputline; outputargc = 0;
-
-    while (*p) {
-        bool quote;
-
-        /* Skip whitespace searching for start of argument. */
-        while (*p && isspace(*p)) p++;
-        if (!*p) break;
-
-        /* We have an argument; start it. */
-        outputargv[outputargc] = q;
-        outputargstart[outputargc] = p;
-        outputargc++;
-        quote = false;
-
-        /* Copy data into the argument until it's finished. */
-        while (*p) {
-            if (!quote && isspace(*p))
-                break;                 /* argument is finished */
-
-            if (*p == '"' || *p == '\\') {
-                /*
-                 * We have a sequence of zero or more backslashes
-                 * followed by a sequence of zero or more quotes.
-                 * Count up how many of each, and then deal with
-                 * them as appropriate.
-                 */
-                int i, slashes = 0, quotes = 0;
-                while (*p == '\\') slashes++, p++;
-                while (*p == '"') quotes++, p++;
-
-                if (!quotes) {
-                    /*
-                     * Special case: if there are no quotes,
-                     * slashes are not special at all, so just copy
-                     * n slashes to the output string.
-                     */
-                    while (slashes--) *q++ = '\\';
-                } else {
-                    /* Slashes annihilate in pairs. */
-                    while (slashes >= 2) slashes -= 2, *q++ = '\\';
-
-                    /* One remaining slash takes out the first quote. */
-                    if (slashes) quotes--, *q++ = '"';
-
-                    if (quotes > 0) {
-                        /* Outside a quote segment, a quote starts one. */
-                        if (!quote) quotes--, quote = true;
-
-                        /* Now we produce (n+1)/3 literal quotes... */
-                        for (i = 3; i <= quotes+1; i += 3) *q++ = '"';
-
-                        /* ... and end in a quote segment iff 3 divides n. */
-                        quote = (quotes % 3 == 0);
-                    }
-                }
-            } else {
-                *q++ = *p++;
-            }
-        }
-
-        /* At the end of an argument, just append a trailing NUL. */
-        *q++ = '\0';
-    }
-
-    outputargv = sresize(outputargv, outputargc, char *);
-    outputargstart = sresize(outputargstart, outputargc, char *);
-
-    if (argc) *argc = outputargc;
-    if (argv) *argv = outputargv; else sfree(outputargv);
-    if (argstart) *argstart = outputargstart; else sfree(outputargstart);
-}
-
-int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
-{
-    MSG msg;
-    char *error = NULL;
-    const game *gg;
-    frontend *fe;
-    midend *me;
-    int argc;
-    char **argv;
-
-    split_into_argv(cmdline, &argc, &argv, NULL);
-
-    InitCommonControls();
-
-    if (!prev) {
-        WNDCLASS wndclass;
-
-        wndclass.style = 0;
-        wndclass.lpfnWndProc = WndProc;
-        wndclass.cbClsExtra = 0;
-        wndclass.cbWndExtra = 0;
-        wndclass.hInstance = inst;
-        wndclass.hIcon = LoadIcon(inst, MAKEINTRESOURCE(200));
-        if (!wndclass.hIcon)           /* in case resource file is absent */
-            wndclass.hIcon = LoadIcon(inst, IDI_APPLICATION);
-        wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
-        wndclass.hbrBackground = NULL;
-        wndclass.lpszMenuName = NULL;
-        wndclass.lpszClassName = CLASSNAME;
-
-        RegisterClass(&wndclass);
-    }
-
-    while (*cmdline && isspace((unsigned char)*cmdline))
-        cmdline++;
-
-    init_help();
-
-#ifdef COMBINED
-    gg = gamelist[0];
-    if (argc > 0) {
-        int i;
-        for (i = 0; i < gamecount; i++) {
-            const char *p = gamelist[i]->name;
-            char *q = argv[0];
-            while (*p && *q) {
-                if (isspace((unsigned char)*p)) {
-                    while (*q && isspace((unsigned char)*q))
-                        q++;
-                } else {
-                    if (tolower((unsigned char)*p) !=
-                        tolower((unsigned char)*q))
-                        break;
-                    q++;
-                }
-                p++;
-            }
-            if (!*p) {
-                gg = gamelist[i];
-                --argc;
-                ++argv;
-                break;
-            }
-        }
-    }
-#else
-    gg = &thegame;
-#endif
-
-    fe = frontend_new(inst);
-    me = midend_for_new_game(fe, gg, argc > 0 ? argv[0] : NULL,
-                             true, true, &error);
-    if (!me) {
-        char buf[128];
-#ifdef COMBINED
-        sprintf(buf, "Puzzles Error");
-#else
-        sprintf(buf, "%.100s Error", gg->name);
-#endif
-        MessageBox(NULL, error, buf, MB_OK|MB_ICONERROR);
-        sfree(error);
-        return 1;
-    }
-    fe_set_midend(fe, me);
-    show_window(fe);
-
-    while (GetMessage(&msg, NULL, 0, 0)) {
-        DispatchMessage(&msg);
-    }
-
-    DestroyWindow(fe->hwnd);
-    cleanup_help();
-
-    return msg.wParam;
-}
-/* vim: set shiftwidth=4 tabstop=8: */