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 "variables.h"

    17

#include "macros.h"

    18

#include "table/strings.h"

    19

#include "newgrf_text.h"

    20

    21

#define GRFTAB  28

    22

#define TABSIZE 11

    23

    24

/**

    25

 * Explains the newgrf shift bit positionning.

    26

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

    27

 * jumping from standard langID scheme to the new one.

    28

 */

    29

typedef enum grf_base_languages {

    30

	GRFLB_AMERICAN    = 0x01,

    31

	GRFLB_ENGLISH     = 0x02,

    32

	GRFLB_GERMAN      = 0x04,

    33

	GRFLB_FRENCH      = 0x08,

    34

	GRFLB_SPANISH     = 0x10,

    35

	GRFLB_GENERIC     = 0x80,

    36

} grf_base_language;

    37

    38

typedef enum grf_extended_languages {

    39

	GRFLX_AMERICAN    = 0x00,

    40

	GRFLX_ENGLISH     = 0x01,

    41

	GRFLX_GERMAN      = 0x02,

    42

	GRFLX_FRENCH      = 0x03,

    43

	GRFLX_SPANISH     = 0x04,

    44

	GRFLX_RUSSIAN     = 0x07,

    45

	GRFLX_CZECH       = 0x15,

    46

	GRFLX_SLOVAK      = 0x16,

    47

	GRFLX_DEUTCH      = 0x1F,

    48

	GRFLX_CATALAN     = 0x22,

    49

	GRFLX_HUNGARIAN   = 0x24,

    50

	GRFLX_ITALIAN     = 0x27,

    51

	GRFLX_ROMANIAN    = 0x28,

    52

	GRFLX_ICELANDIC   = 0x29,

    53

	GRFLX_LATVIAN     = 0x2A,

    54

	GRFLX_LITHUANIAN  = 0x2B,

    55

	GRFLX_SLOVENIAN   = 0x2C,

    56

	GRFLX_DANISH      = 0x2D,

    57

	GRFLX_SEWDISH     = 0x2E,

    58

	GRFLX_NORWEGIAN   = 0x2F,

    59

	GRFLX_POLISH      = 0x30,

    60

	GRFLX_GALICIAN    = 0x31,

    61

	GRFLX_FRISIAN     = 0x32,

    62

	GRFLX_ESTONIAN    = 0x34,

    63

	GRFLX_FINNISH     = 0x35,

    64

	GRFLX_PORTUGUESE  = 0x36,

    65

	GRFLX_BRAZIZILAN  = 0x37,

    66

	GRFLX_TURKISH     = 0x3E,

    67

} grf_language;

    68

    69

    70

typedef struct iso_grf {

    71

	char code[6];

    72

	byte grfLangID;

    73

} iso_grf;

    74

    75

/**

    76

 * ISO code VS NewGrf langID conversion array.

    77

 * This array is used in two ways:

    78

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

    79

 *   with newgrf bit positionning language id

    80

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

    81

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

    82

 */

    83

const iso_grf iso_codes[MAX_LANG] = {

    84

	{"en_US", GRFLX_AMERICAN},

    85

	{"en_GB", GRFLX_ENGLISH},

    86

	{"de",    GRFLX_GERMAN},

    87

	{"fr",    GRFLX_FRENCH},

    88

	{"es",    GRFLX_SPANISH},

    89

	{"cs",    GRFLX_CZECH},

    90

	{"ca",    GRFLX_CATALAN},

    91

	{"da",    GRFLX_DANISH},

    92

	{"nl",    GRFLX_DEUTCH},

    93

	{"et",    GRFLX_ESTONIAN},

    94

	{"fi",    GRFLX_FINNISH},

    95

	{"fy",    GRFLX_FRISIAN},

    96

	{"gl",    GRFLX_GALICIAN},

    97

	{"hu",    GRFLX_HUNGARIAN},

    98

	{"is",    GRFLX_ICELANDIC},

    99

	{"it",    GRFLX_ITALIAN},

   100

	{"lv",    GRFLX_LATVIAN},

   101

	{"lt",    GRFLX_LITHUANIAN},

   102

	{"nb",    GRFLX_NORWEGIAN},

   103

	{"pl",    GRFLX_POLISH},

   104

	{"pt",    GRFLX_PORTUGUESE},

   105

	{"ro",    GRFLX_ROMANIAN},

   106

	{"ru",    GRFLX_RUSSIAN},

   107

	{"sk",    GRFLX_SLOVAK},

   108

	{"sl",    GRFLX_SLOVENIAN},

   109

	{"sv",    GRFLX_SEWDISH},

   110

	{"tr",    GRFLX_TURKISH},

   111

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

   112

};

   113

   114

   115

