1

/* $Id$ */

     2

     3

/** @file

     4

 * Implementation of  Action 04 "universal holder" structure and functions.

     5

 * This file implements a linked-lists of strings,

     6

 * holding everything that the newgrf action 04 will send over to OpenTTD.

     7

 * One of the biggest problems is that Dynamic lang Array uses ISO codes

     8

 * as way to identifying current user lang, while newgrf uses bit shift codes

     9

 * not related to ISO.  So equivalence functionnality had to be set.

    10

 */

    11

    12

#include "stdafx.h"

    13

#include "debug.h"

    14

#include "openttd.h"

    15

#include "string.h"

    16

#include "strings.h"

    17

#include "variables.h"

    18

#include "macros.h"

    19

#include "table/strings.h"

    20

#include "newgrf_text.h"

    21

    22

#define GRFTAB  28

    23

#define TABSIZE 11

    24

    25

/**

    26

 * Explains the newgrf shift bit positionning.

    27

 * the grf base will not be used in order to find the string, but rather for

    28

 * jumping from standard langID scheme to the new one.

    29

 */

    30

typedef enum grf_base_languages {

    31

	GRFLB_AMERICAN    = 0x01,

    32

	GRFLB_ENGLISH     = 0x02,

    33

	GRFLB_GERMAN      = 0x04,

    34

	GRFLB_FRENCH      = 0x08,

    35

	GRFLB_SPANISH     = 0x10,

    36

	GRFLB_GENERIC     = 0x80,

    37

} grf_base_language;

    38

    39

typedef enum grf_extended_languages {

    40

	GRFLX_AMERICAN    = 0x00,

    41

	GRFLX_ENGLISH     = 0x01,

    42

	GRFLX_GERMAN      = 0x02,

    43

	GRFLX_FRENCH      = 0x03,

    44

	GRFLX_SPANISH     = 0x04,

    45

	GRFLX_RUSSIAN     = 0x07,

    46

	GRFLX_CZECH       = 0x15,

    47

	GRFLX_SLOVAK      = 0x16,

    48

	GRFLX_AFRIKAANS   = 0x1B,

    49

	GRFLX_GREEK       = 0x1E,

    50

	GRFLX_DUTCH       = 0x1F,

    51

	GRFLX_CATALAN     = 0x22,

    52

	GRFLX_HUNGARIAN   = 0x24,

    53

	GRFLX_ITALIAN     = 0x27,

    54

	GRFLX_ROMANIAN    = 0x28,

    55

	GRFLX_ICELANDIC   = 0x29,

    56

	GRFLX_LATVIAN     = 0x2A,

    57

	GRFLX_LITHUANIAN  = 0x2B,

    58

	GRFLX_SLOVENIAN   = 0x2C,

    59

	GRFLX_DANISH      = 0x2D,

    60

	GRFLX_SWEDISH     = 0x2E,

    61

	GRFLX_NORWEGIAN   = 0x2F,

    62

	GRFLX_POLISH      = 0x30,

    63

	GRFLX_GALICIAN    = 0x31,

    64

	GRFLX_FRISIAN     = 0x32,

    65

	GRFLX_UKRAINIAN   = 0x33,

    66

	GRFLX_ESTONIAN    = 0x34,

    67

	GRFLX_FINNISH     = 0x35,

    68

	GRFLX_PORTUGUESE  = 0x36,

    69

	GRFLX_BRAZILIAN   = 0x37,

    70

	GRFLX_CROATIAN    = 0x38,

    71

	GRFLX_TURKISH     = 0x3E,

    72

	GRFLX_UNSPECIFIED = 0x7F,

    73

} grf_language;

    74

    75

    76

typedef struct iso_grf {

    77

	char code[6];

    78

	byte grfLangID;

    79

} iso_grf;

    80

    81

/**

    82

 * ISO code VS NewGrf langID conversion array.

    83

 * This array is used in two ways:

    84

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

    85

 *   with newgrf bit positionning language id

    86

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

    87

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

    88

 */

    89

