with_icu="1"

		with_icu

			--with-icu)                   with_icu="2";;

			--without-icu)                with_icu="0";;

			--with-icu=*)                 with_icu="$optarg";;

			--with-libicu)                with_icu="2";;

			--without-libicu)             with_icu="0";;

			--with-libicu=*)              with_icu="$optarg";;

	detect_icu

	if [ -n "$icu_config" ]; then

		CFLAGS="$CFLAGS -DWITH_ICU"

		CFLAGS="$CFLAGS `$icu_config --cppflags | tr '\n\r' '  '`"

		LIBS="$LIBS `$icu_config --ldflags-libsonly | tr '\n\r' '  '`"

	fi

detect_icu() {

	# 0 means no, 1 is auto-detect, 2 is force

	if [ "$with_icu" = "0" ]; then

		log 1 "checking libicu... disabled"

		icu_config=""

		return 0

	fi

	if [ "$with_icu" = "1" ] || [ "$with_icu" = "" ] || [ "$with_icu" = "2" ]; then

		icu_config="icu-config"

	else

		icu_config="$with_icu"

	fi

	version=`$icu_config --version 2>/dev/null`

	ret=$?

	shortversion=`echo $version | cut -c 1,3`

	log 2 "executing $icu_config --version"

	log 2 "  returned $version"

	log 2 "  exit code $ret"

	if [ -z "$version" ] || [ "$ret" != "0" ] || [ "$shortversion" -lt "20" ]; then

		if [ -n "$shortversion" ] && [ "$shortversion" -lt "20" ]; then

			log 1 "checking libicu... needs at least version 2.0.0, icu NOT enabled"

		else

			log 1 "checking libicu... not found"

		fi

		# It was forced, so it should be found.

		if [ "$with_icu" != "1" ]; then

			log 1 "configure: error: icu-config couldn't be found"

			log 1 "configure: error: you supplied '$with_icuconfig', but it seems invalid"

			exit 1

		fi

		icu_config=""

		return 0

	fi

	log 1 "checking libicu... found"

}

static int ReallyDoDrawString(const char *string, int x, int y, uint16 real_colour, bool parse_string_also_when_clipped = false);

#if !defined(WITH_ICU)

static void HandleBiDiAndArabicShapes(char *text, const char *lastof) {}

#else

#include "unicode/ubidi.h"

#include "unicode/ushape.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

 */

static void HandleBiDiAndArabicShapes(char *buffer, const char *lastof)

{

	UChar input_output[DRAW_STRING_BUFFER];

	UChar intermediate[DRAW_STRING_BUFFER];

	char *t = buffer;

	size_t length = 0;

	while (*t != '\0' && length < lengthof(input_output)) {

		WChar tmp;

		t += Utf8Decode(&tmp, t);

		input_output[length++] = tmp;

	}

	input_output[length] = 0;

	UErrorCode err = U_ZERO_ERROR;

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

	if (para == NULL) return;

	ubidi_setPara(para, input_output, length, UBIDI_DEFAULT_RTL, NULL, &err);

	ubidi_writeReordered(para, intermediate, length, 0, &err);

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

	ubidi_close(para);

	if (U_FAILURE(err)) return;

	t = buffer;

	for (size_t i = 0; i < length && t < (lastof - 4); i++) {

		t += Utf8Encode(t, input_output[i]);

	}

	*t = '\0';

}

#endif /* WITH_ICU */

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	return ReallyDoDrawString(buffer, x, y, color);

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	return ReallyDoDrawString(buffer, x, y, color);

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	ReallyDoDrawString(buffer, x - w, y, color);

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	ReallyDoDrawString(buffer, x - GetStringBoundingBox(buffer).width, y, color);

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	ReallyDoDrawString(buffer, x - w / 2, y, color);

	TruncateStringID(str, buffer, xr - xl, lastof(buffer));

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	int w = GetStringBoundingBox(buffer).width;

	return ReallyDoDrawString(buffer, (xl + xr - w) / 2, y, color);

	char buffer[DRAW_STRING_BUFFER];

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

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	int w = GetStringBoundingBox(buffer).width;

	ReallyDoDrawString(buffer, x - w / 2, y, color);

	int num, mt;

		char buf2[DRAW_STRING_BUFFER];

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

		HandleBiDiAndArabicShapes(buf2, lastof(buf2));

		int w = GetStringBoundingBox(buf2).width;

		ReallyDoDrawString(buf2, x - (w >> 1), y, 0xFE, true);

		char buf2[DRAW_STRING_BUFFER];

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

		HandleBiDiAndArabicShapes(buf2, lastof(buf2));

		ReallyDoDrawString(buf2, x, y, 0xFE, true);

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

	char buffer[DRAW_STRING_BUFFER];

	strecpy(buffer, string, lastof(buffer));

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	return ReallyDoDrawString(buffer, x, y, real_colour, parse_string_also_when_clipped);

}

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

 * @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 real_colour         Colour of the string, see _string_colormap in

 *                            table/palettes.h or docs/ottd-colourtext-palette.png or the enum TextColour in gfx_type.h

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

 *                            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 char *string, int x, int y, uint16 real_colour, bool parse_string_also_when_clipped)

{