#if !defined(WITH_ICU)

static WChar *HandleBiDiAndArabicShapes(WChar *text) { return text; }

#else

#include <unicode/ubidi.h>

#include <unicode/ushape.h>

#include <unicode/ustring.h>

/**

 * Function to be able to handle right-to-left text and Arabic chars properly.

 *

 * First: right-to-left (RTL) is stored 'logically' in almost all applications

 *        and so do we. This means that their text is stored from right to the

 *        left in memory and any non-RTL text (like numbers or English) are

 *        then stored from left-to-right. When we want to actually draw the

 *        text we need to reverse the RTL text in memory, which is what

 *        happens in ubidi_writeReordered.

 * Second: Arabic characters "differ" based on their context. To draw the

 *        correct variant we pass it through u_shapeArabic. This function can

 *        add or remove some characters. This is the reason for the lastof

 *        so we know till where we can fill the output.

 *

 * Sadly enough these functions work with a custom character format, UChar,

 * which isn't the same size as WChar. Because of that we need to transform

 * our text first to UChars and then back to something we can use.

 *

 * To be able to truncate strings properly you must truncate before passing to

 * this function. This way the logical begin of the string remains and the end

 * gets chopped of instead of the other way around.

 *

 * The reshaping of Arabic characters might increase or decrease the width of

 * the characters/string. So it might still overflow after truncation, though

 * the chance is fairly slim as most characters get shorter instead of longer.

 * @param buffer the buffer to read from/to

 * @param lastof the end of the buffer

 * @return the buffer to draw from

 */

static WChar *HandleBiDiAndArabicShapes(WChar *buffer)

{

	UChar input[DRAW_STRING_BUFFER];

	UChar intermediate[DRAW_STRING_BUFFER];

	static WChar output[DRAW_STRING_BUFFER];

	/* Transform from UTF-32 to internal ICU format of UTF-16. */

	UErrorCode err = U_ZERO_ERROR;

	int32_t length = 0;

	u_strFromUTF32(input, lengthof(input), &length, (UChar32 *)buffer, -1, &err);

	if (U_FAILURE(err)) return buffer;

	UBiDi *para = ubidi_openSized(length, 0, &err);

	if (para == NULL) return buffer;

	ubidi_setPara(para, input, length, _current_text_dir == TD_RTL ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR, NULL, &err);

	length = ubidi_writeReordered(para, intermediate, lengthof(intermediate), UBIDI_REMOVE_BIDI_CONTROLS, &err);

	length = u_shapeArabic(intermediate, length, input, lengthof(input), U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_LETTERS_SHAPE, &err);

	ubidi_close(para);

	if (U_FAILURE(err)) return buffer;

	/* Transform back to UTF-32. */

	u_strToUTF32((UChar32 *)output, lengthof(output), NULL, input, length, &err);

	if (U_FAILURE(err)) return buffer;

	/* u_strToUTF32 doesn't add a NUL charcter if the buffer is too small, be safe. */

	output[lengthof(output) - 1] = '\0';

	return output;

}

#endif /* WITH_ICU */

/**

 * Truncate a given string to a maximum width if necessary.

 * If the string is truncated, add three dots ('...') to show this.

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

 * @param maxw maximum width in pixels of the string

 * @param start_fontsize Fontsize to start the text with

 * @return new width of (truncated) string

 */

static int TruncateString(char *str, int maxw, FontSize start_fontsize)

{

	int w = 0;

	FontSize size = start_fontsize;

	int ddd, ddd_w;

	WChar c;

	char *ddd_pos;

	ddd_w = ddd = GetCharacterWidth(size, '.') * 3;

	for (ddd_pos = str; (c = Utf8Consume(const_cast<const char **>(&str))) != '\0'; ) {

		if (IsPrintable(c) && !IsTextDirectionChar(c)) {

			w += GetCharacterWidth(size, c);

			if (w > maxw) {

				/* string got too big... insert dotdotdot, but make sure we do not

				 * print anything beyond the string termination character. */

				for (int i = 0; *ddd_pos != '\0' && i < 3; i++, ddd_pos++) *ddd_pos = '.';

				*ddd_pos = '\0';

				return ddd_w;

			}

		} else {

			if (c == SCC_TINYFONT) {

				size = FS_SMALL;

				ddd = GetCharacterWidth(size, '.') * 3;

			} else if (c == SCC_BIGFONT) {

				size = FS_LARGE;

				ddd = GetCharacterWidth(size, '.') * 3;

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

				DEBUG(misc, 0, "Drawing string using newlines with DrawString instead of DrawStringMultiLine. Please notify the developers of this: [%s]", str);

			}

		}

		/* Remember the last position where three dots fit. */

		if (w + ddd < maxw) {

			ddd_w = w + ddd;

			ddd_pos = str;

		}

	}

	return w;

}

