1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
/* $Id$ */
/** @file
* Implementation of Action 04 "universal holder" structure and functions.
* This file implements a linked-lists of strings,
* holding everything that the newgrf action 04 will send over to OpenTTD.
* One of the biggest problems is that Dynamic lang Array uses ISO codes
* as way to identifying current user lang, while newgrf uses bit shift codes
* not related to ISO. So equivalence functionnality had to be set.
*/
#include "stdafx.h"
#include "debug.h"
#include "openttd.h"
#include "string.h"
#include "variables.h"
#include "macros.h"
#include "table/strings.h"
#include "newgrf_text.h"
#define GRFTAB 28
#define TABSIZE 11
/**
* Explains the newgrf shift bit positionning.
* the grf base will not be used in order to find the string, but rather for
* jumping from standard langID scheme to the new one.
*/
typedef enum grf_base_languages {
GRFLB_AMERICAN = 0x01,
GRFLB_ENGLISH = 0x02,
GRFLB_GERMAN = 0x04,
GRFLB_FRENCH = 0x08,
GRFLB_SPANISH = 0x10,
GRFLB_GENERIC = 0x80,
} grf_base_language;
typedef enum grf_extended_languages {
GRFLX_AMERICAN = 0x00,
GRFLX_ENGLISH = 0x01,
GRFLX_GERMAN = 0x02,
GRFLX_FRENCH = 0x03,
GRFLX_SPANISH = 0x04,
GRFLX_RUSSIAN = 0x07,
GRFLX_CZECH = 0x15,
GRFLX_SLOVAK = 0x16,
GRFLX_DEUTCH = 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_SEWDISH = 0x2E,
GRFLX_NORWEGIAN = 0x2F,
GRFLX_POLISH = 0x30,
GRFLX_GALICIAN = 0x31,
GRFLX_FRISIAN = 0x32,
GRFLX_ESTONIAN = 0x34,
GRFLX_FINNISH = 0x35,
GRFLX_PORTUGUESE = 0x36,
GRFLX_BRAZIZILAN = 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[MAX_LANG] = {
{"en_US", GRFLX_AMERICAN},
{"en_GB", GRFLX_ENGLISH},
{"de", GRFLX_GERMAN},
{"fr", GRFLX_FRENCH},
{"es", GRFLX_SPANISH},
{"cs", GRFLX_CZECH},
{"ca", GRFLX_CATALAN},
{"da", GRFLX_DANISH},
{"nl", GRFLX_DEUTCH},
{"et", GRFLX_ESTONIAN},
{"fi", GRFLX_FINNISH},
{"fy", GRFLX_FRISIAN},
{"gl", GRFLX_GALICIAN},
{"hu", GRFLX_HUNGARIAN},
{"is", GRFLX_ICELANDIC},
{"it", GRFLX_ITALIAN},
{"lv", GRFLX_LATVIAN},
{"lt", GRFLX_LITHUANIAN},
{"nb", GRFLX_NORWEGIAN},
{"pl", GRFLX_POLISH},
{"pt", GRFLX_PORTUGUESE},
{"ro", GRFLX_ROMANIAN},
{"ru", GRFLX_RUSSIAN},
{"sk", GRFLX_SLOVAK},
{"sl", GRFLX_SLOVENIAN},
{"sv", GRFLX_SEWDISH},
{"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.
/**
* Add the new read stirng into our structure.
* TODO : ajust the old scheme to the new one for german,french and spanish
*/
StringID AddGRFString(uint32 grfid, uint16 stringid, byte langid_to_add, const char *text_to_add)
{
uint id;
GRFText *newtext = calloc(1, sizeof(*newtext));
newtext->langid = langid_to_add;
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;
/* Raise the number of strings added*/
if (id == _num_grf_texts) _num_grf_texts++;
/* When working with old scheme (BIT 6 of langid is clear) and
* English or american is among the set bits, simply add it as
* english on new scheme, as langid = 1.
* If there are more langid, we simply don't need them
*/
if (!HASBIT(6,langid_to_add)) {
if (HASBITS( GRFLB_AMERICAN | GRFLB_ENGLISH, langid_to_add)) {
newtext->langid = langid_to_add = GRFLX_ENGLISH;
} else {
/* If old scheme and not english nor american, scanning will
* have to be done. At this stage, only 3 are remaining:
* german,french and spanish : 0x04=2,0x08=3,0x10=4
*/
}
}
if (_grf_text[id].textholder == NULL) {
_grf_text[id].grfid = grfid;
_grf_text[id].stringid = stringid;
_grf_text[id].textholder = newtext;
} else {
GRFText *textptr = _grf_text[id].textholder;
while (textptr->next != NULL) textptr = textptr->next;
textptr->next = newtext;
}
debug("Added %x: grfid %x string %x lang %x string %s", id, grfid, stringid, langid_to_add, newtext->text);
return (GRFTAB << TABSIZE) + id;
}
/**
* Returns the index for this stringid associated with its grfID
*/
StringID GetGRFStringID(uint32 grfid, uint16 stringid)
{
uint id;
for (id = 0; id < _num_grf_texts; id++) {
if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {
return (GRFTAB << TABSIZE) + id;
}
}
return STR_UNDEFINED;
}
char *GetGRFString(char *buff, uint16 stringid)
{
GRFText *search_text;
assert(_grf_text[stringid].grfid != 0);
/*Search the list of lang-strings of this stringid for current lang */
for (search_text = _grf_text[stringid].textholder; search_text != NULL; search_text = search_text->next) {
if (search_text->langid == _currentLangID){
return strecpy(buff, search_text->text, NULL);
}
}
/* Use the first text if the specific language isn't available */
return strecpy(buff, _grf_text[stringid].textholder->text, NULL);
}
/**
* Equivalence Setter function between game and newgrf langID.
* This function will adjust _currentLangID as to what is the LangID
* of the current language set by the user.
* The array iso_codes will be used to find that match.
* If not found, it will have to be standard english
* This function is called after the user changed language,
* from strings.c:ReadLanguagePack
* @param iso code of current selection
*/
void SetCurrentGrfLangID( const char *iso_name )
{
byte ret,i;
ret = GRFLX_ENGLISH; //by default, english (not american) will be used
for (i=0; i < MAX_LANG+1; i++) {
if (strcmp(iso_codes[i].code, iso_name)==0){ //we have a match?
ret = i; //we'll use this one then.
break;
}
}
_currentLangID = ret;
}
/**
* House cleaning.
* TODO : Have to be written.
*/
void CleanUpStrings(void)
{
uint id;
GRFText *text_to_clear;
for (id = 0; id < _num_grf_texts; id++) {
text_to_clear = _grf_text[id].textholder;
}
}
|