with up to 64 language.

	                   Otherwise, it is a mapping where set bits have meaning

	                   0 = american, 1 = english, 2 = german, 3 = french, 4 = spanish

	                   Bit 7 set means this is a generic text, not a vehicle one (or else)

	 * B num-veh       number of vehicles which are getting a new name

	 * B/W offset      number of the first vehicle that gets a new name

	 *                 Byte : ID of vehicle to change

	 *                 Word : ID of string to change/add

	 * S data          new texts, each of them zero-terminated, after

	 *                 which the next name begins. */

	/* TODO: No support for changing non-vehicle text. Perhaps we shouldn't

	 * implement it at all, but it could be useful for some "modpacks"

	 * (completely new scenarios changing all graphics and logically also

	 * factory names etc). We should then also support all languages (by

	 * name), not only the original four ones. --pasky

	 * TODO: Support for custom station class/type names.

	 * All of the above are coming.  In Time.  Some sooner than others :)*/

	uint8 feature;

	uint8 lang;

	uint8 num;

	uint16 id;

	uint16 endid;

	const char* name;

	check_length(len, 6, "VehicleNewName");

	buf++;

	feature  = grf_load_byte(&buf);

	lang     = grf_load_byte(&buf);

	num      = grf_load_byte(&buf);

	id       = (lang & 0x80) ? grf_load_word(&buf) : grf_load_byte(&buf);

	if (feature < GSF_AIRCRAFT+1) {

		id += _vehshifts[feature];

	}

	endid    = id + num;

	DEBUG(grf, 6) ("VehicleNewName: About to rename engines %d..%d (feature %d) in language 0x%02X.",

	               id, endid, feature, lang);

	name = (const char*)buf; /*transfer read value*/

	len -= (lang & 0x80) ? 6 : 5;

	for (; id < endid && len > 0; id++) {

		size_t ofs = strlen(name) + 1;

		if (ofs < 128) {

			DEBUG(grf, 8) ("VehicleNewName: %d <- %s", id, name);

			switch (feature) {

				case GSF_TRAIN:

				case GSF_ROAD:

				case GSF_SHIP:

				case GSF_AIRCRAFT: {

					if (id < TOTAL_NUM_ENGINES) SetCustomEngineName(id, string);

					break;

				}

#if 0

				case GSF_STATION:

					switch (GB(id, 8, 8)) {

						case 0xC4: { /* Station class name */

							StationClassID sclass = _cur_grffile->stations[GB(id, 0, 8)].sclass;

							SetStationClassName(sclass, AddGRFString(_cur_grffile->grfid, id, lang, name));

							break;

						}

						case 0xC5:   /* Station name */

							_cur_grffile->stations[GB(id, 0, 8)].name = AddGRFString(_cur_grffile->grfid, id, lang, name);

							break;

						default:

							DEBUG(grf, 7) ("VehicleNewName: Unsupported ID (0x%04X)", id);

							break;

					}

					break;

				case GSF_CANAL :

	GRFLX_SPANISH     = 0x04,

	GRFLX_RUSSIAN     = 0x07,

	GRFLX_CZECH       = 0x15,

	GRFLX_SLOVAK      = 0x16,

	GRFLX_DUTCH       = 0x1F,

	GRFLX_CATALAN     = 0x22,

	GRFLX_HUNGARIAN   = 0x24,

	GRFLX_ITALIAN     = 0x27,

	GRFLX_ROMANIAN    = 0x28,

	GRFLX_ICELANDIC   = 0x29,

	GRFLX_LATVIAN     = 0x2A,

	GRFLX_LITHUANIAN  = 0x2B,

	GRFLX_SLOVENIAN   = 0x2C,

	GRFLX_DANISH      = 0x2D,

	GRFLX_SWEDISH     = 0x2E,

	GRFLX_NORWEGIAN   = 0x2F,

	GRFLX_POLISH      = 0x30,

	GRFLX_GALICIAN    = 0x31,

	GRFLX_FRISIAN     = 0x32,

	GRFLX_ESTONIAN    = 0x34,

	GRFLX_FINNISH     = 0x35,

	GRFLX_PORTUGUESE  = 0x36,

	GRFLX_BRAZILIAN   = 0x37,

	GRFLX_TURKISH     = 0x3E,

} grf_language;

typedef struct iso_grf {

	char code[6];

	byte grfLangID;

} iso_grf;

/**

 * ISO code VS NewGrf langID conversion array.

 * This array is used in two ways:

 * 1-its ISO part is matching OpenTTD dynamic language id

 *   with newgrf bit positionning language id

 * 2-its shift part is used to know what is the shift to

 *   watch for when inserting new strings, hence analysing newgrf langid

 */

const iso_grf iso_codes[] = {

	{"en_US", GRFLX_AMERICAN},

	{"en_GB", GRFLX_ENGLISH},

	{"de",    GRFLX_GERMAN},

	{"fr",    GRFLX_FRENCH},

	{"es",    GRFLX_SPANISH},

	{"cs",    GRFLX_CZECH},

	{"ca",    GRFLX_CATALAN},

	{"is",    GRFLX_ICELANDIC},

	{"it",    GRFLX_ITALIAN},

	{"lv",    GRFLX_LATVIAN},

	{"lt",    GRFLX_LITHUANIAN},

	{"nb",    GRFLX_NORWEGIAN},

	{"pl",    GRFLX_POLISH},

	{"pt",    GRFLX_PORTUGUESE},

	{"pt_BR", GRFLX_BRAZILIAN},

	{"ro",    GRFLX_ROMANIAN},

	{"ru",    GRFLX_RUSSIAN},

	{"sk",    GRFLX_SLOVAK},

	{"sl",    GRFLX_SLOVENIAN},

	{"sv",    GRFLX_SWEDISH},

	{"tr",    GRFLX_TURKISH},

	{"gen",   GRFLB_GENERIC}   //this is not iso code, but there has to be something...

};

static uint _num_grf_texts = 0;

static GRFTextEntry _grf_text[(1 << TABSIZE) * 3];

static byte _currentLangID = GRFLX_ENGLISH;  //by default, english is used.

/**

 */

{

	GRFText *newtext;

	uint id;

	 * English or American is among the set bits, simply add it as English in

	 * the new scheme, i.e. as langid = 1.

	 * If English is set, it is pretty safe to assume the translations are not

	 * actually translated.

	 */

		if (HASBITS(langid_to_add, GRFLB_AMERICAN | GRFLB_ENGLISH)) {

			langid_to_add = GRFLX_ENGLISH;

		} else {

			StringID ret = STR_EMPTY;

			return ret;

		}

	}

	newtext = calloc(1, sizeof(*newtext));

	newtext->langid = GB(langid_to_add, 0, 6);

	newtext->text   = strdup(text_to_add);

	newtext->next   = NULL;

	str_validate(newtext->text);

	for (id = 0; id < _num_grf_texts; id++) {

		if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {

			break;

		}

	}

	/* Too many strings allocated, return empty */

	if (id == lengthof(_grf_text)) return STR_EMPTY;

	/* If we didn't find our stringid and grfid in the list, allocate a new id */

	if (id == _num_grf_texts) _num_grf_texts++;

	if (_grf_text[id].textholder == NULL) {

/**

 * Element of the linked list.

 * Each of those elements represent the string,

 * but according to a different lang.

 */

typedef struct GRFText {

	byte langid;

	char *text;

	struct GRFText *next;

} GRFText;

/**

 * Holder of the above structure.

 * Putting both grfid and stringid togueter allow us to avoid duplicates,

 * since it is NOT SUPPOSED to happen.

 */

typedef struct GRFTextEntry {

	uint32 grfid;

	uint16 stringid;

	GRFText *textholder;

} GRFTextEntry;

StringID GetGRFStringID(uint32 grfid, uint16 stringid);

char *GetGRFString(char *buff, uint16 stringid);

void CleanUpStrings(void);

void SetCurrentGrfLangID(const char *iso_name);

#endif /* NEWGRF_TEXT_H */