const iso_grf iso_codes[] = {

    90

	{"en_US", GRFLX_AMERICAN},

    91

	{"en_GB", GRFLX_ENGLISH},

    92

	{"de_DE", GRFLX_GERMAN},

    93

	{"fr_FR", GRFLX_FRENCH},

    94

	{"es_ES", GRFLX_SPANISH},

    95

	{"af_ZA", GRFLX_AFRIKAANS},

    96

	{"hr_HR", GRFLX_CROATIAN},

    97

	{"cs_CS", GRFLX_CZECH},

    98

	{"ca_ES", GRFLX_CATALAN},

    99

	{"da_DA", GRFLX_DANISH},

   100

	{"nl_NL", GRFLX_DUTCH},

   101

	{"et_ET", GRFLX_ESTONIAN},

   102

	{"fi_FI", GRFLX_FINNISH},

   103

	{"fy_NL", GRFLX_FRISIAN},

   104

	{"gl_ES", GRFLX_GALICIAN},

   105

	{"el_GR", GRFLX_GREEK},

   106

	{"hu_HU", GRFLX_HUNGARIAN},

   107

	{"is_IS", GRFLX_ICELANDIC},

   108

	{"it_IT", GRFLX_ITALIAN},

   109

	{"lv_LV", GRFLX_LATVIAN},

   110

	{"lt_LT", GRFLX_LITHUANIAN},

   111

	{"nb_NO", GRFLX_NORWEGIAN},

   112

	{"pl_PL", GRFLX_POLISH},

   113

	{"pt_PT", GRFLX_PORTUGUESE},

   114

	{"pt_BR", GRFLX_BRAZILIAN},

   115

	{"ro_RO", GRFLX_ROMANIAN},

   116

	{"ru_RU", GRFLX_RUSSIAN},

   117

	{"sk_SK", GRFLX_SLOVAK},

   118

	{"sl_SL", GRFLX_SLOVENIAN},

   119

	{"sv_SE", GRFLX_SWEDISH},

   120

	{"tr_TR", GRFLX_TURKISH},

   121

	{"uk_UA", GRFLX_UKRAINIAN},

   122

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

   123

};

   124

   125

   126

static uint _num_grf_texts = 0;

   127

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

   128

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

   129

   130

   131

static void TranslateTTDPatchCodes(char *str)

   132

{

   133

	char *c;

   134

   135

	for (c = str; *c != '\0'; c++) {

   136

		switch ((byte)*c) {

   137

			case 0x01: c++; break;

   138

			case 0x0D: *c = 10; break;

   139

			case 0x0E: *c = 8; break;

   140

			case 0x0F: *c = 9; break;

   141

			case 0x1F: *c = 2; c += 2; break;

   142

			case 0x7B:

   143

			case 0x7C:

   144

			case 0x7D:

   145

			case 0x7E: *c = 0x8E; break;

   146

			case 0x81: c += 2; break;

   147

			case 0x85: *c = 0x86; break;

   148

			case 0x88: *c = 15; break;

   149

			case 0x89: *c = 16; break;

   150

			case 0x8A: *c = 17; break;

   151

			case 0x8B: *c = 18; break;

   152

			case 0x8C: *c = 19; break;

   153

			case 0x8D: *c = 20; break;

   154

			case 0x8E: *c = 21; break;

   155

			case 0x8F: *c = 22; break;

   156

			case 0x90: *c = 23; break;

   157

			case 0x91: *c = 24; break;

   158

			case 0x92: *c = 25; break;

   159

			case 0x93: *c = 26; break;

   160

			case 0x94: *c = 27; break;

   161

			case 0x95: *c = 28; break;

   162

			case 0x96: *c = 29; break;

   163

			case 0x97: *c = 30; break;

   164

			case 0x98: *c = 31; break;

   165

			default:

   166

				/* Validate any unhandled character */

   167

				if (!IsValidAsciiChar(*c)) *c = '?';

   168

				break;

   169

		}

   170

	}

   171

}

   172

   173

   174

/**

   175

 * Add the new read string into our structure.

   176

 */

   177

StringID AddGRFString(uint32 grfid, uint16 stringid, byte langid_to_add, bool new_scheme, const char *text_to_add, StringID def_string)

   178

