static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode, const SubSprite *sub = NULL, SpriteID sprite_id = SPR_CURSOR_MOUSE);

static ReusableBuffer<uint8> _cursor_backup;

/**

 * @param *str string that is checked and possibly truncated

 * @param maxw maximum width in pixels of the string

 * @param ignore_setxy whether to ignore SETX(Y) or not

 * @return new width of (truncated) string

 */

{

	int w = 0;

	int ddd, ddd_w;

	WChar c;

	return w;

}

/**

 * Get the real width of the string.

 * @param str the string to draw

 * @return the width.

 */

{

	int max_width;

	int width;

	WChar c;

 * @param top    The top most position to draw on.

 * @param str    String to draw.

 * @param last   The end of the string buffer to draw.

 * @param align  The alignment of the string when drawing left-to-right. In the

 *               case a right-to-left language is chosen this is inverted so it

 *               will be drawn in the right direction.

 * @return In case of left or center alignment the right most pixel we have drawn to.

 *         In case of right alignment the left most pixel we have drawn to.

 */

{

	/* We need the outer limits of both left/right */

	int min_left = INT32_MAX;

	int initial_right = right;

	int initial_top = top;

	/*

	 * To support SETX and SETXY properly with RTL languages we have to

			to_draw++;

			offset = *to_draw++;

			if (*to_draw == SCC_SETXY) top = initial_top + *to_draw++;

		}

		to_draw = HandleBiDiAndArabicShapes(to_draw);

		/* right is the right most position to draw on. In this case we want to do

		 * calculations with the width of the string. In comparison right can be

		min_left  = min(left, min_left);

		max_right = max(right, max_right);

		if (underline) {

			GfxFillRect(left, top + FONT_HEIGHT_NORMAL, right, top + FONT_HEIGHT_NORMAL, _string_colourremap[1]);

		}

	}

	return align == SA_RIGHT ? min_left : max_right;

}

{

	char buffer[DRAW_STRING_BUFFER];

	strecpy(buffer, str, lastof(buffer));

}

/**

{

	char buffer[DRAW_STRING_BUFFER];

	GetString(buffer, str, lastof(buffer));

}

/**

 * @param str string to check and correct for length restrictions

 * @param last the last valid location (for '\0') in the buffer of str

 * @param maxw the maximum width the string can have on one line

 * @return return a 32bit wide number consisting of 2 packed values:

 *  0 - 15 the number of lines ADDED to the string

 * 16 - 31 the fontsize in which the length calculation was done at

 */

{

	int num = 0;

	assert(maxw > 0);

/** Calculates height of string (in pixels). Accepts multiline string with '\0' as separators.

 * @param src string to check

 * @param num number of extra lines (output of FormatStringLinebreaks())

 * @note assumes text won't be truncated. FormatStringLinebreaks() is a good way to ensure that.

 * @return height of pixels of string when it is drawn

 */

{

	int maxy = 0;

	int y = 0;

	for (;;) {

		WChar c = Utf8Consume(&src);

	uint32 tmp = FormatStringLinebreaks(buffer, lastof(buffer), maxw);

}

/** Calculate string bounding box for multi-line strings.

	int y = (align == SA_CENTER) ? RoundDivSU(bottom + top - total_height, 2) : top;

	const char *src = buffer;

	for (;;) {

		char buf2[DRAW_STRING_BUFFER];

		strecpy(buf2, src, lastof(buf2));

		for (;;) {

			WChar c = Utf8Consume(&src);

			if (c == 0) {

				y += mt;

				if (--num < 0) {

					return y;

				}

				break;

 * are therefore a rough estimation correct for all the current strings

 * but not every possible combination

 * @param str string to calculate pixel-width

 * @return string width and height in pixels */

{

	Dimension br;

	uint max_width;

	WChar c;

 * @param string              The string to draw. This is already bidi reordered.

 * @param x                   Offset from left side of the screen

 * @param y                   Offset from top side of the screen

 * @param parse_string_also_when_clipped

 *                            By default, always test the available space where to draw the string.

 *                            When in multipline drawing, it would already be done,

 * @return                    the x-coordinates where the drawing has finished.

 *                            If nothing is drawn, the originally passed x-coordinate is returned

 */

{

	DrawPixelInfo *dpi = _cur_dpi;

	UChar c;

	int xo = x;

	if (!parse_string_also_when_clipped) {

		/* in "mode multiline", the available space have been verified. Not in regular one.

		 * So if the string cannot be drawn, return the original start to say so.*/

		if (x >= dpi->left + dpi->width || y >= dpi->top + dpi->height) return x;

switch_colour:;

check_bounds:

	if (y + _max_char_height <= dpi->top || dpi->top + dpi->height <= y) {

		c = *string++;

skip_cont:;

		if (c == 0) {

			return x;  // Nothing more to draw, get out. And here is the new x position

		}

		if (IsPrintable(c)) {

			if (x >= dpi->left + dpi->width) goto skip_char;

			if (x + _max_char_width >= dpi->left) {

			}

		} else if (c == '\n') { // newline = {}

			x = xo;  // We require a new line, so the x coordinate is reset

			goto check_bounds;

		} else if (c >= SCC_BLUE && c <= SCC_BLACK) { // change colour?

			goto switch_colour;

		} else if (c == SCC_PREVIOUS_COLOUR) { // revert to the previous colour

			goto switch_colour;

		} else if (c == SCC_SETX || c == SCC_SETXY) { // {SETX}/{SETXY}

			/* The characters are handled before calling this. */

			NOT_REACHED();

		} else if (c == SCC_TINYFONT) { // {TINYFONT}

		} else if (c == SCC_BIGFONT) { // {BIGFONT}

		} else {

			DEBUG(misc, 0, "[utf8] unknown string command character %d", c);

		}

void GfxDrawLine(int left, int top, int right, int bottom, int colour);

void DrawBox(int x, int y, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3);

Dimension GetStringBoundingBox(StringID strid);

int GetStringHeight(StringID str, int maxw);

Dimension GetStringMultiLineBoundingBox(StringID str, const Dimension &suggestion);

void LoadStringWidthTable();

bool ToggleFullScreen(bool fs);

/* gfx.cpp */

byte GetCharacterWidth(FontSize size, uint32 key);

byte GetDigitWidth(FontSize size = FS_NORMAL);

	this->center = center;

	/* zoomed out version */

	this->MarkDirty();

}