static uint _num_grf_texts = 0;

   116

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

   117

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

   118

   119

   120

/**

   121

 * Add the new read stirng into our structure.

   122

 * TODO : ajust the old scheme to the new one for german,french and spanish

   123

 */

   124

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

   125

{

   126

	GRFText *newtext;

   127

	uint id;

   128

   129

	/* When working with the old language scheme (bit 6 of langid is clear) and

   130

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

   131

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

   132

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

   133

	 * actually translated.

   134

	 */

   135

	if (!HASBIT(langid_to_add, 6)) {

   136

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

   137

			langid_to_add = GRFLX_ENGLISH;

   138

		} else {

   139

			StringID ret = STR_EMPTY;

   140

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

   141

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

   142

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

   143

			return ret;

   144

		}

   145

	}

   146

   147

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

   148

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

   149

	newtext->text   = strdup(text_to_add);

   150

	newtext->next   = NULL;

   151

   152

	str_validate(newtext->text);

   153

   154

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

   155

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

   156

			break;

   157

		}

   158

	}

   159

   160

	/* Too many strings allocated, return empty */

   161

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

   162

   163

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

   164

	if (id == _num_grf_texts) _num_grf_texts++;

   165

   166

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

   167

		_grf_text[id].grfid      = grfid;

   168

		_grf_text[id].stringid   = stringid;

   169

		_grf_text[id].textholder = newtext;

   170

	} else {

   171

		GRFText *textptr = _grf_text[id].textholder;

   172

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

   173

		textptr->next = newtext;

   174

	}

   175

   176

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

   177

   178

	return (GRFTAB << TABSIZE) + id;

   179

}

   180

   181

   182

/**

   183

 * Returns the index for this stringid associated with its grfID

   184

 */

   185

StringID GetGRFStringID(uint32 grfid, uint16 stringid)

   186

{

   187

	uint id;

   188

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

   189

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

   190

			return (GRFTAB << TABSIZE) + id;

   191

		}

   192

	}

   193

   194

	return STR_UNDEFINED;

   195

}

   196

   197

   198

char *GetGRFString(char *buff, uint16 stringid)

   199

{

   200

	GRFText *search_text;

   201

   202

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

   203

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

   204

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

   205

		if (search_text->langid == _currentLangID){

   206

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

   207

		}

   208

	}

   209

   210

	/* Use the first text if the specific language isn't available */

   211

	return strecpy(buff, _grf_text[stringid].textholder->text, NULL);

   212

}

   213

   214

/**

   215

 * Equivalence Setter function between game and newgrf langID.

   216

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

   217

 * of the current language set by the user.

   218

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

   219

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

   220

 * This function is called after the user changed language,

   221

 * from strings.c:ReadLanguagePack

   222

 * @param iso code of current selection

   223

 */

   224

void SetCurrentGrfLangID( const char *iso_name )

   225

{

   226

	byte ret,i;

   227

   228

	ret = GRFLX_ENGLISH;  //by default, english (not american) will be used

   229

   230

	for (i=0; i < MAX_LANG+1; i++) {

   231

		if (strcmp(iso_codes[i].code, iso_name)==0){  //we have a match?

   232

			ret = i;                                  //we'll use this one then.

   233

			break;

   234

		}

   235

	}

   236

	_currentLangID = ret;

   237

}

   238

   239

/**

   240

 * House cleaning.

   241

 * Remove all strings and reset the text counter.

   242

 */

   243

void CleanUpStrings(void)

   244

{

   245

	uint id;

   246

   247

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

   248

		GRFText *grftext = _grf_text[id].textholder;

   249

		while (grftext != NULL) {

   250

			GRFText *grftext2 = grftext->next;

   251

			free(grftext->text);

   252

			free(grftext);

   253

			grftext = grftext2;

   254

		}

   255

		_grf_text[id].grfid      = 0;

   256

		_grf_text[id].stringid   = 0;

   257

		_grf_text[id].textholder = NULL;

   258

	}

   259

   260

	_num_grf_texts = 0;

   261

}