path: root/engines/glk/magnetic/glk.cpp

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#include "glk/magnetic/magnetic_defs.h"
#include "glk/magnetic/magnetic.h"

namespace Glk {
namespace Magnetic {

const gms_command_t Magnetic::GMS_COMMAND_TABLE[14] = {
	{ &Magnetic::gms_command_summary,        "summary",        false, false },
	{ &Magnetic::gms_command_undo,           "undo",           false, true },
	{ &Magnetic::gms_command_script,         "script",         true,  false },
	{ &Magnetic::gms_command_inputlog,       "inputlog",       true,  false },
	{ &Magnetic::gms_command_readlog,        "readlog",        true,  false },
	{ &Magnetic::gms_command_abbreviations,  "abbreviations",  true,  false },
	{ &Magnetic::gms_command_graphics,       "graphics",       true,  false },
	{ &Magnetic::gms_command_gamma,          "gamma",          true,  false },
	{ &Magnetic::gms_command_animations,     "animations",     true,  false },
	{ &Magnetic::gms_command_prompts,        "prompts",        true,  false },
	{ &Magnetic::gms_command_version,        "version",        false, false },
	{ &Magnetic::gms_command_commands,       "commands",       true,  false },
	{ &Magnetic::gms_command_help,           "help",           true,  false },

	{ nullptr, nullptr, false, false}
};

const gms_gamma_t Magnetic::GMS_GAMMA_TABLE[38] = {
	{ "0.90", { 0,  29,  63,  99, 137, 175, 215, 255 }, true },
	{ "0.95", { 0,  33,  68, 105, 141, 179, 217, 255 }, true },
	{ "1.00", { 0,  36,  73, 109, 146, 182, 219, 255 }, false },
	{ "1.05", { 0,  40,  77, 114, 150, 185, 220, 255 }, true },
	{ "1.10", { 0,  43,  82, 118, 153, 188, 222, 255 }, true },
	{ "1.15", { 0,  47,  86, 122, 157, 190, 223, 255 }, true },
	{ "1.20", { 0,  50,  90, 126, 160, 193, 224, 255 }, true },
	{ "1.25", { 0,  54,  94, 129, 163, 195, 225, 255 }, true },
	{ "1.30", { 0,  57,  97, 133, 166, 197, 226, 255 }, true },
	{ "1.35", { 0,  60, 101, 136, 168, 199, 227, 255 }, true },
	{ "1.40", { 0,  64, 104, 139, 171, 201, 228, 255 }, true },
	{ "1.45", { 0,  67, 107, 142, 173, 202, 229, 255 }, true },
	{ "1.50", { 0,  70, 111, 145, 176, 204, 230, 255 }, true },
	{ "1.55", { 0,  73, 114, 148, 178, 205, 231, 255 }, true },
	{ "1.60", { 0,  76, 117, 150, 180, 207, 232, 255 }, true },
	{ "1.65", { 0,  78, 119, 153, 182, 208, 232, 255 }, true },
	{ "1.70", { 0,  81, 122, 155, 183, 209, 233, 255 }, true },
	{ "1.75", { 0,  84, 125, 157, 185, 210, 233, 255 }, true },
	{ "1.80", { 0,  87, 127, 159, 187, 212, 234, 255 }, true },
	{ "1.85", { 0,  89, 130, 161, 188, 213, 235, 255 }, true },
	{ "1.90", { 0,  92, 132, 163, 190, 214, 235, 255 }, true },
	{ "1.95", { 0,  94, 134, 165, 191, 215, 236, 255 }, true },
	{ "2.00", { 0,  96, 136, 167, 193, 216, 236, 255 }, true },
	{ "2.05", { 0,  99, 138, 169, 194, 216, 237, 255 }, true },
	{ "2.10", { 0, 101, 140, 170, 195, 217, 237, 255 }, true },
	{ "2.15", { 0, 103, 142, 172, 197, 218, 237, 255 }, true },
	{ "2.20", { 0, 105, 144, 173, 198, 219, 238, 255 }, true },
	{ "2.25", { 0, 107, 146, 175, 199, 220, 238, 255 }, true },
	{ "2.30", { 0, 109, 148, 176, 200, 220, 238, 255 }, true },
	{ "2.35", { 0, 111, 150, 178, 201, 221, 239, 255 }, true },
	{ "2.40", { 0, 113, 151, 179, 202, 222, 239, 255 }, true },
	{ "2.45", { 0, 115, 153, 180, 203, 222, 239, 255 }, true },
	{ "2.50", { 0, 117, 154, 182, 204, 223, 240, 255 }, true },
	{ "2.55", { 0, 119, 156, 183, 205, 223, 240, 255 }, true },
	{ "2.60", { 0, 121, 158, 184, 206, 224, 240, 255 }, true },
	{ "2.65", { 0, 122, 159, 185, 206, 225, 241, 255 }, true },
	{ "2.70", { 0, 124, 160, 186, 207, 225, 241, 255 }, true },
	{ NULL,   { 0,   0,   0,   0,   0,   0,   0,   0 }, false }
};

static gms_abbreviation_t GMS_ABBREVIATIONS[] = {
	{'c', "close"},    {'g', "again"},  {'i', "inventory"},
	{'k', "attack"},   {'l', "look"},   {'p', "open"},
	{'q', "quit"},     {'r', "drop"},   {'t', "take"},
	{'x', "examine"},  {'y', "yes"},    {'z', "wait"},
	{'\0', NULL}
};

/*---------------------------------------------------------------------*/
/*  Module constants                                                   */
/*---------------------------------------------------------------------*/

/* Glk Magnetic Scrolls port version number. */
static const glui32 GMS_PORT_VERSION = 0x00010601;

/* Magnetic Scrolls standard input prompt string. */
static const char *const GMS_INPUT_PROMPT = ">";

/*
 * Maximum number of regions to consider in a single repaint pass.  A
 * couple of hundred seems to strike the right balance between not too
 * sluggardly picture updates, and responsiveness to input during graphics
 * rendering, when combined with short timeouts.
 */
static const int GMS_REPAINT_LIMIT = 256;

/*
 * Graphics timeout; we like an update call after this period (ms).  In
 * practice, this timeout may actually be shorter than the time taken
 * to reach the limit on repaint regions, but because Glk guarantees that
 * user interactions (in this case, line events) take precedence over
 * timeouts, this should be okay; we'll still see a game that responds to
 * input each time the background repaint function yields.
 *
 * Setting this value is tricky.  We'd like it to be the shortest possible
 * consistent with getting other stuff done, say 10ms.  However, Xglk has
 * a granularity of 50ms on checking for timeouts, as it uses a 1/20s
 * timeout on X select.  This means that the shortest timeout we'll ever
 * get from Xglk will be 50ms, so there's no point in setting this shorter
 * than that.  With luck, other Glk libraries will be more efficient than
 * this, and can give us higher timer resolution; we'll set 50ms here, and
 * hope that no other Glk library is worse.
 */
static const glui32 GMS_GRAPHICS_TIMEOUT = 50;

/*
 * Count of timeouts to wait in between animation paints, and to wait on
 * repaint request.  Waiting for 2 timeouts of around 50ms, gets us to the
 * 100ms recommended animation frame rate.  Waiting after a repaint smooths
 * the display where the frame is being resized, by helping to avoid
 * graphics output while more resize events are received; around 1/2 second
 * seems okay.
 */
static const int GMS_GRAPHICS_ANIMATION_WAIT = 2,
GMS_GRAPHICS_REPAINT_WAIT = 10;

/* Pixel size multiplier for image size scaling. */
static const int GMS_GRAPHICS_PIXEL = 2;

/* Proportion of the display to use for graphics. */
static const glui32 GMS_GRAPHICS_PROPORTION = 60;

/*
 * Border and shading control.  For cases where we can't detect the back-
 * ground color of the main window, there's a default, white, background.
 * Bordering is black, with a 1 pixel border, 2 pixel shading, and 8 steps
 * of shading fade.
 */
static const glui32 GMS_GRAPHICS_DEFAULT_BACKGROUND = 0x00ffffff,
	GMS_GRAPHICS_BORDER_COLOR = 0x00000000;
static const int GMS_GRAPHICS_BORDER = 1,
	GMS_GRAPHICS_SHADING = 2,
	GMS_GRAPHICS_SHADE_STEPS = 8;

/*
 * Guaranteed unused pixel value.  This value is used to fill the on-screen
 * buffer on new pictures or repaints, resulting in a full paint of all
 * pixels since no off-screen, real picture, pixel will match it.
 */
static const int GMS_GRAPHICS_UNUSED_PIXEL = 0xff;

/* Default width used for non-windowing Glk status lines. */
static const int GMS_DEFAULT_STATUS_WIDTH = 74;

/* Success and fail return codes from hint functions. */
static const type8 GMS_HINT_SUCCESS = 1,
GMS_HINT_ERROR = 0;

/* Default window sizes for non-windowing Glk libraries. */
static const glui32 GMS_HINT_DEFAULT_WIDTH = 72,
GMS_HINT_DEFAULT_HEIGHT = 25;

/*
 * Special hint nodes indicating the root hint node, and a value to signal
 * quit from hints subsystem.
 */
static const type16 GMS_HINT_ROOT_NODE = 0,
GMS_HINTS_DONE = UINT16_MAX;

/* Generic hint topic for the root hints node. */
static const char *const GMS_GENERIC_TOPIC = "Hints Menu";

/*---------------------------------------------------------------------*/
/*  Glk port utility functions                                         */
/*---------------------------------------------------------------------*/

void Magnetic::gms_fatal(const char *str) {
	/*
	 * If the failure happens too early for us to have a window, print
	 * the message to stderr.
	 */
	if (!gms_main_window)
		error("\n\nINTERNAL ERROR: %s", str);

	/* Cancel all possible pending window input events. */
	glk_cancel_line_event(gms_main_window, NULL);
	glk_cancel_char_event(gms_main_window);
	if (gms_hint_menu_window) {
		glk_cancel_char_event(gms_hint_menu_window);
		glk_window_close(gms_hint_menu_window, NULL);
	}
	if (gms_hint_text_window) {
		glk_cancel_char_event(gms_hint_text_window);
		glk_window_close(gms_hint_text_window, NULL);
	}

	/* Print a message indicating the error. */
	glk_set_window(gms_main_window);
	glk_set_style(style_Normal);
	glk_put_string("\n\nINTERNAL ERROR: ");
	glk_put_string(str);

	glk_put_string("\n\nPlease record the details of this error, try to"
	                     " note down everything you did to cause it, and email"
	                     " this information to simon_baldwin@yahoo.com.\n\n");
}

void *Magnetic::gms_malloc(size_t size) {
	void *pointer;

	pointer = malloc(size);
	if (!pointer) {
		gms_fatal("GLK: Out of system memory");
		glk_exit();
	}

	return pointer;
}

void *Magnetic::gms_realloc(void *ptr, size_t size) {
	void *pointer;

	pointer = realloc(ptr, size);
	if (!pointer) {
		gms_fatal("GLK: Out of system memory");
		glk_exit();
	}

	return pointer;
}

int Magnetic::gms_strncasecmp(const char *s1, const char *s2, size_t n) {
	size_t index;

	for (index = 0; index < n; index++) {
		int diff;

		diff = glk_char_to_lower(s1[index]) - glk_char_to_lower(s2[index]);
		if (diff < 0 || diff > 0)
			return diff < 0 ? -1 : 1;
	}

	return 0;
}

int Magnetic::gms_strcasecmp(const char *s1, const char *s2) {
	size_t s1len, s2len;
	int result;

	s1len = strlen(s1);
	s2len = strlen(s2);

	result = gms_strncasecmp(s1, s2, s1len < s2len ? s1len : s2len);
	if (result < 0 || result > 0)
		return result;
	else
		return s1len < s2len ? -1 : s1len > s2len ? 1 : 0;
}

/*---------------------------------------------------------------------*/
/*  Glk port CRC functions                                             */
/*---------------------------------------------------------------------*/

glui32 Magnetic::gms_get_buffer_crc(const void *void_buffer, size_t length) {
	const char *buf = (const char *) void_buffer;
	uint32 crc;
	size_t index;

	/*
	 * Start with all ones in the crc, then update using table entries.  Xor
	 * with all ones again, finally, before returning.
	 */
	crc = 0xffffffff;
	for (index = 0; index < length; index++)
		crc = crc_table[(crc ^ buf[index]) & BYTE_MAX] ^ (crc >> CHAR_BIT);
	return crc ^ 0xffffffff;
}

/*---------------------------------------------------------------------*/
/*  Glk port game identification data and identification functions     */
/*---------------------------------------------------------------------*/

type32 Magnetic::gms_gameid_read_uint32(int offset, Common::SeekableReadStream *stream) {
	if (!stream->seek(offset))
		return 0;
	return stream->readUint32BE();
}

void Magnetic::gms_gameid_identify_game(const Common::String &text_file) {
	Common::File stream;

	if (!stream.open(text_file))
		error("Error opening game file");

	type32 game_size, game_pc;
	gms_game_tableref_t game;

	/* Read the game's signature undo size and undo pc values. */
	game_size = gms_gameid_read_uint32(0x22, &stream);
	game_pc = gms_gameid_read_uint32(0x26, &stream);

	/* Search for these values in the table, and set game name if found. */
	game = gms_gameid_lookup_game(game_size, game_pc);
	gms_gameid_game_name = game ? game->name : NULL;
}

/*---------------------------------------------------------------------*/
/*  Glk port picture functions                                         */
/*---------------------------------------------------------------------*/

int Magnetic::gms_graphics_open() {
	if (!gms_graphics_window) {
		gms_graphics_window = glk_window_open(gms_main_window,
		                      winmethod_Above
		                      | winmethod_Proportional,
		                      GMS_GRAPHICS_PROPORTION,
		                      wintype_Graphics, 0);
	}

	return gms_graphics_window != NULL;
}

void Magnetic::gms_graphics_close() {
	if (gms_graphics_window) {
		glk_window_close(gms_graphics_window, NULL);
		gms_graphics_window = NULL;
	}
}

void Magnetic::gms_graphics_start() {
	if (gms_graphics_enabled) {
		/* If not running, start the updating "thread". */
		if (!gms_graphics_active) {
			glk_request_timer_events(GMS_GRAPHICS_TIMEOUT);
			gms_graphics_active = true;
		}
	}
}

void Magnetic::gms_graphics_stop() {
	/* If running, stop the updating "thread". */
	if (gms_graphics_active) {
		glk_request_timer_events(0);
		gms_graphics_active = false;
	}
}

void Magnetic::gms_graphics_paint() {
	if (gms_graphics_enabled && gms_graphics_are_displayed()) {
		/* Set the repaint flag, and start graphics. */
		gms_graphics_repaint = true;
		gms_graphics_start();
	}
}

void Magnetic::gms_graphics_restart() {
	if (gms_graphics_enabled && gms_graphics_are_displayed()) {
		/*
		 * If the picture is animated, we'll need to be able to re-get the
		 * first animation frame so that the picture can be treated as if
		 * it is a new one.  So here, we'll try to re-extract the current
		 * picture to do this.  Calling ms_extract() is safe because we
		 * don't get here unless graphics are displayed, and graphics aren't
		 * displayed until there's a valid picture loaded, and ms_showpic
		 * only loads a picture after it's called ms_extract and set the
		 * picture id into gms_graphics_picture.
		 *
		 * The bitmap and other picture stuff can be ignored because it's
		 * the precise same stuff as we already have in picture details
		 * variables.  If the ms_extract() fails, we'll carry on regardless,
		 * which may, or may not, result in the ideal picture display.
		 *
		 * One or two non-animated pictures return NULL from ms_extract()
		 * being re-called, so we'll restrict calls to animations only.
		 * And just to be safe, we'll also call only if we're already
		 * holding a bitmap (and we should be; how else could the graphics
		 * animation flag be set?...).
		 */
		if (gms_graphics_animated && gms_graphics_bitmap) {
			type8 animated;
			type16 width, height, palette[GMS_PALETTE_SIZE];

			/* Extract the bitmap into dummy variables. */
			(void)ms_extract(gms_graphics_picture, &width, &height, palette, &animated);
		}

		/* Set the new picture flag, and start graphics. */
		gms_graphics_new_picture = true;
		gms_graphics_start();
	}
}

void Magnetic::gms_graphics_count_colors(type8 bitmap[], type16 width, type16 height,
		int *color_count, long color_usage[]) {
	int x, y, count;
	long usage[GMS_PALETTE_SIZE], index_row;
	assert(bitmap);

	/*
	 * Traverse the image, counting each pixel usage.  For the y iterator,
	 * maintain an index row as an optimization to avoid multiplications in
	 * the loop.
	 */
	count = 0;
	memset(usage, 0, sizeof(usage));
	for (y = 0, index_row = 0; y < height; y++, index_row += width) {
		for (x = 0; x < width; x++) {
			long index;

			/* Get the pixel index, and update the count for this color. */
			index = index_row + x;
			usage[bitmap[index]]++;

			/* If color usage is now 1, note new color encountered. */
			if (usage[bitmap[index]] == 1)
				count++;
		}
	}

	if (color_count)
		*color_count = count;

	if (color_usage)
		memcpy(color_usage, usage, sizeof(usage));
}

void Magnetic::gms_graphics_game_to_rgb_color(type16 color, gms_gammaref_t gamma,
		gms_rgbref_t rgb_color) {
	assert(gamma && rgb_color);

	/*
	 * Convert Magnetic Scrolls color, through gamma, into RGB.  This splits
	 * the color into components based on the 3-bits used in the game palette,
	 * and gamma-corrects and rescales each to the range 0-255, using the given
	 * correction.
	 */
	rgb_color->red   = gamma->table[(color & 0x700) >> 8];
	rgb_color->green = gamma->table[(color & 0x070) >> 4];
	rgb_color->blue  = gamma->table[(color & 0x007)];
}

void Magnetic::gms_graphics_split_color(glui32 color, gms_rgbref_t rgb_color) {
	assert(rgb_color);

	rgb_color->red   = (color >> 16) & 0xff;
	rgb_color->green = (color >> 8) & 0xff;
	rgb_color->blue  = color & 0xff;
}

glui32 Magnetic::gms_graphics_combine_color(gms_rgbref_t rgb_color) {
	glui32 color;
	assert(rgb_color);

	color = (rgb_color->red << 16) | (rgb_color->green << 8) | rgb_color->blue;
	return color;
}

int Magnetic::gms_graphics_color_luminance(gms_rgbref_t rgb_color) {
	/* Calculate the luminance and scale back by 1000 to 0-255 before return. */
	long luminance = ((long) rgb_color->red   * (long) GMS_LUMINANCE_WEIGHTS.red
	             + (long) rgb_color->green * (long) GMS_LUMINANCE_WEIGHTS.green
	             + (long) rgb_color->blue  * (long) GMS_LUMINANCE_WEIGHTS.blue);

	assert(luminance_weighting > 0);
	return (int)(luminance / luminance_weighting);
}

int Magnetic::gms_graphics_compare_luminance(const void *void_first,
        const void *void_second) {
	long first = *(const long *)void_first;
	long second = *(const long *)void_second;

	return first > second ? 1 : second > first ? -1 : 0;
}

long Magnetic::gms_graphics_contrast_variance(type16 palette[],
        long color_usage[], gms_gammaref_t gamma) {
	int index, count, has_black, mean;
	long sum;
	int contrast[GMS_PALETTE_SIZE];
	int luminance[GMS_PALETTE_SIZE + 1];  /* Luminance for each color,
                                           plus one extra for black */

	/* Calculate the luminance energy of each palette color at this gamma. */
	has_black = false;
	for (index = 0, count = 0; index < GMS_PALETTE_SIZE; index++) {
		if (color_usage[index] > 0) {
			gms_rgb_t rgb_color;

			/*
			 * Convert the 16-bit base picture color to RGB using the gamma
			 * currently under consideration.  Calculate luminance for this
			 * color and store in the next available luminance array entry.
			 */
			gms_graphics_game_to_rgb_color(palette[index], gamma, &rgb_color);
			luminance[count++] = gms_graphics_color_luminance(&rgb_color);

			/* Note if black is present in the palette. */
			has_black |= luminance[count - 1] == 0;
		}
	}

	/*
	 * For best results, we want to anchor contrast calculations to black, so
	 * if black is not represented in the palette, add it as an extra luminance.
	 */
	if (!has_black)
		luminance[count++] = 0;

	/* Sort luminance values so that the darkest color is at index 0. */
	qsort(luminance, count,
	      sizeof(*luminance), gms_graphics_compare_luminance);

	/*
	 * Calculate the difference in luminance between adjacent luminances in
	 * the sorted array, as contrast, and at the same time sum contrasts to
	 * calculate the mean.
	 */
	sum = 0;
	for (index = 0; index < count - 1; index++) {
		contrast[index] = luminance[index + 1] - luminance[index];
		sum += contrast[index];
	}
	mean = sum / (count - 1);

	/* Calculate and return the variance in contrasts. */
	sum = 0;
	for (index = 0; index < count - 1; index++)
		sum += (contrast[index] - mean) * (contrast[index] - mean);

	return sum / (count - 1);
}

gms_gammaref_t Magnetic::gms_graphics_equal_contrast_gamma(type16 palette[], long color_usage[]) {
	gms_gammaref_t gamma, result;
	long lowest_variance;
	assert(palette && color_usage);

	result = NULL;
	lowest_variance = INT32_MAX;

	/* Search the gamma table for the entry with the lowest contrast variance. */
	for (gamma = GMS_GAMMA_TABLE; gamma->level; gamma++) {
		long variance;

		/* Find the color contrast variance of the palette at this gamma. */
		variance = gms_graphics_contrast_variance(palette, color_usage, gamma);

		/*
		 * Compare the variance to the lowest so far, and if it is lower, note
		 * the gamma entry that produced it as being the current best found.
		 */
		if (variance < lowest_variance) {
			result = gamma;
			lowest_variance = variance;
		}
	}

	assert(result);
	return result;
}

gms_gammaref_t Magnetic::gms_graphics_select_gamma(type8 bitmap[],
        type16 width, type16 height, type16 palette[]) {
	long color_usage[GMS_PALETTE_SIZE];
	int color_count;
	gms_gammaref_t contrast_gamma;
	assert(linear_gamma);

	/*
	 * Check to see if automated correction is turned off; if it is, return
	 * the linear gamma.
	 */
	if (gms_gamma_mode == GAMMA_OFF)
		return linear_gamma;

	/*
	 * Get the color usage and count of total colors represented.  For a
	 * degenerate picture with one color or less, return the linear gamma.
	 */
	gms_graphics_count_colors(bitmap, width, height, &color_count, color_usage);
	if (color_count <= 1)
		return linear_gamma;

	/*
	 * Now calculate a gamma setting to give the most equal contrast across the
	 * picture colors.  We'll return either half this gamma, or all of it.
	 */
	contrast_gamma = gms_graphics_equal_contrast_gamma(palette, color_usage);

	/*
	 * For normal automated correction, return a gamma value half way between
	 * the linear gamma and the equal contrast gamma.
	 */
	if (gms_gamma_mode == GAMMA_NORMAL)
		return linear_gamma + (contrast_gamma - linear_gamma) / 2;

	/* Correction must be high; return the equal contrast gamma. */
	assert(gms_gamma_mode == GAMMA_HIGH);
	return contrast_gamma;
}

void Magnetic::gms_graphics_clear_and_border(winid_t glk_window,
        int x_offset, int y_offset, int pixel_size, type16 width, type16 height) {
	glui32 background, fade_color, shading_color;
	gms_rgb_t rgb_background, rgb_border, rgb_fade;
	int index;
	assert(glk_window);

	/*
	 * Try to detect the background color of the main window, by getting the
	 * background for Normal style (Glk offers no way to directly get a window's
	 * background color).  If we can get it, we'll match the graphics window
	 * background to it.  If we can't, we'll default the color to white.
	 */
	if (!glk_style_measure(gms_main_window,
	                             style_Normal, stylehint_BackColor, &background)) {
		/*
		 * Unable to get the main window background, so assume, and default
		 * graphics to white.
		 */
		background = GMS_GRAPHICS_DEFAULT_BACKGROUND;
	}

	/*
	 * Set the graphics window background to match the main window background,
	 * as best as we can tell, and clear the window.
	 */
	glk_window_set_background_color(glk_window, background);
	glk_window_clear(glk_window);

	/*
	 * For very small pictures, just border them, but don't try and do any
	 * shading.  Failing this check is probably highly unlikely.
	 */
	if (width < 2 * GMS_GRAPHICS_SHADE_STEPS
	        || height < 2 * GMS_GRAPHICS_SHADE_STEPS) {
		/* Paint a rectangle bigger than the picture by border pixels. */
		glk_window_fill_rect(glk_window,
		                           GMS_GRAPHICS_BORDER_COLOR,
		                           x_offset - GMS_GRAPHICS_BORDER,
		                           y_offset - GMS_GRAPHICS_BORDER,
		                           width * pixel_size + GMS_GRAPHICS_BORDER * 2,
		                           height * pixel_size + GMS_GRAPHICS_BORDER * 2);
		return;
	}

	/*
	 * Paint a rectangle bigger than the picture by border pixels all round,
	 * and with additional shading pixels right and below.  Some of these
	 * shading pixels are later overwritten by the fading loop below.  The
	 * picture will sit over this rectangle.
	 */
	glk_window_fill_rect(glk_window,
	                           GMS_GRAPHICS_BORDER_COLOR,
	                           x_offset - GMS_GRAPHICS_BORDER,
	                           y_offset - GMS_GRAPHICS_BORDER,
	                           width * pixel_size + GMS_GRAPHICS_BORDER * 2
	                           + GMS_GRAPHICS_SHADING,
	                           height * pixel_size + GMS_GRAPHICS_BORDER * 2
	                           + GMS_GRAPHICS_SHADING);

	/*
	 * Split the main window background color and the border color into
	 * components.
	 */
	gms_graphics_split_color(background, &rgb_background);
	gms_graphics_split_color(GMS_GRAPHICS_BORDER_COLOR, &rgb_border);

	/*
	 * Generate the incremental color to use in fade steps.  Here we're
	 * assuming that the border is always darker than the main window
	 * background (currently valid, as we're using black).
	 */
	rgb_fade.red = (rgb_background.red - rgb_border.red)
	               / GMS_GRAPHICS_SHADE_STEPS;
	rgb_fade.green = (rgb_background.green - rgb_border.green)
	                 / GMS_GRAPHICS_SHADE_STEPS;
	rgb_fade.blue = (rgb_background.blue - rgb_border.blue)
	                / GMS_GRAPHICS_SHADE_STEPS;

	/* Combine RGB fade into a single incremental Glk color. */
	fade_color = gms_graphics_combine_color(&rgb_fade);

	/* Fade in edge, from background to border, shading in stages. */
	shading_color = background;
	for (index = 0; index < GMS_GRAPHICS_SHADE_STEPS; index++) {
		/* Shade the two border areas with this color. */
		glk_window_fill_rect(glk_window, shading_color,
		                           x_offset + width * pixel_size
		                           + GMS_GRAPHICS_BORDER,
		                           y_offset + index - GMS_GRAPHICS_BORDER,
		                           GMS_GRAPHICS_SHADING, 1);
		glk_window_fill_rect(glk_window, shading_color,
		                           x_offset + index - GMS_GRAPHICS_BORDER,
		                           y_offset + height * pixel_size
		                           + GMS_GRAPHICS_BORDER,
		                           1, GMS_GRAPHICS_SHADING);

		/* Update the shading color for the fade next iteration. */
		shading_color -= fade_color;
	}
}

void Magnetic::gms_graphics_convert_palette(type16 ms_palette[], gms_gammaref_t gamma,
        glui32 glk_palette[]) {
	int index;
	assert(ms_palette && gamma && glk_palette);

	for (index = 0; index < GMS_PALETTE_SIZE; index++) {
		gms_rgb_t rgb_color;

		/*
		 * Convert the 16-bit base picture color through gamma to a 32-bit
		 * RGB color, and combine into a Glk color and store in the Glk palette.
		 */
		gms_graphics_game_to_rgb_color(ms_palette[index], gamma, &rgb_color);
		glk_palette[index] = gms_graphics_combine_color(&rgb_color);
	}
}

void Magnetic::gms_graphics_position_picture(winid_t glk_window,
        int pixel_size, type16 width, type16 height, int *x_offset, int *y_offset) {
	glui32 window_width, window_height;
	assert(glk_window && x_offset && y_offset);

	/* Measure the current graphics window dimensions. */
	glk_window_get_size(glk_window, &window_width, &window_height);

	/*
	 * Calculate and return an x and y offset to use on point plotting, so that
	 * the image centers inside the graphical window.
	 */
	*x_offset = ((int) window_width - width * pixel_size) / 2;
	*y_offset = ((int) window_height - height * pixel_size) / 2;
}

void Magnetic::gms_graphics_apply_animation_frame(type8 bitmap[],
        type16 frame_width, type16 frame_height, type8 mask[], int frame_x, int frame_y,
        type8 off_screen[], type16 width, type16 height) {
	int mask_width, x, y;
	type8 mask_hibit;
	long frame_row, buffer_row, mask_row;
	assert(bitmap && off_screen);

	/*
	 * It turns out that the mask isn't quite as described in defs.h, and thanks
	 * to Torbjorn Andersson and his Gtk port of Magnetic for illuminating this.
	 * The mask is made up of lines of 16-bit words, so the mask width is always
	 * even.  Here we'll calculate the real width of a mask, and also set a high
	 * bit for later on.
	 */
	mask_width = (((frame_width - 1) / CHAR_BIT) + 2) & (~1);
	mask_hibit = 1 << (CHAR_BIT - 1);

	/*
	 * Initialize row index components; these are optimizations to avoid the
	 * need for multiplications in the frame iteration loop.
	 */
	frame_row = 0;
	buffer_row = frame_y * width;
	mask_row = 0;

	/*
	 * Iterate over each frame row, clipping where y lies outside the main
	 * picture area.
	 */
	for (y = 0; y < frame_height; y++) {
		/* Clip if y is outside the main picture area. */
		if (y + frame_y < 0 || y + frame_y >= height) {
			/* Update optimization variables as if not clipped. */
			frame_row += frame_width;
			buffer_row += width;
			mask_row += mask_width;
			continue;
		}

		/* Iterate over each frame column, clipping again. */
		for (x = 0; x < frame_width; x++) {
			long frame_index, buffer_index;

			/* Clip if x is outside the main picture area. */
			if (x + frame_x < 0 || x + frame_x >= width)
				continue;

			/*
			 * If there's a mask, check the bit associated with this x,y, and
			 * ignore any transparent pixels.
			 */
			if (mask) {
				type8 mask_byte;

				/* Isolate the mask byte, and test the transparency bit. */
				mask_byte = mask[mask_row + (x / CHAR_BIT)];
				if ((mask_byte & (mask_hibit >> (x % CHAR_BIT))) != 0)
					continue;
			}

			/*
			 * Calculate indexes for this pixel into the frame, and into the
			 * main off-screen buffer, and transfer the frame pixel into the
			 * off-screen buffer.
			 */
			frame_index = frame_row + x;
			buffer_index = buffer_row + x + frame_x;
			off_screen[buffer_index] = bitmap[frame_index];
		}

		/* Update row index components on change of y. */
		frame_row += frame_width;
		buffer_row += width;
		mask_row += mask_width;
	}
}

int Magnetic::gms_graphics_animate(type8 off_screen[], type16 width, type16 height) {
	struct ms_position *positions;
	type16 count;
	type8 status;
	int frame;
	assert(off_screen);

	/* Search for more animation frames, and return zero if none. */
	status = ms_animate(&positions, &count);
	if (status == 0)
		return false;

	/* Apply each animation frame to the off-screen buffer. */
	for (frame = 0; frame < count; frame++) {
		type8 *bitmap, *mask;
		type16 frame_width, frame_height;

		/*
		 * Get the bitmap and other details for this frame.  If we can't get
		 * this animation frame, skip it and see if any others are available.
		 */
		bitmap = ms_get_anim_frame(positions[frame].number,
		                           &frame_width, &frame_height, &mask);
		if (bitmap) {
			gms_graphics_apply_animation_frame(bitmap,
			                                   frame_width, frame_height, mask,
			                                   positions[frame].x,
			                                   positions[frame].y,
			                                   off_screen, width, height);
		}
	}

	/* Return true since more animation frames remain. */
	return true;
}

#ifndef GARGLK
int Magnetic::gms_graphics_is_vertex(type8 off_screen[], type16 width, type16 height,
		int x, int y) {
	type8 pixel;
	int above, below, left, right;
	long index_row;
	assert(off_screen);

	/* Use an index row to cut down on multiplications. */
	index_row = y * width;

	/* Find the color of the reference pixel. */
	pixel = off_screen[index_row + x];
	assert(pixel < GMS_PALETTE_SIZE);

	/*
	 * Detect differences between the reference pixel and its upper, lower, left
	 * and right neighbors.  Mark as different if the neighbor doesn't exist,
	 * that is, at the edge of the picture.
	 */
	above = (y == 0 || off_screen[index_row - width + x] != pixel);
	below = (y == height - 1 || off_screen[index_row + width + x] != pixel);
	left  = (x == 0 || off_screen[index_row + x - 1] != pixel);
	right = (x == width - 1 || off_screen[index_row + x + 1] != pixel);

	/*
	 * Return true if this pixel lies at the vertex of a rectangular, fillable,
	 * area.  That is, if two adjacent neighbors aren't the same color (or if
	 * absent -- at the edge of the picture).
	 */
	return ((above || below) && (left || right));
}

int Magnetic::gms_graphics_compare_layering_inverted(const void *void_first,
        const void *void_second) {
	gms_layering_t *first = (gms_layering_t *) void_first;
	gms_layering_t *second = (gms_layering_t *) void_second;

	/*
	 * Order by complexity first, then by usage, putting largest first.  Some
	 * colors may have no vertices at all when doing animation frames, but
	 * rendering optimization relies on the first layer that contains no areas
	 * to fill halting the rendering loop.  So it's important here that we order
	 * indexes so that colors that render complex shapes come first, non-empty,
	 * but simpler shaped colors next, and finally all genuinely empty layers.
	 */
	return second->complexity > first->complexity ? 1 :
	       first->complexity > second->complexity ? -1 :
	       second->usage > first->usage ? 1 :
	       first->usage > second->usage ? -1 : 0;
}

void Magnetic::gms_graphics_assign_layers(type8 off_screen[], type8 on_screen[],
                                       type16 width, type16 height,
                                       int layers[], long layer_usage[]) {
	int index, x, y;
	long index_row;
	gms_layering_t layering[GMS_PALETTE_SIZE];
	assert(off_screen && on_screen && layers && layer_usage);

	/* Clear initial complexity and usage counts, and set initial colors. */
	for (index = 0; index < GMS_PALETTE_SIZE; index++) {
		layering[index].complexity = 0;
		layering[index].usage = 0;
		layering[index].color = index;
	}

	/*
	 * Traverse the image, counting vertices and pixel usage where the pixels
	 * differ between the off-screen and on-screen buffers.  Optimize by
	 * maintaining an index row to avoid multiplications.
	 */
	for (y = 0, index_row = 0; y < height; y++, index_row += width) {
		for (x = 0; x < width; x++) {
			long idx;

			/*
			 * Get the index for this pixel, and update complexity and usage
			 * if off-screen and on-screen pixels differ.
			 */
			idx = index_row + x;
			if (on_screen[idx] != off_screen[idx]) {
				if (gms_graphics_is_vertex(off_screen, width, height, x, y))
					layering[off_screen[idx]].complexity++;

				layering[off_screen[idx]].usage++;
			}
		}
	}

	/*
	 * Sort counts to form color indexes.  The primary sort is on the shape
	 * complexity, and within this, on color usage.
	 */
	qsort(layering, GMS_PALETTE_SIZE,
	      sizeof(*layering), gms_graphics_compare_layering_inverted);

	/*
	 * Assign a layer to each palette color, and also return the layer usage
	 * for each layer.
	 */
	for (index = 0; index < GMS_PALETTE_SIZE; index++) {
		layers[layering[index].color] = index;
		layer_usage[index] = layering[index].usage;
	}
}

void Magnetic::gms_graphics_paint_region(winid_t glk_window, glui32 palette[], int layers[],
                                      type8 off_screen[], type8 on_screen[],
                                      int x, int y, int x_offset, int y_offset,
                                      int pixel_size, type16 width, type16 height) {
	type8 pixel;
	int layer, x_min, x_max, y_min, y_max, x_index, y_index;
	long index_row;
	assert(glk_window && palette && layers && off_screen && on_screen);

	/* Find the color and layer for the initial pixel. */
	pixel = off_screen[y * width + x];
	layer = layers[pixel];
	assert(pixel < GMS_PALETTE_SIZE);

	/*
	 * Start by finding the extent to which we can pull the x coordinate and
	 * still find either invalidated pixels, or pixels in this layer.
	 *
	 * Use an index row to remove multiplications from the loops.
	 */
	index_row = y * width;
	for (x_min = x; x_min - 1 >= 0; x_min--) {
		long index = index_row + x_min - 1;

		if (on_screen[index] == off_screen[index]
		        && layers[off_screen[index]] != layer)
			break;
	}
	for (x_max = x; x_max + 1 < width; x_max++) {
		long index = index_row + x_max + 1;

		if (on_screen[index] == off_screen[index]
		        && layers[off_screen[index]] != layer)
			break;
	}

	/*
	 * Now try to stretch the height of the region, by extending the y
	 * coordinate as much as possible too.  Again, we're looking for pixels
	 * that are invalidated or ones in the same layer.  We need to check
	 * across the full width of the current region.
	 *
	 * As above, an index row removes multiplications from the loops.
	 */
	for (y_min = y, index_row = (y - 1) * width;
	        y_min - 1 >= 0; y_min--, index_row -= width) {
		for (x_index = x_min; x_index <= x_max; x_index++) {
			long index = index_row + x_index;

			if (on_screen[index] == off_screen[index]
			        && layers[off_screen[index]] != layer)
				goto break_y_min;
		}
	}
break_y_min:

	for (y_max = y, index_row = (y + 1) * width;
	        y_max + 1 < height; y_max++, index_row += width) {
		for (x_index = x_min; x_index <= x_max; x_index++) {
			long index = index_row + x_index;

			if (on_screen[index] == off_screen[index]
			        && layers[off_screen[index]] != layer)
				goto break_y_max;
		}
	}
break_y_max:

	/* Fill the region using Glk's rectangle fill. */
	glk_window_fill_rect(glk_window, palette[pixel],
	                           x_min * pixel_size + x_offset,
	                           y_min * pixel_size + y_offset,
	                           (x_max - x_min + 1) * pixel_size,
	                           (y_max - y_min + 1) * pixel_size);

	/*
	 * Validate each pixel in the reference layer that was rendered by the
	 * rectangle fill.  We don't validate pixels that are not in this layer
	 * (and are by definition in higher layers, as we've validated all lower
	 * layers), since although we colored them, we did it for optimization
	 * reasons, and they're not yet colored correctly.
	 *
	 * Maintain an index row as an optimization to avoid multiplication.
	 */
	index_row = y_min * width;
	for (y_index = y_min; y_index <= y_max; y_index++) {
		for (x_index = x_min; x_index <= x_max; x_index++) {
			long index;

			/*
			 * Get the index for x_index,y_index.  If the layers match, update
			 * the on-screen buffer.
			 */
			index = index_row + x_index;
			if (layers[off_screen[index]] == layer) {
				assert(off_screen[index] == pixel);
				on_screen[index] = off_screen[index];
			}
		}

		/* Update row index component on change of y. */
		index_row += width;
	}
}
#endif

void Magnetic::gms_graphics_paint_everything(winid_t glk_window,
        glui32 palette[], type8 off_screen[], int x_offset, int y_offset,
        type16 width, type16 height) {
	type8       pixel;          /* Reference pixel color */
	int     x, y;

	for (y = 0; y < height; y++) {
		for (x = 0; x < width; x ++) {
			pixel = off_screen[ y * width + x ];
			glk_window_fill_rect(glk_window,
			                           palette[ pixel ],
			                           x * GMS_GRAPHICS_PIXEL + x_offset,
			                           y * GMS_GRAPHICS_PIXEL + y_offset,
			                           GMS_GRAPHICS_PIXEL, GMS_GRAPHICS_PIXEL);
		}
	}
}

void Magnetic::gms_graphics_timeout() {
	static glui32 palette[GMS_PALETTE_SIZE];   /* Precomputed Glk palette */
#ifndef GARGLK
	static int layers[GMS_PALETTE_SIZE];       /* Assigned image layers */
	static long layer_usage[GMS_PALETTE_SIZE]; /* Image layer occupancies */
#endif

	static int deferred_repaint = false;       /* Local delayed repaint flag */
	static int ignore_counter;                 /* Count of calls ignored */

	static int x_offset, y_offset;             /* Point plot offsets */
	static int yield_counter;                  /* Yields in rendering */
#ifndef GARGLK
	static int saved_layer;                    /* Saved current layer */
	static int saved_x, saved_y;               /* Saved x,y coord */
	static int total_regions;                  /* Debug statistic */
#endif

	type8 *on_screen;                          /* On-screen image buffer */
	type8 *off_screen;                         /* Off-screen image buffer */
	long picture_size;                         /* Picture size in pixels */
//  int layer;                                 /* Image layer iterator */
//  int x, y;                                  /* Image iterators */
//  int regions;                               /* Count of regions painted */

	/* Ignore the call if the current graphics state is inactive. */
	if (!gms_graphics_active)
		return;
	assert(gms_graphics_window);

	/*
	 * On detecting a repaint request, note the flag in a local static variable,
	 * then set up a graphics delay to wait until, hopefully, the resize, if
	 * that's what caused it, is complete, and return.  This makes resizing the
	 * window a lot smoother, since it prevents unnecessary region paints where
	 * we are receiving consecutive Glk arrange or redraw events.
	 */
	if (gms_graphics_repaint) {
		deferred_repaint = true;
		gms_graphics_repaint = false;
		ignore_counter = GMS_GRAPHICS_REPAINT_WAIT - 1;
		return;
	}

	/*
	 * If asked to ignore a given number of calls, decrement the ignore counter
	 * and return having done nothing more.  This lets us delay graphics
	 * operations by a number of timeouts, providing animation timing and
	 * partial protection from resize event "storms".
	 *
	 * Note -- to wait for N timeouts, set the count of timeouts to be ignored
	 * to N-1.
	 */
	assert(ignore_counter >= 0);
	if (ignore_counter > 0) {
		ignore_counter--;
		return;
	}

	/* Calculate the picture size, and synchronize screen buffer pointers. */
	picture_size = gms_graphics_width * gms_graphics_height;
	off_screen = gms_graphics_off_screen;
	on_screen = gms_graphics_on_screen;

	/*
	 * If we received a new picture, set up the local static variables for that
	 * picture -- decide on gamma correction, convert the color palette, and
	 * initialize the off_screen buffer to be the base picture.
	 */
	if (gms_graphics_new_picture) {
		/* Initialize the off_screen buffer to be a copy of the base picture. */
		free(off_screen);
		off_screen = (type8 *)gms_malloc(picture_size * sizeof(*off_screen));
		memcpy(off_screen, gms_graphics_bitmap,
		       picture_size * sizeof(*off_screen));

		/* Note the buffer for freeing on cleanup. */
		gms_graphics_off_screen = off_screen;

		/*
		 * If the picture is animated, apply the first animation frames now.
		 * This is important, since they form an intrinsic part of the first
		 * displayed image (in type2 animation cases, perhaps _all_ of the
		 * first displayed image).
		 */
		if (gms_graphics_animated) {
			gms_graphics_animate(off_screen,
			                     gms_graphics_width, gms_graphics_height);
		}

		/*
		 * Select a suitable gamma for the picture, taking care to use the
		 * off-screen buffer.
		 */
		gms_graphics_current_gamma =
		    gms_graphics_select_gamma(off_screen,
		                              gms_graphics_width,
		                              gms_graphics_height,
		                              gms_graphics_palette);

		/*
		 * Pre-convert all the picture palette colors into their corresponding
		 * Glk colors.
		 */
		gms_graphics_convert_palette(gms_graphics_palette,
		                             gms_graphics_current_gamma, palette);

		/* Save the color count for possible queries later. */
		gms_graphics_count_colors(off_screen,
		                          gms_graphics_width, gms_graphics_height,
		                          &gms_graphics_color_count, NULL);
	}

	/*
	 * For a new picture, or a repaint of a prior one, calculate new values for
	 * the x and y offsets used to draw image points, and set the on-screen
	 * buffer to an unused pixel value, in effect invalidating all on-screen
	 * data.  Also, reset the saved image scan coordinates so that we scan for
	 * unpainted pixels from top left starting at layer zero, and clear the
	 * graphics window.
	 */
	if (gms_graphics_new_picture || deferred_repaint) {
		/*
		 * Calculate the x and y offset to center the picture in the graphics
		 * window.
		 */
		gms_graphics_position_picture(gms_graphics_window,
		                              GMS_GRAPHICS_PIXEL,
		                              gms_graphics_width, gms_graphics_height,
		                              &x_offset, &y_offset);

		/*
		 * Reset all on-screen pixels to an unused value, guaranteed not to
		 * match any in a real picture.  This forces all pixels to be repainted
		 * on a buffer/on-screen comparison.
		 */
		free(on_screen);
		on_screen = (type8 *)gms_malloc(picture_size * sizeof(*on_screen));
		memset(on_screen, GMS_GRAPHICS_UNUSED_PIXEL,
		       picture_size * sizeof(*on_screen));

		/* Note the buffer for freeing on cleanup. */
		gms_graphics_on_screen = on_screen;

		/*
		 * Assign new layers to the current image.  This sorts colors by usage
		 * and puts the most used colors in the lower layers.  It also hands us
		 * a count of pixels in each layer, useful for knowing when to stop
		 * scanning for layers in the rendering loop.
		 */
#ifndef GARGLK
		gms_graphics_assign_layers(off_screen, on_screen,
		                           gms_graphics_width, gms_graphics_height,
		                           layers, layer_usage);

		saved_layer = 0;
		saved_x = 0;
		saved_y = 0;
		total_regions = 0;
#endif

		/* Clear the graphics window. */
		gms_graphics_clear_and_border(gms_graphics_window,
		                              x_offset, y_offset,
		                              GMS_GRAPHICS_PIXEL,
		                              gms_graphics_width, gms_graphics_height);

		/* Start a fresh picture rendering pass. */
		yield_counter = 0;

		/* Clear the new picture and deferred repaint flags. */
		gms_graphics_new_picture = false;
		deferred_repaint = false;
	}

#ifndef GARGLK
	/*
	 * Make a portion of an image pass, from lower to higher image layers,
	 * scanning for invalidated pixels that are in the current image layer we
	 * are painting.  Each invalidated pixel gives rise to a region paint,
	 * which equates to one Glk rectangle fill.
	 *
	 * When the limit on regions is reached, save the current image pass layer
	 * and coordinates, and yield control to the main game playing code by
	 * returning.  On the next call, pick up where we left off.
	 *
	 * As an optimization, we can leave the loop on the first empty layer we
	 * encounter.  Since layers are ordered by complexity and color usage, all
	 * layers higher than the first unused one will also be empty, so we don't
	 * need to scan them.
	 */
	regions = 0;
	for (layer = saved_layer;
	        layer < GMS_PALETTE_SIZE && layer_usage[layer] > 0; layer++) {
		long index_row;

		/*
		 * As an optimization to avoid multiplications in the loop, maintain a
		 * separate index row.
		 */
		index_row = saved_y * gms_graphics_width;
		for (y = saved_y; y < gms_graphics_height; y++) {
			for (x = saved_x; x < gms_graphics_width; x++) {
				long index;

				/* Get the index for this pixel. */
				index = index_row + x;
				assert(index < picture_size * sizeof(*off_screen));

				/*
				 * Ignore pixels not in the current layer, and pixels not
				 * currently invalid (that is, ones whose on-screen represen-
				 * tation matches the off-screen buffer).
				 */
				if (layers[off_screen[index]] == layer
				        && on_screen[index] != off_screen[index]) {
					/*
					 * Rather than painting just one pixel, here we try to
					 * paint the maximal region we can for the layer of the
					 * given pixel.
					 */
					gms_graphics_paint_region(gms_graphics_window,
					                          palette, layers,
					                          off_screen, on_screen,
					                          x, y, x_offset, y_offset,
					                          GMS_GRAPHICS_PIXEL,
					                          gms_graphics_width,
					                          gms_graphics_height);

					/*
					 * Increment count of regions handled, and yield, by
					 * returning, if the limit on paint regions is reached.
					 * Before returning, save the current layer and scan
					 * coordinates, so we can pick up here on the next call.
					 */
					regions++;
					if (regions >= GMS_REPAINT_LIMIT) {
						yield_counter++;
						saved_layer = layer;
						saved_x = x;
						saved_y = y;
						total_regions += regions;
						return;
					}
				}
			}

			/* Reset the saved x coordinate on y increment. */
			saved_x = 0;

			/* Update the index row on change of y. */
			index_row += gms_graphics_width;
		}

		/* Reset the saved y coordinate on layer change. */
		saved_y = 0;
	}

	/*
	 * If we reach this point, then we didn't get to the limit on regions
	 * painted on this pass.  In that case, we've finished rendering the
	 * image.
	 */
	assert(regions < GMS_REPAINT_LIMIT);
	total_regions += regions;

#else
	gms_graphics_paint_everything
	(gms_graphics_window,
	 palette, off_screen,
	 x_offset, y_offset,
	 gms_graphics_width,
	 gms_graphics_height);
#endif

	/*
	 * If animated, and if animations are enabled, handle further animation
	 * frames, if any.
	 */
	if (gms_animation_enabled && gms_graphics_animated) {
		int more_animation;

		/*
		 * Reset the off-screen buffer to a copy of the base picture.  This is
		 * the correct state for applying animation frames.
		 */
		memcpy(off_screen, gms_graphics_bitmap,
		       picture_size * sizeof(*off_screen));

		/*
		 * Apply any further animations.  If none, then stop the graphics
		 * "thread" and return.  There's no more to be done until something
		 * restarts us.
		 */
		more_animation = gms_graphics_animate(off_screen,
		                                      gms_graphics_width,
		                                      gms_graphics_height);
		if (!more_animation) {
			/*
			 * There's one extra wrinkle here.  The base picture we've just put
			 * into the off-screen buffer isn't really complete (and for type2
			 * animations, might be pure garbage), so if we happen to get a
			 * repaint after an animation has ended, the off-screen data we'll
			 * be painting could well look wrong.
			 *
			 * So... here we want to set the off-screen buffer to contain the
			 * final animation frame.  Fortunately, we still have it in the
			 * on-screen buffer.
			 */
			memcpy(off_screen, on_screen, picture_size * sizeof(*off_screen));
			gms_graphics_stop();
			return;
		}

		/*
		 * Re-assign layers based on animation changes to the off-screen
		 * buffer.
		 */
#ifndef GARGLK
		gms_graphics_assign_layers(off_screen, on_screen,
		                           gms_graphics_width, gms_graphics_height,
		                           layers, layer_usage);
#endif

		/*
		 * Set up an animation wait, adjusted here by the number of times we
		 * had to yield while rendering, as we're now that late with animations,
		 * and capped at zero, as we can't do anything to compensate for being
		 * too late.  In practice, we're running too close to the edge to have
		 * much of an effect here, but nevertheless...
		 */
		ignore_counter = GMS_GRAPHICS_ANIMATION_WAIT - 1;
		if (yield_counter > ignore_counter)
			ignore_counter = 0;
		else
			ignore_counter -= yield_counter;

		/* Start a fresh picture rendering pass. */
		yield_counter = 0;
#ifndef GARGLK
		saved_layer = 0;
		saved_x = 0;
		saved_y = 0;
		total_regions = 0;
#endif
	} else {
		/*
		 * Not an animated picture, so just stop graphics, as again, there's
		 * no more to be done until something restarts us.
		 */
		gms_graphics_stop();
	}
}

void Magnetic::ms_showpic(type32 picture, type8 mode) {
	type8 *bitmap, animated;
	type16 width, height, palette[GMS_PALETTE_SIZE];
	long picture_bytes;
	glui32 crc;

	/* See if the mode indicates no graphics. */
	if (mode == 0) {
		/* Note that the interpreter turned graphics off. */
		gms_graphics_interpreter = false;

		/*
		 * If we are currently displaying the graphics window, stop any update
		 * "thread" and turn off graphics.
		 */
		if (gms_graphics_enabled && gms_graphics_are_displayed()) {
			gms_graphics_stop();
			gms_graphics_close();
		}

		/* Nothing more to do now graphics are off. */
		return;
	}

	/* Note that the interpreter turned graphics on. */
	gms_graphics_interpreter = true;

	/*
	 * Obtain the image details for the requested picture.  The call returns
	 * NULL if there's a problem with the picture.
	 */
	bitmap = ms_extract(picture, &width, &height, palette, &animated);
	if (!bitmap)
		return;

	/* Note the last thing passed to ms_extract, in case of graphics restarts. */
	gms_graphics_picture = picture;

	/* Calculate the picture size, and the CRC for the bitmap data. */
	picture_bytes = width * height * sizeof(*bitmap);
	crc = gms_get_buffer_crc(bitmap, picture_bytes);

	/*
	 * If there is no change of picture, we might be able to largely ignore the
	 * call.  Check for a change, and if we don't see one, and if graphics are
	 * enabled and being displayed, we can safely ignore the call.
	 */
	if (width == gms_graphics_width
	        && height == gms_graphics_height
	        && crc == pic_current_crc
	        && gms_graphics_enabled && gms_graphics_are_displayed())
		return;

	/*
	 * We know now that this is either a genuine change of picture, or graphics
	 * were off and have been turned on.  So, record picture details, ensure
	 * graphics is on, set the flags, and start the background graphics update.
	 */

	/*
	 * Save the picture details for the update code.  Here we take a complete
	 * local copy of the bitmap, since the interpreter core may reuse part of
	 * its memory for animations.
	 */
	free(gms_graphics_bitmap);
	gms_graphics_bitmap = (type8 *)gms_malloc(picture_bytes);
	memcpy(gms_graphics_bitmap, bitmap, picture_bytes);
	gms_graphics_width = width;
	gms_graphics_height = height;
	memcpy(gms_graphics_palette, palette, sizeof(palette));
	gms_graphics_animated = animated;

	/* Retain the new picture CRC. */
	pic_current_crc = crc;

	/*
	 * If graphics are enabled, ensure the window is displayed, set the
	 * appropriate flags, and start graphics update.  If they're not enabled,
	 * the picture details will simply stick around in module variables until
	 * they are required.
	 */
	if (gms_graphics_enabled) {
		/*
		 * Ensure graphics on, then set the new picture flag and start the
		 * updating "thread".
		 */
		if (gms_graphics_open()) {
			gms_graphics_new_picture = true;
			gms_graphics_start();
		}
	}
}

int Magnetic::gms_graphics_get_picture_details(int *width, int *height, int *is_animated) {
	if (gms_graphics_picture_is_available()) {
		if (width)
			*width = gms_graphics_width;
		if (height)
			*height = gms_graphics_height;
		if (is_animated)
			*is_animated = gms_graphics_animated;

		return true;
	}

	return false;
}

int Magnetic::gms_graphics_get_rendering_details(const char **gamma,
		int *color_count, int *is_active) {
	if (gms_graphics_enabled && gms_graphics_are_displayed()) {
		/*
		 * Return the string representing the gamma correction.  If racing
		 * with timeouts, we might return the gamma for the last picture.
		 */
		if (gamma) {
			assert(gms_graphics_current_gamma);
			*gamma = gms_graphics_current_gamma->level;
		}

		/*
		 * Return the color count noted by timeouts on the first timeout
		 * following a new picture.  Again, we might return the one for
		 * the prior picture.
		 */
		if (color_count)
			*color_count = gms_graphics_color_count;

		/* Return graphics active flag. */
		if (is_active)
			*is_active = gms_graphics_active;

		return true;
	}

	return false;
}

int Magnetic::gms_graphics_interpreter_enabled() {
	return gms_graphics_interpreter;
}

void Magnetic::gms_graphics_cleanup() {
	free(gms_graphics_bitmap);
	gms_graphics_bitmap = NULL;
	free(gms_graphics_off_screen);
	gms_graphics_off_screen = NULL;
	free(gms_graphics_on_screen);
	gms_graphics_on_screen = NULL;

	gms_graphics_animated = false;
	gms_graphics_picture = 0;
}

/*---------------------------------------------------------------------*/
/*  Glk port status line functions                                     */
/*---------------------------------------------------------------------*/

void Magnetic::ms_statuschar(type8 c) {
	static char buffer_[GMS_STATBUFFER_LENGTH];
	static int length = 0;

	/*
	 * If the status character is newline, transfer locally buffered data to
	 * the common buffer, empty the local buffer; otherwise, if space permits,
	 * buffer the character.
	 */
	if (c == '\n') {
		memcpy(gms_status_buffer, buffer_, length);
		gms_status_length = length;

		length = 0;
	} else {
		if (length < (int)sizeof(buffer_))
			buffer_[length++] = c;
	}
}

void Magnetic::gms_status_update() {
	glui32 width, height;
	int index;
	assert(gms_status_window);

	glk_window_get_size(gms_status_window, &width, &height);
	if (height > 0) {
		glk_window_clear(gms_status_window);
		glk_window_move_cursor(gms_status_window, 0, 0);
		glk_set_window(gms_status_window);

		glk_set_style(style_User1);
		for (index = 0; index < (int)width; index++)
			glk_put_char(' ');
		glk_window_move_cursor(gms_status_window, 1, 0);

		if (gms_status_length > 0) {
			/*
			 * Output each character from the status line buffer.  If the
			 * character is Tab, position the cursor to eleven characters shy
			 * of the status window right.
			 */
			for (index = 0; index < gms_status_length; index++) {
				if (gms_status_buffer[index] == '\t')
					glk_window_move_cursor(gms_status_window, width - 11, 0);
				else
					glk_put_char(gms_status_buffer[index]);
			}
		} else {
			const char *game_name;

			/*
			 * We have no status line to display, so print the game's name, or
			 * a standard message if unable to identify the game.  Having no
			 * status line is common with Magnetic Windows games, which don't,
			 * in general, seem to use one.
			 */
			game_name = gms_gameid_get_game_name();
			glk_put_string(game_name ? game_name : "ScummVM Magnetic version 2.3");
		}

		glk_set_window(gms_main_window);
	}
}

void Magnetic::gms_status_print() {
	static char buffer_[GMS_STATBUFFER_LENGTH];
	static int length = 0;

	int index, column;

	/*
	 * Do nothing if there is no status line to print, or if the status
	 * line hasn't changed since last printed.
	 */
	if (gms_status_length == 0
	        || (gms_status_length == length
	            && strncmp(buffer_, gms_status_buffer, length)) == 0)
		return;

	/* Set fixed width font to try to preserve status line formatting. */
	glk_set_style(style_Preformatted);

	/* Bracket, and output the status line buffer_. */
	glk_put_string("[ ");
	column = 1;
	for (index = 0; index < gms_status_length; index++) {
		/*
		 * If the character is Tab, position the cursor to eleven characters
		 * shy of the right edge.  In the absence of the real window dimensions,
		 * we'll select 74 characters, which gives us a 78 character status
		 * line; pretty standard.
		 */
		if (gms_status_buffer[index] == '\t') {
			while (column <= GMS_DEFAULT_STATUS_WIDTH - 11) {
				glk_put_char(' ');
				column++;
			}
		} else {
			glk_put_char(gms_status_buffer[index]);
			column++;
		}
	}

	while (column <= GMS_DEFAULT_STATUS_WIDTH) {
		glk_put_char(' ');
		column++;
	}
	glk_put_string(" ]\n");

	/* Save the details of the printed status buffer_. */
	memcpy(buffer_, gms_status_buffer, gms_status_length);
	length = gms_status_length;
}

void Magnetic::gms_status_notify() {
	if (gms_status_window)
		gms_status_update();
	else
		gms_status_print();
}

void Magnetic::gms_status_redraw() {
	if (gms_status_window) {
		winid_t parent;

		/*
		 * Rearrange the status window, without changing its actual arrangement
		 * in any way.  This is a hack to work round incorrect window repainting
		 * in Xglk; it forces a complete repaint of affected windows on Glk
		 * window resize and arrange events, and works in part because Xglk
		 * doesn't check for actual arrangement changes in any way before
		 * invalidating its windows.  The hack should be harmless to Glk
		 * libraries other than Xglk, moreover, we're careful to activate it
		 * only on resize and arrange events.
		 */
		parent = glk_window_get_parent(gms_status_window);
		glk_window_set_arrangement(parent,
		                                 winmethod_Above | winmethod_Fixed, 1, NULL);

		gms_status_update();
	}
}

/*---------------------------------------------------------------------*/
/*  Glk port output functions                                          */
/*---------------------------------------------------------------------*/

void Magnetic::gms_output_register_help_request() {
	gms_help_requested = true;
}

void Magnetic::gms_output_silence_help_hints() {
	gms_help_hints_silenced = true;
}

void Magnetic::gms_output_provide_help_hint() {
	if (gms_help_requested && !gms_help_hints_silenced) {
		glk_set_style(style_Emphasized);
		glk_put_string("[Try 'glk help' for help on special interpreter"
		                     " commands]\n");

		gms_help_requested = false;
		glk_set_style(style_Normal);
	}
}

int Magnetic::gms_game_prompted() {
	int result;

	result = gms_output_prompt;
	gms_output_prompt = false;

	return result;
}

void Magnetic::gms_detect_game_prompt() {
	int index;

	gms_output_prompt = false;

	/*
	 * Search for a prompt across any last unterminated buffered line; a prompt
	 * is any non-space character on that line.
	 */
	for (index = gms_output_length - 1;
	        index >= 0 && gms_output_buffer[index] != '\n'; index--) {
		if (gms_output_buffer[index] != ' ') {
			gms_output_prompt = true;
			break;
		}
	}
}

void Magnetic::gms_output_delete() {
	free(gms_output_buffer);
	gms_output_buffer = NULL;
	gms_output_allocation = gms_output_length = 0;
}

void Magnetic::gms_output_flush() {
	assert(glk_stream_get_current());

	if (gms_output_length > 0) {
		/*
		 * See if the game issued a standard prompt, then print the buffer to
		 * the main window.  If providing a help hint, position that before
		 * the game's prompt (if any).
		 */
		gms_detect_game_prompt();
		glk_set_style(style_Normal);

		if (gms_output_prompt) {
			int index;

			for (index = gms_output_length - 1;
			        index >= 0 && gms_output_buffer[index] != '\n';)
				index--;

			glk_put_buffer(gms_output_buffer, index + 1);
			gms_output_provide_help_hint();
			glk_put_buffer(gms_output_buffer + index + 1,
			                     gms_output_length - index - 1);
		} else {
			glk_put_buffer(gms_output_buffer, gms_output_length);
			gms_output_provide_help_hint();
		}

		gms_output_delete();
	}
}

void Magnetic::ms_putchar(type8 c) {
	int bytes;
	assert(gms_output_length <= gms_output_allocation);

	/*
	 * See if the character is a backspace.  Magnetic Scrolls games can send
	 * backspace characters to the display.  We'll need to handle such
	 * characters specially, by taking the last character out of the buffer.
	 */
	if (c == '\b') {
		if (gms_output_length > 0)
			gms_output_length--;

		return;
	}

	/* Grow the output buffer if necessary, then add the character. */
	for (bytes = gms_output_allocation; bytes < gms_output_length + 1;)
		bytes = bytes == 0 ? 1 : bytes << 1;

	if (bytes > gms_output_allocation) {
		gms_output_buffer = (char *)gms_realloc(gms_output_buffer, bytes);
		gms_output_allocation = bytes;
	}

	gms_output_buffer[gms_output_length++] = c;
}

void Magnetic::gms_styled_string(glui32 style, const char *message) {
	assert(message);

	glk_set_style(style);
	glk_put_string(message);
	glk_set_style(style_Normal);
}

void Magnetic::gms_styled_char(glui32 style, char c) {
	char str[2];

	str[0] = c;
	str[1] = '\0';
	gms_styled_string(style, str);
}

void Magnetic::gms_standout_string(const char *message) {
	gms_styled_string(style_Emphasized, message);
}

void Magnetic::gms_normal_string(const char *message) {
	gms_styled_string(style_Normal, message);
}

void Magnetic::gms_normal_char(char c) {
	gms_styled_char(style_Normal, c);
}

void Magnetic::gms_header_string(const char *message) {
	gms_styled_string(style_Header, message);
}

void Magnetic::gms_banner_string(const char *message) {
	gms_styled_string(style_Subheader, message);
}

void Magnetic::ms_flush() {
}

/*---------------------------------------------------------------------*/
/*  Glk port hint functions                                            */
/*---------------------------------------------------------------------*/

type16 Magnetic::gms_get_hint_max_node(const struct ms_hint hints_[], type16 node) {
	const struct ms_hint *hint;
	int index;
	type16 max_node;
	assert(hints_);

	hint = hints_ + node;
	max_node = node;

	switch (hint->nodetype) {
	case GMS_HINT_TYPE_TEXT:
		break;

	case GMS_HINT_TYPE_FOLDER:
		/*
		 * Recursively find the maximum node reference for each link, and keep
		 * the largest value found.
		 */
		for (index = 0; index < hint->elcount; index++) {
			type16 link_max;

			link_max = gms_get_hint_max_node(hints_, hint->links[index]);
			if (link_max > max_node)
				max_node = link_max;
		}
		break;

	default:
		gms_fatal("GLK: Invalid hints_ node type encountered");
		glk_exit();
	}

	/*
	 * Return the largest node reference found, capped to avoid overlapping the
	 * special end-hints_ value.
	 */
	return max_node < GMS_HINTS_DONE ? max_node : GMS_HINTS_DONE - 1;
}

const char *Magnetic::gms_get_hint_content(const struct ms_hint hints_[], type16 node, int number) {
	const struct ms_hint *hint;
	int offset, index;
	assert(hints_);

	hint = hints_ + node;

	/* Run through content until 'number' strings found. */
	offset = 0;
	for (index = 0; index < number; index++)
		offset += strlen(hint->content + offset) + 1;

	/* Return the start of the number'th string encountered. */
	return hint->content + offset;
}

const char *Magnetic::gms_get_hint_topic(const ms_hint hints_[], type16 node) {
	assert(hints_);

	if (node == GMS_HINT_ROOT_NODE) {
		/* If the node is the root node, return a generic string. */
		return GMS_GENERIC_TOPIC;
	} else {
		type16 parent;
		int index;
		const char *topic;

		/*
		 * Search the parent for a link to node, and use that as the hint topic;
		 * NULL if none found.
		 */
		parent = hints_[node].parent;

		topic = NULL;
		for (index = 0; index < hints_[parent].elcount; index++) {
			if (hints_[parent].links[index] == node) {
				topic = gms_get_hint_content(hints_, parent, index);
				break;
			}
		}

		return topic ? topic : GMS_GENERIC_TOPIC;
	}
}

int Magnetic::gms_hint_open() {
	if (!gms_hint_menu_window) {
		assert(!gms_hint_text_window);

		/*
		 * Open the hint menu window.  The initial size is two lines, but we'll
		 * change this later to suit the hint.
		 */
		gms_hint_menu_window = glk_window_open(gms_main_window,
		                       winmethod_Above | winmethod_Fixed,
		                       2, wintype_TextGrid, 0);
		if (!gms_hint_menu_window)
			return false;

		/*
		 * Now open the hints text window.  This is set to be 100% of the size
		 * of the main window, so should cover what remains of it completely.
		 */
		gms_hint_text_window = glk_window_open(gms_main_window,
		                       winmethod_Above
		                       | winmethod_Proportional,
		                       100, wintype_TextBuffer, 0);
		if (!gms_hint_text_window) {
			glk_window_close(gms_hint_menu_window, NULL);
			gms_hint_menu_window = NULL;
			return false;
		}
	}

	return true;
}

void Magnetic::Magnetic::gms_hint_close() {
	if (gms_hint_menu_window) {
		assert(gms_hint_text_window);

		glk_window_close(gms_hint_menu_window, NULL);
		gms_hint_menu_window = NULL;
		glk_window_close(gms_hint_text_window, NULL);
		gms_hint_text_window = NULL;
	}
}

int Magnetic::gms_hint_windows_available() {
	return (gms_hint_menu_window && gms_hint_text_window);
}

void Magnetic::gms_hint_menu_print(int line, int column, const char *string_,
		glui32 width, glui32 height) {
	assert(string_);

	/* Ignore the call if the text position is outside the window. */
	if (!(line > (int)height || column > (int)width)) {
		if (gms_hint_windows_available()) {
			int posn, index;

			glk_window_move_cursor(gms_hint_menu_window, column, line);
			glk_set_window(gms_hint_menu_window);

			/* Write until the end of the string_, or the end of the window. */
			for (posn = column, index = 0;
			        posn < (int)width && index < (int)strlen(string_); posn++, index++) {
				glk_put_char(string_[index]);
			}

			glk_set_window(gms_main_window);
		} else {
			static int current_line = 0;    /* Retained line number */
			static int current_column = 0;  /* Retained col number */

			int index;

			/*
			 * Check the line number against the last one output.  If it is less,
			 * assume the start of a new block.  In this case, perform a hokey
			 * type of screen clear.
			 */
			if (line < current_line) {
				for (index = 0; index < (int)height; index++)
					gms_normal_char('\n');

				current_line = 0;
				current_column = 0;
			}

			/* Print blank lines until the target line is reached. */
			for (; current_line < line; current_line++) {
				gms_normal_char('\n');
				current_column = 0;
			}

			/* Now print spaces until the target column is reached. */
			for (; current_column < column; current_column++)
				gms_normal_char(' ');

			/*
			 * Write characters until the end of the string_, or the end of the
			 * (self-imposed not-really-there) window.
			 */
			for (index = 0;
			        current_column < (int)width && index < (int)strlen(string_);
			        current_column++, index++) {
				gms_normal_char(string_[index]);
			}
		}
	}
}

void Magnetic::gms_hint_menu_header(int line, const char *string_,
		glui32 width, glui32 height) {
	int posn, length;
	assert(string_);

	/* Output the text in the approximate line center. */
	length = strlen(string_);
	posn = length < (int)width ? (width - length) / 2 : 0;
	gms_hint_menu_print(line, posn, string_, width, height);
}

void Magnetic::gms_hint_menu_justify(int line, const char *left_string,
		const char *right_string, glui32 width, glui32 height) {
	int posn, length;
	assert(left_string && right_string);

	/* Write left text normally to window left. */
	gms_hint_menu_print(line, 0, left_string, width, height);

	/* Output the right text flush with the right of the window. */
	length = strlen(right_string);
	posn = length < (int)width ? width - length : 0;
	gms_hint_menu_print(line, posn, right_string, width, height);
}

void Magnetic::gms_hint_text_print(const char *string_) {
	assert(string_);

	if (gms_hint_windows_available()) {
		glk_set_window(gms_hint_text_window);
		glk_put_string(string_);
		glk_set_window(gms_main_window);
	} else
		gms_normal_string(string_);
}

void Magnetic::gms_hint_menutext_start() {
	/*
	 * Twiddle for non-windowing libraries; 'clear' the main window by writing
	 * a null string at line 1, then a null string at line 0.  This works
	 * because we know the current output line in gms_hint_menu_print() is zero,
	 * since we set it that way with gms_hint_menutext_done(), or if this is
	 * the first call, then that's its initial value.
	 */
	if (!gms_hint_windows_available()) {
		gms_hint_menu_print(1, 0, "",
		                    GMS_HINT_DEFAULT_WIDTH, GMS_HINT_DEFAULT_HEIGHT);
		gms_hint_menu_print(0, 0, "",
		                    GMS_HINT_DEFAULT_WIDTH, GMS_HINT_DEFAULT_HEIGHT);
	}
}

void Magnetic::gms_hint_menutext_done() {
	/*
	 * Twiddle for non-windowing libraries; 'clear' the main window by writing
	 * an empty string to line zero.  For windowing Glk libraries, this function
	 * does nothing.
	 */
	if (!gms_hint_windows_available()) {
		gms_hint_menu_print(0, 0, "",
		                    GMS_HINT_DEFAULT_WIDTH, GMS_HINT_DEFAULT_HEIGHT);
	}
}

void Magnetic::gms_hint_menutext_char_event(event_t *event) {
	assert(event);

	if (gms_hint_windows_available()) {
		glk_request_char_event(gms_hint_menu_window);
		glk_request_char_event(gms_hint_text_window);

		gms_event_wait(evtype_CharInput, event);
		assert(event->window == gms_hint_menu_window
		       || event->window == gms_hint_text_window);

		glk_cancel_char_event(gms_hint_menu_window);
		glk_cancel_char_event(gms_hint_text_window);
	} else {
		glk_request_char_event(gms_main_window);
		gms_event_wait(evtype_CharInput, event);
	}
}

void Magnetic::gms_hint_arrange_windows(int requested_lines, glui32 *width, glui32 *height) {
	if (gms_hint_windows_available()) {
		winid_t parent;

		/* Resize the hint menu window to fit the current hint. */
		parent = glk_window_get_parent(gms_hint_menu_window);
		glk_window_set_arrangement(parent,
		                                 winmethod_Above | winmethod_Fixed,
		                                 requested_lines, NULL);

		/* Measure, and return the size of the hint menu window. */
		glk_window_get_size(gms_hint_menu_window, width, height);

		/* Clear both the hint menu and the hint text window. */
		glk_window_clear(gms_hint_menu_window);
		glk_window_clear(gms_hint_text_window);
	} else {
		/*
		 * No hints windows, so default width and height.  The hints output
		 * functions will cope with this.
		 */
		if (width)
			*width = GMS_HINT_DEFAULT_WIDTH;
		if (height)
			*height = GMS_HINT_DEFAULT_HEIGHT;
	}
}

void Magnetic::gms_hint_display_folder(const ms_hint hints_[],
		const int cursor[], type16 node) {
	glui32 width, height;
	int line, index;
	assert(hints_ && cursor);

	/*
	 * Arrange windows to suit the hint folder.  For a folder menu window we
	 * use one line for each element, three for the controls, and two spacers,
	 * making a total of five additional lines.  Width and height receive the
	 * actual menu window dimensions.
	 */
	gms_hint_arrange_windows(hints_[node].elcount + 5, &width, &height);

	/* Paint in the menu header. */
	line = 0;
	gms_hint_menu_header(line++,
	                     gms_get_hint_topic(hints_, node),
	                     width, height);
	gms_hint_menu_justify(line++,
	                      " N = next subject  ", "  P = previous ",
	                      width, height);
	gms_hint_menu_justify(line++,
	                      " RETURN = read subject  ",
	                      node == GMS_HINT_ROOT_NODE
	                      ? "  Q = resume game " : "  Q = previous menu ",
	                      width, height);

	/*
	 * Output a blank line, then the menu for the node's folder hint.  The folder
	 * text for the selected hint is preceded by a '>' pointer.
	 */
	line++;
	for (index = 0; index < hints_[node].elcount; index++) {
		gms_hint_menu_print(line, 3,
		                    index == cursor[node] ? ">" : " ",
		                    width, height);
		gms_hint_menu_print(line++, 5,
		                    gms_get_hint_content(hints_, node, index),
		                    width, height);
	}

	/*
	 * Terminate with a blank line; using a single space here improves cursor
	 * positioning for optimized output libraries (for example, without it,
	 * curses output will leave the cursor at the end of the previous line).
	 */
	gms_hint_menu_print(line, 0, " ", width, height);
}

void Magnetic::gms_hint_display_text(const ms_hint hints_[],
		const int cursor[], type16 node) {
	glui32 width, height;
	int line, index;
	assert(hints_ && cursor);

	/*
	 * Arrange windows to suit the hint text.  For a hint menu, we use a simple
	 * two-line set of controls; everything else is in the hints_ text window.
	 * Width and height receive the actual menu window dimensions.
	 */
	gms_hint_arrange_windows(2, &width, &height);

	/* Paint in a short menu header. */
	line = 0;
	gms_hint_menu_header(line++,
	                     gms_get_hint_topic(hints_, node),
	                     width, height);
	gms_hint_menu_justify(line++,
	                      " RETURN = read hint  ", "  Q = previous menu ",
	                      width, height);

	/*
	 * Output hints_ to the hints_ text window.  hints_ not yet exposed are
	 * indicated by the cursor for the hint, and are displayed as a dash.
	 */
	gms_hint_text_print("\n");
	for (index = 0; index < hints_[node].elcount; index++) {
		char buf[16];

		sprintf(buf, "%3d.  ", index + 1);
		gms_hint_text_print(buf);

		gms_hint_text_print(index < cursor[node]
		                    ? gms_get_hint_content(hints_, node, index) : "-");
		gms_hint_text_print("\n");
	}
}

void Magnetic::gms_hint_display(const ms_hint hints_[], const int cursor[], type16 node) {
	assert(hints_ && cursor);

	switch (hints_[node].nodetype) {
	case GMS_HINT_TYPE_TEXT:
		gms_hint_display_text(hints_, cursor, node);
		break;

	case GMS_HINT_TYPE_FOLDER:
		gms_hint_display_folder(hints_, cursor, node);
		break;

	default:
		gms_fatal("GLK: Invalid hints_ node type encountered");
		glk_exit();
	}
}

type16 Magnetic::gms_hint_handle_folder(const ms_hint hints_[],
		int cursor[], type16 node, glui32 keycode) {
	unsigned char response;
	type16 next_node;
	assert(hints_ && cursor);

	/* Convert key code into a single response character. */
	switch (keycode) {
	case keycode_Down:
		response = 'N';
		break;
	case keycode_Up:
		response = 'P';
		break;
	case keycode_Right:
	case keycode_Return:
		response = '\n';
		break;
	case keycode_Left:
	case keycode_Escape:
		response = 'Q';
		break;
	default:
		response = keycode <= BYTE_MAX ? glk_char_to_upper(keycode) : 0;
		break;
	}

	/*
	 * Now handle the response character.  We'll default the next node to be
	 * this node, but a response case can change it.
	 */
	next_node = node;
	switch (response) {
	case 'N':
		/* Advance the hint cursor, wrapping at the folder end. */
		if (cursor[node] < hints_[node].elcount - 1)
			cursor[node]++;
		else
			cursor[node] = 0;
		break;

	case 'P':
		/* Regress the hint cursor, wrapping at the folder start. */
		if (cursor[node] > 0)
			cursor[node]--;
		else
			cursor[node] = hints_[node].elcount - 1;
		break;

	case '\n':
		/* The next node is the hint node at the cursor position. */
		next_node = hints_[node].links[cursor[node]];
		break;

	case 'Q':
		/* If root, we're done; if not, next node is node's parent. */
		next_node = node == GMS_HINT_ROOT_NODE
		            ? GMS_HINTS_DONE : hints_[node].parent;
		break;

	default:
		break;
	}

	return next_node;
}

type16 Magnetic::gms_hint_handle_text(const ms_hint hints_[],
		int cursor[], type16 node, glui32 keycode) {
	unsigned char response;
	type16 next_node;
	assert(hints_ && cursor);

	/* Convert key code into a single response character. */
	switch (keycode) {
	case keycode_Right:
	case keycode_Return:
		response = '\n';
		break;
	case keycode_Left:
	case keycode_Escape:
		response = 'Q';
		break;
	default:
		response = keycode <= BYTE_MAX ? glk_char_to_upper(keycode) : 0;
		break;
	}

	/*
	 * Now handle the response character.  We'll default the next node to be
	 * this node, but a response case can change it.
	 */
	next_node = node;
	switch (response) {
	case '\n':
		/* If not at end of the hint, advance the hint cursor. */
		if (cursor[node] < hints_[node].elcount)
			cursor[node]++;
		break;

	case 'Q':
		/* Done with this hint node, so next node is its parent. */
		next_node = hints_[node].parent;
		break;

	default:
		break;
	}

	return next_node;
}

type16 Magnetic::gms_hint_handle(const ms_hint hints_[],
		int cursor[], type16 node, glui32 keycode) {
	type16 next_node;
	assert(hints_ && cursor);

	next_node = GMS_HINT_ROOT_NODE;
	switch (hints_[node].nodetype) {
	case GMS_HINT_TYPE_TEXT:
		next_node = gms_hint_handle_text(hints_, cursor, node, keycode);
		break;

	case GMS_HINT_TYPE_FOLDER:
		next_node = gms_hint_handle_folder(hints_, cursor, node, keycode);
		break;

	default:
		gms_fatal("GLK: Invalid hints_ node type encountered");
		glk_exit();
	}

	return next_node;
}

type8 Magnetic::ms_showhints(ms_hint *hints_) {
	type16 hint_count;
	glui32 crc;
	assert(hints_);

	/*
	 * Find the number of hints_ in the array.  To do this, we'll visit every
	 * node in a tree search, starting at the root, to locate the maximum node
	 * number found, then add one to that.  It's a pity that the interpreter
	 * doesn't hand us this information directly.
	 */
	hint_count = gms_get_hint_max_node(hints_, GMS_HINT_ROOT_NODE) + 1;

	/*
	 * Calculate a CRC for the hints_ array data.  If the CRC has changed, or
	 * this is the first call, assign a new cursor array.
	 */
	crc = gms_get_buffer_crc(hints_, hint_count * sizeof(*hints_));
	if (crc != hints_current_crc || !hints_crc_initialized) {
		int bytes;

		/* Allocate new cursors, and set all to zero initial state. */
		free(gms_hint_cursor);
		bytes = hint_count * sizeof(*gms_hint_cursor);
		gms_hint_cursor = (int *)gms_malloc(bytes);
		memset(gms_hint_cursor, 0, bytes);

		/*
		 * Retain the hints_ CRC, for later comparisons, and set is_initialized
		 * flag.
		 */
		hints_current_crc = crc;
		hints_crc_initialized = true;
	}

	/*
	 * Save the hints_ array passed in.  This is done here since even if the data
	 * remains the same (found by the CRC check above), the pointer to it might
	 * have changed.
	 */
	gms_hints = hints_;

	/*
	 * Try to create the hints_ windows.  If they can't be created, perhaps
	 * because the Glk library doesn't support it, the output functions will
	 * work around this.
	 */
	gms_hint_open();
	gms_hint_menutext_start();

	/*
	 * Begin hints_ display at the root node, and navigate until the user exits
	 * hints_.
	 */
	gms_current_hint_node = GMS_HINT_ROOT_NODE;
	while (gms_current_hint_node != GMS_HINTS_DONE) {
		event_t event;

		assert(gms_current_hint_node < hint_count);
		gms_hint_display(gms_hints, gms_hint_cursor, gms_current_hint_node);

		/* Get and handle a character key event for hint navigation. */
		gms_hint_menutext_char_event(&event);
		assert(event.type == evtype_CharInput);
		gms_current_hint_node = gms_hint_handle(gms_hints,
		                                        gms_hint_cursor,
		                                        gms_current_hint_node,
		                                        event.val1);
	}

	/* Done with hint windows. */
	gms_hint_menutext_done();
	gms_hint_close();

	return GMS_HINT_SUCCESS;
}

void Magnetic::gms_hint_redraw() {
	if (gms_hint_windows_available()) {
		assert(gms_hints && gms_hint_cursor);
		gms_hint_display(gms_hints, gms_hint_cursor, gms_current_hint_node);
	}
}

void Magnetic::gms_hints_cleanup() {
	free(gms_hint_cursor);
	gms_hint_cursor = NULL;

	gms_hints = NULL;
	gms_current_hint_node = 0;
}

void Magnetic::ms_playmusic(type8 *midi_data, type32 length, type16 tempo) {
}

/*---------------------------------------------------------------------*/
/*  Glk command escape functions                                       */
/*---------------------------------------------------------------------*/

void Magnetic::gms_command_undo(const char *argument) {
	assert(argument);
}

void Magnetic::gms_command_script(const char *argument) {
	assert(argument);

	if (gms_strcasecmp(argument, "on") == 0) {
		frefid_t fileref;

		if (gms_transcript_stream) {
			gms_normal_string("Glk transcript is already on.\n");
			return;
		}

		fileref = glk_fileref_create_by_prompt(fileusage_Transcript
		          | fileusage_TextMode,
		          filemode_WriteAppend, 0);
		if (!fileref) {
			gms_standout_string("Glk transcript failed.\n");
			return;
		}

		gms_transcript_stream = glk_stream_open_file(fileref,
		                        filemode_WriteAppend, 0);
		glk_fileref_destroy(fileref);
		if (!gms_transcript_stream) {
			gms_standout_string("Glk transcript failed.\n");
			return;
		}

		glk_window_set_echo_stream(gms_main_window, gms_transcript_stream);

		gms_normal_string("Glk transcript is now on.\n");
	}

	else if (gms_strcasecmp(argument, "off") == 0) {
		if (!gms_transcript_stream) {
			gms_normal_string("Glk transcript is already off.\n");
			return;
		}

		glk_stream_close(gms_transcript_stream, NULL);
		gms_transcript_stream = NULL;

		glk_window_set_echo_stream(gms_main_window, NULL);

		gms_normal_string("Glk transcript is now off.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk transcript is ");
		gms_normal_string(gms_transcript_stream ? "on" : "off");
		gms_normal_string(".\n");
	}

	else {
		gms_normal_string("Glk transcript can be ");
		gms_standout_string("on");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_inputlog(const char *argument) {
	assert(argument);

	if (gms_strcasecmp(argument, "on") == 0) {
		frefid_t fileref;

		if (gms_inputlog_stream) {
			gms_normal_string("Glk input logging is already on.\n");
			return;
		}

		fileref = glk_fileref_create_by_prompt(fileusage_InputRecord
		          | fileusage_BinaryMode,
		          filemode_WriteAppend, 0);
		if (!fileref) {
			gms_standout_string("Glk input logging failed.\n");
			return;
		}

		gms_inputlog_stream = glk_stream_open_file(fileref,
		                      filemode_WriteAppend, 0);
		glk_fileref_destroy(fileref);
		if (!gms_inputlog_stream) {
			gms_standout_string("Glk input logging failed.\n");
			return;
		}

		gms_normal_string("Glk input logging is now on.\n");
	}

	else if (gms_strcasecmp(argument, "off") == 0) {
		if (!gms_inputlog_stream) {
			gms_normal_string("Glk input logging is already off.\n");
			return;
		}

		glk_stream_close(gms_inputlog_stream, NULL);
		gms_inputlog_stream = NULL;

		gms_normal_string("Glk input log is now off.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk input logging is ");
		gms_normal_string(gms_inputlog_stream ? "on" : "off");
		gms_normal_string(".\n");
	}

	else {
		gms_normal_string("Glk input logging can be ");
		gms_standout_string("on");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_readlog(const char *argument) {
	assert(argument);

	if (gms_strcasecmp(argument, "on") == 0) {
		frefid_t fileref;

		if (gms_readlog_stream) {
			gms_normal_string("Glk read log is already on.\n");
			return;
		}

		fileref = glk_fileref_create_by_prompt(fileusage_InputRecord
		          | fileusage_BinaryMode,
		          filemode_Read, 0);
		if (!fileref) {
			gms_standout_string("Glk read log failed.\n");
			return;
		}

		if (!glk_fileref_does_file_exist(fileref)) {
			glk_fileref_destroy(fileref);
			gms_standout_string("Glk read log failed.\n");
			return;
		}

		gms_readlog_stream = glk_stream_open_file(fileref, filemode_Read, 0);
		glk_fileref_destroy(fileref);
		if (!gms_readlog_stream) {
			gms_standout_string("Glk read log failed.\n");
			return;
		}

		gms_normal_string("Glk read log is now on.\n");
	}

	else if (gms_strcasecmp(argument, "off") == 0) {
		if (!gms_readlog_stream) {
			gms_normal_string("Glk read log is already off.\n");
			return;
		}

		glk_stream_close(gms_readlog_stream, NULL);
		gms_readlog_stream = NULL;

		gms_normal_string("Glk read log is now off.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk read log is ");
		gms_normal_string(gms_readlog_stream ? "on" : "off");
		gms_normal_string(".\n");
	}

	else {
		gms_normal_string("Glk read log can be ");
		gms_standout_string("on");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_abbreviations(const char *argument) {
	assert(argument);

	if (gms_strcasecmp(argument, "on") == 0) {
		if (gms_abbreviations_enabled) {
			gms_normal_string("Glk abbreviation expansions are already on.\n");
			return;
		}

		gms_abbreviations_enabled = true;
		gms_normal_string("Glk abbreviation expansions are now on.\n");
	}

	else if (gms_strcasecmp(argument, "off") == 0) {
		if (!gms_abbreviations_enabled) {
			gms_normal_string("Glk abbreviation expansions are already off.\n");
			return;
		}

		gms_abbreviations_enabled = false;
		gms_normal_string("Glk abbreviation expansions are now off.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk abbreviation expansions are ");
		gms_normal_string(gms_abbreviations_enabled ? "on" : "off");
		gms_normal_string(".\n");
	}

	else {
		gms_normal_string("Glk abbreviation expansions can be ");
		gms_standout_string("on");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_graphics(const char *argument) {
	assert(argument);

	if (!gms_graphics_possible) {
		gms_normal_string("Glk graphics are not available.\n");
		return;
	}

	if (gms_strcasecmp(argument, "on") == 0) {
		if (gms_graphics_enabled) {
			gms_normal_string("Glk graphics are already on.\n");
			return;
		}

		gms_graphics_enabled = true;

		/* If a picture is loaded, call the restart function to repaint it. */
		if (gms_graphics_picture_is_available()) {
			if (!gms_graphics_open()) {
				gms_normal_string("Glk graphics error.\n");
				return;
			}
			gms_graphics_restart();
		}

		gms_normal_string("Glk graphics are now on.\n");
	}

	else if (gms_strcasecmp(argument, "off") == 0) {
		if (!gms_graphics_enabled) {
			gms_normal_string("Glk graphics are already off.\n");
			return;
		}

		/*
		 * Set graphics to disabled, and stop any graphics processing.  Close
		 * the graphics window.
		 */
		gms_graphics_enabled = false;
		gms_graphics_stop();
		gms_graphics_close();

		gms_normal_string("Glk graphics are now off.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk graphics are available,");
		gms_normal_string(gms_graphics_enabled
		                  ? " and enabled.\n" : " but disabled.\n");

		if (gms_graphics_picture_is_available()) {
			int width, height, is_animated;

			if (gms_graphics_get_picture_details(&width, &height, &is_animated)) {
				char buf[16];

				gms_normal_string("There is ");
				gms_normal_string(is_animated ? "an animated" : "a");
				gms_normal_string(" picture loaded, ");

				sprintf(buf, "%d", width);
				gms_normal_string(buf);
				gms_normal_string(" by ");

				sprintf(buf, "%d", height);
				gms_normal_string(buf);

				gms_normal_string(" pixels.\n");
			}
		}

		if (!gms_graphics_interpreter_enabled())
			gms_normal_string("Interpreter graphics are disabled.\n");

		if (gms_graphics_enabled && gms_graphics_are_displayed()) {
			int color_count, is_active;
			const char *gamma;

			if (gms_graphics_get_rendering_details(&gamma, &color_count,
			                                       &is_active)) {
				char buf[16];

				gms_normal_string("Graphics are ");
				gms_normal_string(is_active ? "active, " : "displayed, ");

				sprintf(buf, "%d", color_count);
				gms_normal_string(buf);
				gms_normal_string(" colours");

				if (gms_gamma_mode == GAMMA_OFF)
					gms_normal_string(", without gamma correction");
				else {
					gms_normal_string(", with gamma ");
					gms_normal_string(gamma);
					gms_normal_string(" correction");
				}
				gms_normal_string(".\n");
			} else
				gms_normal_string("Graphics are being displayed.\n");
		}

		if (gms_graphics_enabled && !gms_graphics_are_displayed())
			gms_normal_string("Graphics are not being displayed.\n");
	}

	else {
		gms_normal_string("Glk graphics can be ");
		gms_standout_string("on");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_gamma(const char *argument) {
	assert(argument);

	if (!gms_graphics_possible) {
		gms_normal_string("Glk automatic gamma correction is not available.\n");
		return;
	}

	if (gms_strcasecmp(argument, "high") == 0) {
		if (gms_gamma_mode == GAMMA_HIGH) {
			gms_normal_string("Glk automatic gamma correction mode is"
			                  " already 'high'.\n");
			return;
		}

		gms_gamma_mode = GAMMA_HIGH;
		gms_graphics_restart();

		gms_normal_string("Glk automatic gamma correction mode is"
		                  " now 'high'.\n");
	}

	else if (gms_strcasecmp(argument, "normal") == 0
	         || gms_strcasecmp(argument, "on") == 0) {
		if (gms_gamma_mode == GAMMA_NORMAL) {
			gms_normal_string("Glk automatic gamma correction mode is"
			                  " already 'normal'.\n");
			return;
		}

		gms_gamma_mode = GAMMA_NORMAL;
		gms_graphics_restart();

		gms_normal_string("Glk automatic gamma correction mode is"
		                  " now 'normal'.\n");
	}

	else if (gms_strcasecmp(argument, "none") == 0
	         || gms_strcasecmp(argument, "off") == 0) {
		if (gms_gamma_mode == GAMMA_OFF) {
			gms_normal_string("Glk automatic gamma correction mode is"
			                  " already 'off'.\n");
			return;
		}

		gms_gamma_mode = GAMMA_OFF;
		gms_graphics_restart();

		gms_normal_string("Glk automatic gamma correction mode is"
		                  " now 'off'.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk automatic gamma correction mode is '");
		switch (gms_gamma_mode) {
		case GAMMA_OFF:
			gms_normal_string("off");
			break;
		case GAMMA_NORMAL:
			gms_normal_string("normal");
			break;
		case GAMMA_HIGH:
			gms_normal_string("high");
			break;
		}
		gms_normal_string("'.\n");
	}

	else {
		gms_normal_string("Glk automatic gamma correction mode can be ");
		gms_standout_string("high");
		gms_normal_string(", ");
		gms_standout_string("normal");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_animations(const char *argument) {
	assert(argument);

	if (!gms_graphics_possible) {
		gms_normal_string("Glk graphics animations are not available.\n");
		return;
	}

	if (gms_strcasecmp(argument, "on") == 0) {
		int is_animated;

		if (gms_animation_enabled) {
			gms_normal_string("Glk graphics animations are already on.\n");
			return;
		}

		/*
		 * Set animation to on, and restart graphics if the current picture
		 * is animated; if it isn't, we can leave it displayed as is, since
		 * changing animation mode doesn't affect this picture.
		 */
		gms_animation_enabled = true;
		if (gms_graphics_get_picture_details(NULL, NULL, &is_animated)) {
			if (is_animated)
				gms_graphics_restart();
		}

		gms_normal_string("Glk graphics animations are now on.\n");
	}

	else if (gms_strcasecmp(argument, "off") == 0) {
		int is_animated;

		if (!gms_animation_enabled) {
			gms_normal_string("Glk graphics animations are already off.\n");
			return;
		}

		gms_animation_enabled = false;
		if (gms_graphics_get_picture_details(NULL, NULL, &is_animated)) {
			if (is_animated)
				gms_graphics_restart();
		}

		gms_normal_string("Glk graphics animations are now off.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk graphics animations are ");
		gms_normal_string(gms_animation_enabled ? "on" : "off");
		gms_normal_string(".\n");
	}

	else {
		gms_normal_string("Glk graphics animations can be ");
		gms_standout_string("on");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_prompts(const char *argument) {
	assert(argument);

	if (gms_strcasecmp(argument, "on") == 0) {
		if (gms_prompt_enabled) {
			gms_normal_string("Glk extra prompts are already on.\n");
			return;
		}

		gms_prompt_enabled = true;
		gms_normal_string("Glk extra prompts are now on.\n");

		/* Check for a game prompt to clear the flag. */
		gms_game_prompted();
	}

	else if (gms_strcasecmp(argument, "off") == 0) {
		if (!gms_prompt_enabled) {
			gms_normal_string("Glk extra prompts are already off.\n");
			return;
		}

		gms_prompt_enabled = false;
		gms_normal_string("Glk extra prompts are now off.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk extra prompts are ");
		gms_normal_string(gms_prompt_enabled ? "on" : "off");
		gms_normal_string(".\n");
	}

	else {
		gms_normal_string("Glk extra prompts can be ");
		gms_standout_string("on");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_print_version_number(glui32 version_) {
	Common::String str = Common::String::format("%lu.%lu.%lu",
	        (unsigned long)version_ >> 16,
	        (unsigned long)(version_ >> 8) & 0xff,
	        (unsigned long)version_ & 0xff);
	gms_normal_string(str.c_str());
}

void Magnetic::gms_command_version(const char *argument) {
	glui32 version_;
	assert(argument);

	gms_normal_string("This is version_ ");
	gms_command_print_version_number(GMS_PORT_VERSION);
	gms_normal_string(" of the Glk Magnetic port.\n");

	version_ = glk_gestalt(gestalt_Version, 0);
	gms_normal_string("The Glk library version_ is ");
	gms_command_print_version_number(version_);
	gms_normal_string(".\n");
}

void Magnetic::gms_command_commands(const char *argument) {
	assert(argument);

	if (gms_strcasecmp(argument, "on") == 0) {
		gms_normal_string("Glk commands are already on.\n");
	}

	else if (gms_strcasecmp(argument, "off") == 0) {
		gms_commands_enabled = false;
		gms_normal_string("Glk commands are now off.\n");
	}

	else if (strlen(argument) == 0) {
		gms_normal_string("Glk commands are ");
		gms_normal_string(gms_commands_enabled ? "on" : "off");
		gms_normal_string(".\n");
	}

	else {
		gms_normal_string("Glk commands can be ");
		gms_standout_string("on");
		gms_normal_string(", or ");
		gms_standout_string("off");
		gms_normal_string(".\n");
	}
}

void Magnetic::gms_command_summary(const char *argument) {
	const gms_command_t *entry;
	assert(argument);

	/*
	 * Call handlers that have status to report with an empty argument,
	 * prompting each to print its current setting.
	 */
	for (entry = GMS_COMMAND_TABLE; entry->command; entry++) {
		if (entry->handler == &Magnetic::gms_command_summary
		        || entry->handler == &Magnetic::gms_command_undo
		        || entry->handler == &Magnetic::gms_command_help)
			continue;

		(this->*entry->handler)("");
	}
}

void Magnetic::gms_command_help(const char *command) {
	const gms_command_t *entry, *matched;
	assert(command);

	if (strlen(command) == 0) {
		gms_normal_string("Glk commands are");
		for (entry = GMS_COMMAND_TABLE; entry->command; entry++) {
			const gms_command_t *next;

			next = entry + 1;
			gms_normal_string(next->command ? " " : " and ");
			gms_standout_string(entry->command);
			gms_normal_string(next->command ? "," : ".\n\n");
		}

		gms_normal_string("Glk commands may be abbreviated, as long as"
		                  " the abbreviation is unambiguous.  Use ");
		gms_standout_string("glk help");
		gms_normal_string(" followed by a Glk command name for help on that"
		                  " command.\n");
		return;
	}

	matched = NULL;
	for (entry = GMS_COMMAND_TABLE; entry->command; entry++) {
		if (gms_strncasecmp(command, entry->command, strlen(command)) == 0) {
			if (matched) {
				gms_normal_string("The Glk command ");
				gms_standout_string(command);
				gms_normal_string(" is ambiguous.  Try ");
				gms_standout_string("glk help");
				gms_normal_string(" for more information.\n");
				return;
			}
			matched = entry;
		}
	}
	if (!matched) {
		gms_normal_string("The Glk command ");
		gms_standout_string(command);
		gms_normal_string(" is not valid.  Try ");
		gms_standout_string("glk help");
		gms_normal_string(" for more information.\n");
		return;
	}

	if (matched->handler == &Magnetic::gms_command_summary) {
		gms_normal_string("Prints a summary of all the current Glk Magnetic"
		                  " settings.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_undo) {
		gms_normal_string("Undoes a single game turn.\n\nEquivalent to the"
		                  " standalone game 'undo' command.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_script) {
		gms_normal_string("Logs the game's output to a file.\n\nUse ");
		gms_standout_string("glk script on");
		gms_normal_string(" to begin logging game output, and ");
		gms_standout_string("glk script off");
		gms_normal_string(" to end it.  Glk Magnetic will ask you for a file"
		                  " when you turn scripts on.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_inputlog) {
		gms_normal_string("Records the commands you type into a game.\n\nUse ");
		gms_standout_string("glk inputlog on");
		gms_normal_string(", to begin recording your commands, and ");
		gms_standout_string("glk inputlog off");
		gms_normal_string(" to turn off input logs.  You can play back"
		                  " recorded commands into a game with the ");
		gms_standout_string("glk readlog");
		gms_normal_string(" command.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_readlog) {
		gms_normal_string("Plays back commands recorded with ");
		gms_standout_string("glk inputlog on");
		gms_normal_string(".\n\nUse ");
		gms_standout_string("glk readlog on");
		gms_normal_string(".  Command play back stops at the end of the"
		                  " file.  You can also play back commands from a"
		                  " text file created using any standard editor.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_abbreviations) {
		gms_normal_string("Controls abbreviation expansion.\n\nGlk Magnetic"
		                  " automatically expands several standard single"
		                  " letter abbreviations for you; for example, \"x\""
		                  " becomes \"examine\".  Use ");
		gms_standout_string("glk abbreviations on");
		gms_normal_string(" to turn this feature on, and ");
		gms_standout_string("glk abbreviations off");
		gms_normal_string(" to turn it off.  While the feature is on, you"
		                  " can bypass abbreviation expansion for an"
		                  " individual game command by prefixing it with a"
		                  " single quote.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_graphics) {
		gms_normal_string("Turns interpreter graphics on and off.\n\nUse ");
		gms_standout_string("glk graphics on");
		gms_normal_string(" to enable interpreter graphics, and ");
		gms_standout_string("glk graphics off");
		gms_normal_string(" to turn graphics off and close the graphics window."
		                  "  This control works slightly differently to the"
		                  " 'graphics' command in Magnetic Windows and Magnetic"
		                  " Scrolls games themselves; the game's 'graphics'"
		                  " command may disable new images, but leave old ones"
		                  " displayed.  For graphics to be displayed, they"
		                  " must be turned on in both the game and the"
		                  " interpreter.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_gamma) {
		gms_normal_string("Sets the level of automatic gamma correction applied"
		                  " to game graphics.\n\nUse ");
		gms_standout_string("glk gamma normal");
		gms_normal_string(" to set moderate automatic colour contrast"
		                  " correction, ");
		gms_standout_string("glk gamma high");
		gms_normal_string(" to set high automatic colour contrast correction,"
		                  " or ");
		gms_standout_string("glk gamma off");
		gms_normal_string(" to turn off all automatic gamma correction.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_animations) {
		gms_normal_string("Turns graphic animations on and off.\n\nUse ");
		gms_standout_string("glk animation on");
		gms_normal_string(" to enable animations, or ");
		gms_standout_string("glk animation off");
		gms_normal_string(" to turn animations off.  Not all game graphics are"
		                  " animated, so this control works only on graphics"
		                  " that are animated.  When animation is off, Glk"
		                  " Magnetic displays only the static portions of a"
		                  " game's pictures.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_prompts) {
		gms_normal_string("Controls extra input prompting.\n\n"
		                  "Glk Magnetic can issue a replacement '>' input"
		                  " prompt if it detects that the game hasn't prompted"
		                  " after, say, an empty input line.  Use ");
		gms_standout_string("glk prompts on");
		gms_normal_string(" to turn this feature on, and ");
		gms_standout_string("glk prompts off");
		gms_normal_string(" to turn it off.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_version) {
		gms_normal_string("Prints the version numbers of the Glk library"
		                  " and the Glk Magnetic port.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_commands) {
		gms_normal_string("Turn off Glk commands.\n\nUse ");
		gms_standout_string("glk commands off");
		gms_normal_string(" to disable all Glk commands, including this one."
		                  "  Once turned off, there is no way to turn Glk"
		                  " commands back on while inside the game.\n");
	}

	else if (matched->handler == &Magnetic::gms_command_help)
		gms_command_help("");

	else
		gms_normal_string("There is no help available on that Glk command."
		                  "  Sorry.\n");
}

int Magnetic::gms_command_escape(const char *string_, int *undo_command) {
	int posn;
	char *string_copy, *command, *argument;
	assert(string_ && undo_command);

	/*
	 * Return false if the string doesn't begin with the Glk command escape
	 * introducer.
	 */
	posn = strspn(string_, "\t ");
	if (gms_strncasecmp(string_ + posn, "glk", strlen("glk")) != 0)
		return false;

	/* Take a copy of the string_, without any leading space or introducer. */
	string_copy = (char *)gms_malloc(strlen(string_ + posn) + 1 - strlen("glk"));
	strcpy(string_copy, string_ + posn + strlen("glk"));

	/*
	 * Find the subcommand; the first word in the string copy.  Find its end,
	 * and ensure it terminates with a NUL.
	 */
	posn = strspn(string_copy, "\t ");
	command = string_copy + posn;
	posn += strcspn(string_copy + posn, "\t ");
	if (string_copy[posn] != '\0')
		string_copy[posn++] = '\0';

	/*
	 * Now find any argument data for the command, ensuring it too terminates
	 * with a NUL.
	 */
	posn += strspn(string_copy + posn, "\t ");
	argument = string_copy + posn;
	posn += strcspn(string_copy + posn, "\t ");
	string_copy[posn] = '\0';

	/*
	 * Try to handle the command and argument as a Glk subcommand.  If it
	 * doesn't run unambiguously, print command usage.  Treat an empty command
	 * as "help".
	 */
	if (strlen(command) > 0) {
		const gms_command_t *entry, *matched;
		int matches;

		/*
		 * Search for the first unambiguous table command string_ matching
		 * the command passed in.
		 */
		matches = 0;
		matched = NULL;
		for (entry = GMS_COMMAND_TABLE; entry->command; entry++) {
			if (gms_strncasecmp(command, entry->command, strlen(command)) == 0) {
				matches++;
				matched = entry;
			}
		}

		/* If the match was unambiguous, call the command handler. */
		if (matches == 1) {
			if (!matched->undo_return)
				gms_normal_char('\n');
			(this->*(matched->handler))(argument);

			if (!matched->takes_argument && strlen(argument) > 0) {
				gms_normal_string("[The ");
				gms_standout_string(matched->command);
				gms_normal_string(" command ignores arguments.]\n");
			}

			*undo_command = matched->undo_return;
		}

		/* No match, or the command was ambiguous. */
		else {
			gms_normal_string("\nThe Glk command ");
			gms_standout_string(command);
			gms_normal_string(" is ");
			gms_normal_string(matches == 0 ? "not valid" : "ambiguous");
			gms_normal_string(".  Try ");
			gms_standout_string("glk help");
			gms_normal_string(" for more information.\n");
		}
	} else {
		gms_normal_char('\n');
		gms_command_help("");
	}

	/* The string_ contained a Glk command; return true. */
	free(string_copy);
	return true;
}

int Magnetic::gms_command_undo_special(const char *string_) {
	int posn, end;
	assert(string_);

	/* Find the start and end of the first string_ word. */
	posn = strspn(string_, "\t ");
	end = posn + strcspn(string_ + posn, "\t ");

	/* See if string_ contains an "undo" request, with nothing following. */
	if (end - posn == (int)strlen("undo")
	        && gms_strncasecmp(string_ + posn, "undo", end - posn) == 0) {
		posn = end + strspn(string_ + end, "\t ");
		if (string_[posn] == '\0')
			return true;
	}

	return false;
}

/*---------------------------------------------------------------------*/
/*  Glk port input functions                                           */
/*---------------------------------------------------------------------*/

void Magnetic::gms_expand_abbreviations(char *buffer_, int size) {
	char *command, abbreviation;
	const char *expansion;
	gms_abbreviationref_t entry;
	assert(buffer_);

	/* Ignore anything that isn't a single letter command. */
	command = buffer_ + strspn(buffer_, "\t ");
	if (!(strlen(command) == 1
	        || (strlen(command) > 1 && Common::isSpace(command[1]))))
		return;

	/* Scan the abbreviations table for a match. */
	abbreviation = glk_char_to_lower((unsigned char) command[0]);
	expansion = NULL;
	for (entry = GMS_ABBREVIATIONS; entry->expansion; entry++) {
		if (entry->abbreviation == abbreviation) {
			expansion = entry->expansion;
			break;
		}
	}

	/*
	 * If a match found, check for a fit, then replace the character with the
	 * expansion string.
	 */
	if (expansion) {
		if ((int)(strlen(buffer_) + strlen(expansion)) - 1 >= size)
			return;

		memmove(command + strlen(expansion) - 1, command, strlen(command) + 1);
		memcpy(command, expansion, strlen(expansion));

#if 0
		gms_standout_string("[");
		gms_standout_char(abbreviation);
		gms_standout_string(" -> ");
		gms_standout_string(expansion);
		gms_standout_string("]\n");
#endif
	}
}

void Magnetic::gms_buffer_input() {
	event_t event;

	/*
	 * Update the current status line display, and flush any pending buffered
	 * output.
	 */
	gms_status_notify();
	gms_output_flush();

	/*
	 * Magnetic Windows games tend not to issue a prompt after reading an empty
	 * line of input.  This can make for a very blank looking screen.
	 *
	 * To slightly improve things, if it looks like we didn't get a prompt from
	 * the game, do our own.
	 */
	if (gms_prompt_enabled && !gms_game_prompted()) {
		gms_normal_char('\n');
		gms_normal_string(GMS_INPUT_PROMPT);
	}

	/*
	 * If we have an input log to read from, use that until it is exhausted.  On
	 * end of file, close the stream and resume input from line requests.
	 */
	if (gms_readlog_stream) {
		glui32 chars;

		/* Get the next line from the log stream. */
		chars = glk_get_line_stream(gms_readlog_stream,
		                                  gms_input_buffer, sizeof(gms_input_buffer));
		if (chars > 0) {
			/* Echo the line just read in input style. */
			glk_set_style(style_Input);
			glk_put_buffer(gms_input_buffer, chars);
			glk_set_style(style_Normal);

			/* Note how many characters buffered, and return. */
			gms_input_length = chars;
			return;
		}

		/*
		 * We're at the end of the log stream.  Close it, and then continue
		 * on to request a line from Glk.
		 */
		glk_stream_close(gms_readlog_stream, NULL);
		gms_readlog_stream = NULL;
	}

	/*
	 * No input log being read, or we just hit the end of file on one.  Revert
	 * to normal line input; start by getting a new line from Glk.
	 */
	glk_request_line_event(gms_main_window,
	                             gms_input_buffer, sizeof(gms_input_buffer) - 1, 0);
	gms_event_wait(evtype_LineInput, &event);
	if (shouldQuit()) {
		glk_cancel_line_event(gms_main_window, &event);
		return;
	}

	/* Terminate the input line with a NUL. */
	assert(event.val1 <= sizeof(gms_input_buffer) - 1);
	gms_input_buffer[event.val1] = '\0';

	/* Special handling for "undo" commands. */
	if (gms_command_undo_special(gms_input_buffer)) {
		/* Write the "undo" to any input log. */
		if (gms_inputlog_stream) {
			glk_put_string_stream(gms_inputlog_stream, gms_input_buffer);
			glk_put_char_stream(gms_inputlog_stream, '\n');
		}

		/* Overwrite buffer with an empty line if we saw "undo". */
		gms_input_buffer[0] = '\n';
		gms_input_length = 1;

		gms_undo_notification = true;
		return;
	}

	/*
	 * If neither abbreviations nor local commands are enabled, use the data
	 * read above without further massaging.
	 */
	if (gms_abbreviations_enabled || gms_commands_enabled) {
		char *command;

		/*
		 * If the first non-space input character is a quote, bypass all
		 * abbreviation expansion and local command recognition, and use the
		 * unadulterated input, less introductory quote.
		 */
		command = gms_input_buffer + strspn(gms_input_buffer, "\t ");
		if (command[0] == '\'') {
			/* Delete the quote with memmove(). */
			memmove(command, command + 1, strlen(command));
		} else {
			/* Check for, and expand, any abbreviated commands. */
			if (gms_abbreviations_enabled) {
				gms_expand_abbreviations(gms_input_buffer,
				                         sizeof(gms_input_buffer));
			}

			/*
			 * Check for standalone "help", then for Glk port special commands;
			 * suppress the interpreter's use of this input for Glk commands
			 * by overwriting the line with a single newline character.
			 */
			if (gms_commands_enabled) {
				int posn;

				posn = strspn(gms_input_buffer, "\t ");
				if (gms_strncasecmp(gms_input_buffer + posn,
				                    "help", strlen("help")) == 0) {
					if (strspn(gms_input_buffer + posn + strlen("help"), "\t ")
					        == strlen(gms_input_buffer + posn + strlen("help"))) {
						gms_output_register_help_request();
					}
				}

				if (gms_command_escape(gms_input_buffer,
				                       &gms_undo_notification)) {
					gms_output_silence_help_hints();
					gms_input_buffer[0] = '\n';
					gms_input_length = 1;
					return;
				}
			}
		}
	}

	/*
	 * If there is an input log active, log this input string to it.  Note that
	 * by logging here we get any abbreviation expansions but we won't log glk
	 * special commands, nor any input read from a current open input log.
	 */
	if (gms_inputlog_stream) {
		glk_put_string_stream(gms_inputlog_stream, gms_input_buffer);
		glk_put_char_stream(gms_inputlog_stream, '\n');
	}

	/*
	 * Now append a newline to the buffer, since Glk line input doesn't provide
	 * one, and in any case, abbreviation expansion may have edited the buffer
	 * contents (and in particular, changed the length).
	 */
	gms_input_buffer[strlen(gms_input_buffer) + 1] = '\0';
	gms_input_buffer[strlen(gms_input_buffer)] = '\n';

	/* Note how many characters are buffered after all of the above. */
	gms_input_length = strlen(gms_input_buffer);
}

type8 Magnetic::ms_getchar(type8 trans) {
	/* See if we are at the end of the input buffer. */
	if (gms_input_cursor == gms_input_length) {
		/*
		 * Try to read in more data, and rewind buffer cursor.  As well as
		 * reading input, this may set an undo notification.
		 */
		gms_buffer_input();
		gms_input_cursor = 0;

		if (shouldQuit())
			return '\0';
		
		if (gms_undo_notification) {
			/*
			 * Clear the undo notification, and discard buffered input (usually
			 * just the '\n' placed there when the undo command was recognized).
			 */
			gms_undo_notification = false;
			gms_input_length = 0;

			/*
			 * Return the special 0, or a blank line if no undo is allowed at
			 * this point.
			 */
			return trans ? 0 : '\n';
		}
	}

	/* Return the next character from the input buffer. */
	assert(gms_input_cursor < gms_input_length);
	return gms_input_buffer[gms_input_cursor++];
}

/*---------------------------------------------------------------------*/
/*  Glk port event functions                                           */
/*---------------------------------------------------------------------*/

void Magnetic::gms_event_wait(glui32 wait_type, event_t *event) {
	assert(event);

	do {
		glk_select(event);

		switch (event->type) {
		case evtype_Arrange:
		case evtype_Redraw:
			/* Refresh any sensitive windows on size events. */
			gms_status_redraw();
			gms_hint_redraw();
			gms_graphics_paint();
			break;

		case evtype_Timer:
			/* Do background graphics updates on timeout. */
			gms_graphics_timeout();
			break;

		case evtype_Quit:
			return;

		default:
			break;
		}
	} while (event->type != (EvType)wait_type);
}

/*---------------------------------------------------------------------*/
/*  Functions intercepted by link-time wrappers                        */
/*---------------------------------------------------------------------*/

int Magnetic::__wrap_toupper(int ch) {
	unsigned char uch;

	uch = glk_char_to_upper((unsigned char) ch);
	return (int) uch;
}

int Magnetic::__wrap_tolower(int ch) {
	unsigned char lch;

	lch = glk_char_to_lower((unsigned char) ch);
	return (int) lch;
}

/*---------------------------------------------------------------------*/
/*  main() and options parsing                                         */
/*---------------------------------------------------------------------*/

void Magnetic::gms_establish_filenames(const char *name, char **text, char **graphics, char **hints_) {
	char *base, *text_file, *graphics_file, *hints_file;
	Common::File stream;
	assert(name && text && graphics && hints_);

	/* Take a destroyable copy of the input filename. */
	base = (char *)gms_malloc(strlen(name) + 1);
	strcpy(base, name);

	/* If base has an extension .MAG, .GFX, or .HNT, remove it. */
	if (strlen(base) > strlen(".XXX")) {
		if (gms_strcasecmp(base + strlen(base) - strlen(".MAG"), ".MAG") == 0
		        || gms_strcasecmp(base + strlen(base) - strlen(".GFX"), ".GFX") == 0
		        || gms_strcasecmp(base + strlen(base) - strlen(".HNT"), ".HNT") == 0)
			base[strlen(base) - strlen(".XXX")] = '\0';
	}

	/* Allocate space for the return text file. */
	text_file = (char *)gms_malloc(strlen(base) + strlen(".MAG") + 1);

	/* Form a candidate text file, by adding a .MAG extension. */
	strcpy(text_file, base);
	strcat(text_file, ".MAG");

	if (!stream.open(text_file)) {
		/* Retry, using a .mag extension instead. */
		strcpy(text_file, base);
		strcat(text_file, ".mag");

		if (!stream.open(text_file)) {
			/*
			 * No access to a usable game text file.  Return immediately,
			 * without looking for any associated graphics or hints_ files.
			 */
			*text = NULL;
			*graphics = NULL;
			*hints_ = NULL;

			free(text_file);
			free(base);
			return;
		}
	}
	stream.close();

	/* Now allocate space for the return graphics file. */
	graphics_file = (char *)gms_malloc(strlen(base) + strlen(".GFX") + 1);

	/* As above, form a candidate graphics file, using a .GFX extension. */
	strcpy(graphics_file, base);
	strcat(graphics_file, ".GFX");

	if (!stream.open(graphics_file)) {
		/* Retry, using a .gfx extension instead. */
		strcpy(graphics_file, base);
		strcat(graphics_file, ".gfx");

		if (!stream.open(graphics_file)) {
			/*
			 * No access to any graphics file.  In this case, free memory and
			 * reset graphics file to NULL.
			 */
			free(graphics_file);
			graphics_file = NULL;
		}
	}
	stream.close();

	/* Now allocate space for the return hints_ file. */
	hints_file = (char *)gms_malloc(strlen(base) + strlen(".HNT") + 1);

	/* As above, form a candidate graphics file, using a .HNT extension. */
	strcpy(hints_file, base);
	strcat(hints_file, ".HNT");

	if (!stream.open(hints_file)) {
		/* Retry, using a .hnt extension instead. */
		strcpy(hints_file, base);
		strcat(hints_file, ".hnt");

		if (!stream.open(hints_file)) {
			/*
			 * No access to any hints_ file.  In this case, free memory and
			 * reset hints_ file to NULL.
			 */
			free(hints_file);
			hints_file = NULL;
		}
	}
	stream.close();

	/* Return the text file, and graphics and hints_, which may be NULL. */
	*text = text_file;
	*graphics = graphics_file;
	*hints_ = hints_file;

	free(base);
}

void Magnetic::gms_main() {
	char *text_file = NULL, *graphics_file = NULL, *hints_file = NULL;
	int ms_init_status, is_running;

	/* Create the main Glk window, and set its stream as current. */
	gms_main_window = glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
	if (!gms_main_window) {
		gms_fatal("GLK: Can't open main window");
		glk_exit();
		return;
	}
	glk_window_clear(gms_main_window);
	glk_set_window(gms_main_window);
	glk_set_style(style_Normal);

	/*
	 * Given the basic game name, try to come up with usable text, graphics,
	 * and hints filenames.  The graphics and hints files may be null, but the
	 * text file may not.
	 */
	Common::String gameFile = getFilename();
	gms_establish_filenames(gameFile.c_str(), &text_file, &graphics_file, &hints_file);

	/* Set the possibility of pictures depending on graphics file. */
	if (graphics_file) {
		/*
		 * Check Glk library capabilities, and note pictures are impossible if
		 * the library can't offer both graphics and timers.  We need timers to
		 * create the background "thread" for picture updates.
		 */
		gms_graphics_possible = glk_gestalt(gestalt_Graphics, 0)
		                        && glk_gestalt(gestalt_Timer, 0);
	} else
		gms_graphics_possible = false;


	/*
	 * If pictures are impossible, clear pictures enabled flag.  That is, act
	 * as if -np was given on the command line, even though it may not have
	 * been.  If pictures are impossible, they can never be enabled.
	 */
	if (!gms_graphics_possible)
		gms_graphics_enabled = false;

	/* Try to create a one-line status window.  We can live without it. */
	glk_stylehint_set(wintype_TextGrid, style_User1, stylehint_ReverseColor, 1);
	gms_status_window = glk_window_open(gms_main_window,
	                    winmethod_Above | winmethod_Fixed,
	                    1, wintype_TextGrid, 0);

	/*
	 * Load the game.  If no graphics are possible, then passing the NULL to
	 * ms_init() runs a game without graphics.
	 */
	if (gms_graphics_possible) {
		assert(graphics_file);
		ms_init_status = ms_init(text_file, graphics_file, hints_file, NULL);
	} else
		ms_init_status = ms_init(text_file, NULL, hints_file, NULL);

	/* Look for a complete failure to load the game. */
	if (ms_init_status == 0) {
		if (gms_status_window)
			glk_window_close(gms_status_window, NULL);
		gms_header_string("Glk Magnetic Error\n\n");
		gms_normal_string("Can't load game '");
		gms_normal_string(gameFile.c_str());
		gms_normal_char('\'');

		gms_normal_char('\n');

		/*
		 * Free the text file path, any graphics/hints file path, and
		 * interpreter allocated memory.
		 */
		free(text_file);
		free(graphics_file);
		free(hints_file);
		ms_freemem();
		glk_exit();
	}

	/* Try to identify the game from its text file header. */
	gms_gameid_identify_game(text_file);

	/* Look for failure to load just game graphics. */
	if (gms_graphics_possible && ms_init_status == 1) {
		/*
		 * Output a warning if graphics failed, but the main game text
		 * initialized okay.
		 */
		gms_standout_string("Error: Unable to open graphics file\n"
		                    "Continuing without pictures...\n\n");

		gms_graphics_possible = false;
	}

	/* Run the game opcodes -- ms_rungame() returns false on game end. */
	do {
		is_running = ms_rungame() && !shouldQuit();
		glk_tick();
	} while (is_running);

	/* Handle any updated status and pending buffered output. */
	gms_status_notify();
	gms_output_flush();

	/* Turn off any background graphics "thread". */
	gms_graphics_stop();

	/* Free interpreter allocated memory. */
	ms_freemem();

	/*
	 * Free any temporary memory that may have been used by graphics and hints.
	 */
	gms_graphics_cleanup();
	gms_hints_cleanup();

	/* Close any open transcript, input log, and/or read log. */
	if (gms_transcript_stream) {
		glk_stream_close(gms_transcript_stream, NULL);
		gms_transcript_stream = NULL;
	}
	if (gms_inputlog_stream) {
		glk_stream_close(gms_inputlog_stream, NULL);
		gms_inputlog_stream = NULL;
	}
	if (gms_readlog_stream) {
		glk_stream_close(gms_readlog_stream, NULL);
		gms_readlog_stream = NULL;
	}

	/* Free the text file path, and any graphics/hints file path. */
	free(text_file);
	free(graphics_file);
	free(hints_file);
}

/*---------------------------------------------------------------------*/
/*  Linkage between Glk entry/exit calls and the Magnetic interpreter  */
/*---------------------------------------------------------------------*/

void Magnetic::glk_main() {
	assert(gms_startup_called && !gms_main_called);
	gms_main_called = true;

	/* Call the interpreter main function. */
	gms_main();
}

void Magnetic::write(const char *fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	Common::String s = Common::String::format(fmt, ap);
	va_end(ap);
	glk_put_buffer(s.c_str(), s.size());
}

void Magnetic::writeChar(char c) {
	glk_put_char(c);
}

} // End of namespace Magnetic
} // End of namespace Glk