{

   179

	GRFText *newtext;

   180

	uint id;

   181

   182

	/* When working with the old language scheme (grf_version is less than 7) and

   183

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

   184

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

   185

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

   186

	 * actually translated.

   187

	 */

   188

	if (!new_scheme) {

   189

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

   190

			langid_to_add = GRFLX_ENGLISH;

   191

		} else {

   192

			StringID ret = STR_EMPTY;

   193

			if (langid_to_add & GRFLB_GERMAN)  ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_GERMAN,  true, text_to_add, def_string);

   194

			if (langid_to_add & GRFLB_FRENCH)  ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_FRENCH,  true, text_to_add, def_string);

   195

			if (langid_to_add & GRFLB_SPANISH) ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_SPANISH, true, text_to_add, def_string);

   196

			return ret;

   197

		}

   198

	}

   199

   200

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

   201

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

   202

			break;

   203

		}

   204

	}

   205

   206

	/* Too many strings allocated, return empty */

   207

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

   208

   209

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

   210

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

   211

	newtext->text   = strdup(text_to_add);

   212

	newtext->next   = NULL;

   213

   214

	TranslateTTDPatchCodes(newtext->text);

   215

   216

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

   217

	if (id == _num_grf_texts) _num_grf_texts++;

   218

   219

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

   220

		_grf_text[id].grfid      = grfid;

   221

		_grf_text[id].stringid   = stringid;

   222

		_grf_text[id].def_string = def_string;

   223

		_grf_text[id].textholder = newtext;

   224

	} else {

   225

		GRFText *textptr = _grf_text[id].textholder;

   226

		while (textptr->next != NULL) textptr = textptr->next;

   227

		textptr->next = newtext;

   228

	}

   229

   230

	DEBUG(grf, 2)("Added 0x%X: grfid 0x%X string 0x%X lang 0x%X string %s", id, grfid, stringid, newtext->langid, newtext->text);

   231

   232

	return (GRFTAB << TABSIZE) + id;

   233

}

   234

   235

   236

/**

   237

 * Returns the index for this stringid associated with its grfID

   238

 */

   239

StringID GetGRFStringID(uint32 grfid, uint16 stringid)

   240

{

   241

	uint id;

   242

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

   243

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

   244

			return (GRFTAB << TABSIZE) + id;

   245

		}

   246

	}

   247

   248

	return STR_UNDEFINED;

   249

}

   250

   251

   252

char *GetGRFString(char *buff, uint16 stringid)

   253

{

   254

	GRFText *search_text;

   255

	GRFText *default_text = NULL;

   256

   257

	assert(_grf_text[stringid].grfid != 0);

   258

	/*Search the list of lang-strings of this stringid for current lang */

   259

	for (search_text = _grf_text[stringid].textholder; search_text != NULL; search_text = search_text->next) {

   260

		if (search_text->langid == _currentLangID) {

   261

			return strecpy(buff, search_text->text, NULL);

   262

		}

   263

   264

		/* If the current string is English or American, set it as the

   265

		 * fallback language if the specific language isn't available. */

   266

		if (search_text->langid == GRFLX_ENGLISH || search_text->langid == GRFLX_AMERICAN) {

   267

			default_text = search_text;

   268

		}

   269

	}

   270

   271

	/* If there is a fallback string, return that */

   272

	if (default_text != NULL) return strecpy(buff, default_text->text, NULL);

   273

   274

	/* Use the default string ID if the fallback string isn't available */

   275

	return GetString(buff, _grf_text[stringid].def_string);

   276

}

   277

   278

/**

   279

 * Equivalence Setter function between game and newgrf langID.

   280

 * This function will adjust _currentLangID as to what is the LangID

   281

 * of the current language set by the user.

   282

 * The array iso_codes will be used to find that match.

   283

 * If not found, it will have to be standard english

   284

 * This function is called after the user changed language,

   285

 * from strings.c:ReadLanguagePack

   286

 * @param iso code of current selection

   287

 */

   288

void SetCurrentGrfLangID(const char *iso_name)

   289

{

   290

	byte ret,i;

   291

   292

	/* Use English by default, if we can't match up the iso_code. */

   293

	ret = GRFLX_ENGLISH;

   294

   295

	for (i=0; i < lengthof(iso_codes); i++) {

   296

		if (strncmp(iso_codes[i].code, iso_name, strlen(iso_codes[i].code)) == 0) {

   297

			/* We found a match, so let's use it. */

   298

			ret = i;

   299

			break;

   300

		}

   301

	}

   302

	_currentLangID = ret;

   303

}

   304

   305

/**

   306

 * House cleaning.

   307

 * Remove all strings and reset the text counter.

   308

 */

   309

void CleanUpStrings(void)

   310

{

   311

	uint id;

   312

   313

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

   314

		GRFText *grftext = _grf_text[id].textholder;

   315

		while (grftext != NULL) {

   316

			GRFText *grftext2 = grftext->next;

   317

			free(grftext->text);

   318

			free(grftext);

   319

			grftext = grftext2;

   320

		}

   321

		_grf_text[id].grfid      = 0;

   322

		_grf_text[id].stringid   = 0;

   323

		_grf_text[id].textholder = NULL;

   324

	}

   325

   326

	_num_grf_texts = 0;

   327

}