static int ReallyDoDrawString(const WChar *string, int x, int y, DrawStringParams &params, bool parse_string_also_when_clipped = false);

 * Get the real width of the string.

 * @param str the string to draw

 * @param start_fontsize Fontsize to start the text with

 * @return the width.

 */

static int GetStringWidth(const WChar *str, FontSize start_fontsize)

{

	FontSize size = start_fontsize;

	int max_width;

	int width;

	WChar c;

	width = max_width = 0;

	for (;;) {

		c = *str++;

		if (c == 0) break;

		if (IsPrintable(c) && !IsTextDirectionChar(c)) {

			width += GetCharacterWidth(size, c);

		} else {

			switch (c) {

				case SCC_TINYFONT: size = FS_SMALL; break;

				case SCC_BIGFONT:  size = FS_LARGE; break;

				case '\n':

					max_width = max(max_width, width);

					break;

			}

		}

	}

	return max(max_width, width);

}

/**

 * Draw string, possibly truncated to make it fit in its allocated space

 *

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

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

 * @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 params Text drawing parameters.

 * @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.

 * @param underline Whether to underline what has been drawn or not.

 * @param truncate  Whether to truncate the string or not.

 *

 * @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.

 */

static int DrawString(int left, int right, int top, char *str, const char *last, DrawStringParams &params, StringAlignment align, bool underline = false, bool truncate = true)

{

	if (truncate) TruncateString(str, right - left + 1, params.fontsize);

	WChar draw_buffer[DRAW_STRING_BUFFER];

	WChar *p = draw_buffer;

	const char *text = str;

	for (WChar c = Utf8Consume(&text); c != '\0'; c = Utf8Consume(&text)) {

		*p++ = c;

	}

	*p++ = '\0';

	/* In case we have a RTL language we swap the alignment. */

	if (!(align & SA_FORCE) && _current_text_dir == TD_RTL && (align & SA_HOR_MASK) != SA_HOR_CENTER) align ^= SA_RIGHT;

	WChar *to_draw = HandleBiDiAndArabicShapes(draw_buffer);

	int w = GetStringWidth(to_draw, params.fontsize);

	/* 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

	 * seen as lastof(todraw) and width as lengthof(todraw). They differ by 1.

	 * So most +1/-1 additions are to move from lengthof to 'indices'.

	 */

	switch (align & SA_HOR_MASK) {

		case SA_LEFT:

			/* right + 1 = left + w */

			right = left + w - 1;

			break;

		case SA_HOR_CENTER:

			left  = RoundDivSU(right + 1 + left - w, 2);

			/* right + 1 = left + w */

			right = left + w - 1;

			break;

		case SA_RIGHT:

			left = right + 1 - w;

			break;

		default:

			NOT_REACHED();

	}

	ReallyDoDrawString(to_draw, left, top, params, !truncate);

	if (underline) {

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

	}

	return (align & SA_HOR_MASK) == SA_RIGHT ? left : right;

}

/**

 * 'Correct' a string to a maximum length. Longer strings will be cut into

 * additional lines at whitespace characters if possible. The string parameter

 * is modified with terminating characters mid-string which are the

 * placeholders for the newlines.

 * The string WILL be truncated if there was no whitespace for the current

 * line's maximum width.

 *

 * @note To know if the terminating '\0' is the string end or just a

 * newline, the returned 'num' value should be consulted. The num'th '\0',

 * starting with index 0 is the real string end.

 *

 * @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

 * @param size Fontsize to start the text with

 * @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

 */

static uint32 FormatStringLinebreaks(char *str, const char *last, int maxw, FontSize size = FS_NORMAL)

{

	int num = 0;

	assert(maxw > 0);

	for (;;) {

		/* The character *after* the last space. */

		char *last_space = NULL;

		int w = 0;

		for (;;) {

			WChar c = Utf8Consume(const_cast<const char **>(&str));

			/* whitespace is where we will insert the line-break */

			if (IsWhitespace(c)) last_space = str;

			if (IsPrintable(c) && !IsTextDirectionChar(c)) {

				int char_w = GetCharacterWidth(size, c);

				w += char_w;

				if (w > maxw) {

					/* The string is longer than maximum width so we need to decide

					 * what to do with it. */

					if (w == char_w) {

						/* The character is wider than allowed width; don't know

						 * what to do with this case... bail out! */

						return num + (size << 16);

					}

					if (last_space == NULL) {

						/* No space has been found. Just terminate at our current

						 * location. This usually happens for languages that do not

						 * require spaces in strings, like Chinese, Japanese and

						 * Korean. For other languages terminating mid-word might

						 * not be the best, but terminating the whole string instead

						 * of continuing the word at the next line is worse. */

						str = Utf8PrevChar(str);

						size_t len = strlen(str);

						char *terminator = str + len;

						/* The string location + length of the string + 1 for '\0'

						 * always fits; otherwise there's no trailing '\0' and it

						 * it not a valid string. */

						assert(terminator <= last);

						assert(*terminator == '\0');

						/* If the string is too long we have to terminate it earlier. */

						if (terminator == last) {

							/* Get the 'begin' of the previous character and make that

							 * the terminator of the string; we truncate it 'early'. */

							*Utf8PrevChar(terminator) = '\0';

							len = strlen(str);

						}

						/* Also move the terminator! */

						memmove(str + 1, str, len + 1);

						*str = '\0';

						/* str needs to point to the character *after* the last space */

						str++;

					} else {

						/* A space is found; perfect place to terminate */

						str = last_space;

					}

					break;

				}

			} else {

				switch (c) {

					case '\0': return num + (size << 16);

					case SCC_TINYFONT: size = FS_SMALL; break;

					case SCC_BIGFONT:  size = FS_LARGE; break;

					case '\n': goto end_of_inner_loop;

				}

			}

		}

end_of_inner_loop:

		/* String didn't fit on line (or a '\n' was encountered), so 'dummy' terminate

		 * and increase linecount. We use Utf8PrevChar() as also non 1 char long

		 * whitespace separators are supported */

		num++;

		char *s = Utf8PrevChar(str);

		*s++ = '\0';

		/* In which case (see above) we will shift remainder to left and close the gap */

		if (str - s >= 1) {

			for (; str[-1] != '\0';) *s++ = *str++;

		}

	}

}

/**

 * 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())

 * @param start_fontsize Fontsize to start the text with

 * @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

 */

static int GetMultilineStringHeight(const char *src, int num, FontSize start_fontsize)

{

	int maxy = 0;

	int y = 0;

	int fh = GetCharacterHeight(start_fontsize);

	for (;;) {

		WChar c = Utf8Consume(&src);

		switch (c) {

			case 0:            y += fh; if (--num < 0) return maxy; break;

			case '\n':         y += fh;                             break;

			case SCC_TINYFONT: fh = GetCharacterHeight(FS_SMALL);   break;

			case SCC_BIGFONT:  fh = GetCharacterHeight(FS_LARGE);   break;

			default:           maxy = max<int>(maxy, y + fh);       break;

		}

	}

}

/**

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

 * @param colour Colour used for drawing the string, see DoDrawString() for details

 * @param align  The horizontal and vertical alignment of the string.

 * @param underline Whether to underline all strings

 * @param fontsize The size of the initial characters.

 *

 * @return If \a align is #SA_BOTTOM, the top to where we have written, else the bottom to where we have written.

 */

static int DrawStringMultiLine(int left, int right, int top, int bottom, char *str, const char *last, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)

{

	int maxw = right - left + 1;

	int maxh = bottom - top + 1;

	/* It makes no sense to even try if it can't be drawn anyway, or

	 * do we really want to support fonts of 0 or less pixels high? */

	if (maxh <= 0) return top;

	uint32 tmp = FormatStringLinebreaks(str, last, maxw);

	int num = GB(tmp, 0, 16) + 1;

	int mt = GetCharacterHeight((FontSize)GB(tmp, 16, 16));

	int total_height = num * mt;

	int skip_lines = 0;

	if (total_height > maxh) {

		if (maxh < mt) return top; //  Not enough room for a single line.

		if ((align & SA_VERT_MASK) == SA_BOTTOM) {

			skip_lines = num;

			num = maxh / mt;

			skip_lines -= num;

		} else {

			num = maxh / mt;

		}

		total_height = num * mt;

	}

	int y;

	switch (align & SA_VERT_MASK) {

		case SA_TOP:

			y = top;

			break;

		case SA_VERT_CENTER:

			y = RoundDivSU(bottom + top - total_height, 2);

			break;

		case SA_BOTTOM:

			y = bottom - total_height;

			break;

		default: NOT_REACHED();

	}

	const char *src = str;

	DrawStringParams params(colour, fontsize);

	int written_top = bottom; // Uppermost position of rendering a line of text

	for (;;) {

		if (skip_lines == 0) {

			char buf2[DRAW_STRING_BUFFER];

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

			DrawString(left, right, y, buf2, lastof(buf2), params, align, underline, false);

			if (written_top > y) written_top = y;

			y += mt;

			num--;

		}

		for (;;) {

			WChar c = Utf8Consume(&src);

			if (c == 0) {

				break;

			} else if (skip_lines > 0) {

				/* Skipped drawing, so do additional processing to update params. */

				if (c >= SCC_BLUE && c <= SCC_BLACK) {

					params.SetColour((TextColour)(c - SCC_BLUE));

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

					params.SetPreviousColour();

				} else if (c == SCC_TINYFONT) {

					params.SetFontSize(FS_SMALL);

				} else if (c == SCC_BIGFONT) {

					params.SetFontSize(FS_LARGE);

				}

			}

		}

		if (skip_lines > 0) skip_lines--;

		if (num == 0) return ((align & SA_VERT_MASK) == SA_BOTTOM) ? written_top : y;

	}

}

/**

 * Draw string, possibly over multiple lines.

 *

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

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

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

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

 * @param str    String to draw.

 * Draw a string at the given coordinates with the given colour.

 *  While drawing the string, parse it in case some formatting is specified,

 *  like new colour, new size or even positioning.

 * @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 params              Text drawing parameters

 * @param parse_string_also_when_clipped

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

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

 *                            so no need to re-perform the same kind (more or less) of verifications.

 *                            It's not only an optimisation, it's also a way to ensures the string will be parsed

 *                            (as there are certain side effects on global variables, which are important for the next line)

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

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

 */

static int ReallyDoDrawString(const WChar *string, int x, int y, DrawStringParams &params, bool parse_string_also_when_clipped)

{

	DrawPixelInfo *dpi = _cur_dpi;

	bool draw_shadow = GetDrawGlyphShadow(FS_NORMAL);

	WChar 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:;

	SetColourRemap(params.cur_colour);

check_bounds:

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

skip_char:;

		for (;;) {

			c = *string++;

			if (!IsPrintable(c)) goto skip_cont;

		}

	}

	for (;;) {

		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) && !IsTextDirectionChar(c)) {

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

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

				const Sprite *glyph = GetGlyph(params.fontsize, c);

				if (draw_shadow && params.fontsize == FS_NORMAL && params.cur_colour != TC_BLACK && !(c >= SCC_SPRITE_START && c <= SCC_SPRITE_END)) {

					SetColourRemap(TC_BLACK);

					GfxMainBlitter(glyph, x + 1, y + 1, BM_COLOUR_REMAP);

					SetColourRemap(params.cur_colour);

				}

				GfxMainBlitter(glyph, x, y, BM_COLOUR_REMAP);

			}

			x += GetCharacterWidth(params.fontsize, c);

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

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

			y += GetCharacterHeight(params.fontsize);

			goto check_bounds;

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

			params.SetColour((TextColour)(c - SCC_BLUE));

			goto switch_colour;

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

			params.SetPreviousColour();

			goto switch_colour;

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

			params.SetFontSize(FS_SMALL);

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

			params.SetFontSize(FS_LARGE);

		} else if (!IsTextDirectionChar(c)) {

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

		}

	}

}

/**