Cleanup: spelling
[blender-staging.git] / source / blender / blentranslation / intern / blt_lang.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version. 
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2008 Blender Foundation.
19  * All rights reserved.
20  * 
21  * Contributor(s): Blender Foundation.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/blentranslation/intern/blt_lang.c
27  *  \ingroup blt
28  *
29  * Main internationalization functions to set the locale and query available languages.
30  */
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 #ifndef _WIN32
37 #  include <locale.h>
38 #endif
39
40 #include "RNA_types.h"
41
42 #include "BLT_translation.h"
43 #include "BLT_lang.h"  /* own include */
44
45 #include "BLI_fileops.h"
46 #include "BLI_linklist.h"
47 #include "BLI_path_util.h"
48 #include "BLI_string.h"
49 #include "BLI_utildefines.h"
50
51 #include "BKE_appdir.h"
52
53 #include "DNA_userdef_types.h"
54
55 #include "MEM_guardedalloc.h"
56
57 #ifdef WITH_INTERNATIONAL
58
59 #include "boost_locale_wrapper.h"
60
61 /* Locale options. */
62 static const char **locales = NULL;
63 static int num_locales = 0;
64 static EnumPropertyItem *locales_menu = NULL;
65 static int num_locales_menu = 0;
66
67 static void free_locales(void)
68 {
69         if (locales) {
70                 int idx = num_locales_menu - 1; /* Last item does not need to be freed! */
71                 while (idx--) {
72                         MEM_freeN((void *)locales_menu[idx].identifier);
73                         MEM_freeN((void *)locales_menu[idx].name);
74                         MEM_freeN((void *)locales_menu[idx].description); /* Also frees locales's relevant value! */
75                 }
76
77                 MEM_freeN((void *)locales);
78                 locales = NULL;
79         }
80         if (locales_menu) {
81                 MEM_freeN(locales_menu);
82                 locales_menu = NULL;
83         }
84         num_locales = num_locales_menu = 0;
85 }
86
87 static void fill_locales(void)
88 {
89         const char * const languages_path = BKE_appdir_folder_id(BLENDER_DATAFILES, "locale");
90         char languages[FILE_MAX];
91         LinkNode *lines = NULL, *line;
92         char *str;
93         int idx = 0;
94
95         free_locales();
96
97         BLI_join_dirfile(languages, FILE_MAX, languages_path, "languages");
98         line = lines = BLI_file_read_as_lines(languages);
99
100         /* This whole "parsing" code is a bit weak, in that it expects strictly formatted input file...
101          * Should not be a problem, though, as this file is script-generated! */
102
103         /* First loop to find highest locale ID */
104         while (line) {
105                 int t;
106                 str = (char *)line->link;
107                 if (str[0] == '#' || str[0] == '\0') {
108                         line = line->next;
109                         continue; /* Comment or void... */
110                 }
111                 t = atoi(str);
112                 if (t >= num_locales)
113                         num_locales = t + 1;
114                 num_locales_menu++;
115                 line = line->next;
116         }
117         num_locales_menu++; /* The "closing" void item... */
118
119         /* And now, build locales and locale_menu! */
120         locales_menu = MEM_callocN(num_locales_menu * sizeof(EnumPropertyItem), __func__);
121         line = lines;
122         /* Do not allocate locales with zero-sized mem, as LOCALE macro uses NULL locales as invalid marker! */
123         if (num_locales > 0) {
124                 locales = MEM_callocN(num_locales * sizeof(char *), __func__);
125                 while (line) {
126                         int id;
127                         char *loc, *sep1, *sep2, *sep3;
128
129                         str = (char *)line->link;
130                         if (str[0] == '#' || str[0] == '\0') {
131                                 line = line->next;
132                                 continue;
133                         }
134
135                         id = atoi(str);
136                         sep1 = strchr(str, ':');
137                         if (sep1) {
138                                 sep1++;
139                                 sep2 = strchr(sep1, ':');
140                                 if (sep2) {
141                                         locales_menu[idx].value = id;
142                                         locales_menu[idx].icon = 0;
143                                         locales_menu[idx].name = BLI_strdupn(sep1, sep2 - sep1);
144
145                                         sep2++;
146                                         sep3 = strchr(sep2, ':');
147
148                                         if (sep3) {
149                                                 locales_menu[idx].identifier = loc = BLI_strdupn(sep2, sep3 - sep2);
150                                         }
151                                         else {
152                                                 locales_menu[idx].identifier = loc = BLI_strdup(sep2);
153                                         }
154
155                                         if (id == 0) {
156                                                 /* The DEFAULT item... */
157                                                 if (BLI_strnlen(loc, 2)) {
158                                                         locales[id] = locales_menu[idx].description = BLI_strdup("");
159                                                 }
160                                                 /* Menu "label", not to be stored in locales! */
161                                                 else {
162                                                         locales_menu[idx].description = BLI_strdup("");
163                                                 }
164                                         }
165                                         else {
166                                                 locales[id] = locales_menu[idx].description = BLI_strdup(loc);
167                                         }
168                                         idx++;
169                                 }
170                         }
171
172                         line = line->next;
173                 }
174         }
175
176         /* Add closing item to menu! */
177         locales_menu[idx].identifier = NULL;
178         locales_menu[idx].value = locales_menu[idx].icon = 0;
179         locales_menu[idx].name = locales_menu[idx].description = "";
180
181         BLI_file_free_lines(lines);
182 }
183 #endif  /* WITH_INTERNATIONAL */
184
185 EnumPropertyItem *BLT_lang_RNA_enum_properties(void)
186 {
187 #ifdef WITH_INTERNATIONAL
188         return locales_menu;
189 #else
190         return NULL;
191 #endif
192 }
193
194 void BLT_lang_init(void)
195 {
196 #ifdef WITH_INTERNATIONAL
197         const char * const messagepath = BKE_appdir_folder_id(BLENDER_DATAFILES, "locale");
198 #endif
199
200         /* Make sure LANG is correct and wouldn't cause std::rumtime_error. */
201 #ifndef _WIN32
202         /* TODO(sergey): This code only ensures LANG is set properly, so later when
203          * Cycles will try to use file system API from boost there'll be no runtime
204          * exception generated by std::locale() which _requires_ having proper LANG
205          * set in the environment.
206          *
207          * Ideally we also need to ensure LC_ALL, LC_MESSAGES and others are also
208          * set to a proper value, but currently it's not a huge deal and doesn't
209          * cause any headache.
210          *
211          * Would also be good to find nicer way to check if LANG is correct.
212          */
213         const char *lang = getenv("LANG");
214         if (lang != NULL) {
215                 char *old_locale = setlocale(LC_ALL, NULL);
216                 /* Make a copy so subsequenct setlocale() doesn't interfere. */
217                 old_locale = BLI_strdup(old_locale);
218                 if (setlocale(LC_ALL, lang) == NULL) {
219                         setenv("LANG", "C", 1);
220                         printf("Warning: Falling back to the standard locale (\"C\")\n");
221                 }
222                 setlocale(LC_ALL, old_locale);
223                 MEM_freeN(old_locale);
224         }
225 #endif
226
227 #ifdef WITH_INTERNATIONAL
228         if (messagepath) {
229                 bl_locale_init(messagepath, TEXT_DOMAIN_NAME);
230                 fill_locales();
231         }
232         else {
233                 printf("%s: 'locale' data path for translations not found, continuing\n", __func__);
234         }
235 #else
236 #endif
237 }
238
239 void BLT_lang_free(void)
240 {
241 #ifdef WITH_INTERNATIONAL
242         free_locales();
243 #else
244 #endif
245 }
246
247 #ifdef WITH_INTERNATIONAL
248 #  define ULANGUAGE ((U.language >= 0 && U.language < num_locales) ? U.language : 0)
249 #  define LOCALE(_id) (locales ? locales[(_id)] : "")
250 #endif
251
252 void BLT_lang_set(const char *str)
253 {
254 #ifdef WITH_INTERNATIONAL
255         int ulang = ULANGUAGE;
256         const char *short_locale = str ? str : LOCALE(ulang);
257         const char *short_locale_utf8 = NULL;
258
259         if ((U.transopts & USER_DOTRANSLATE) == 0)
260                 return;
261
262         /* We want to avoid locales like '.UTF-8'! */
263         if (short_locale[0]) {
264                 /* Hurrey! encoding needs to be placed *before* variant! */
265                 char *variant = strchr(short_locale, '@');
266                 if (variant) {
267                         char *locale = BLI_strdupn(short_locale, variant - short_locale);
268                         short_locale_utf8 = BLI_sprintfN("%s.UTF-8%s", locale, variant);
269                         MEM_freeN(locale);
270                 }
271                 else {
272                         short_locale_utf8 = BLI_sprintfN("%s.UTF-8", short_locale);
273                 }
274                 bl_locale_set(short_locale_utf8);
275                 MEM_freeN((void *)short_locale_utf8);
276         }
277         else {
278                 bl_locale_set(short_locale);
279         }
280 #else
281         (void)str;
282 #endif
283 }
284
285 /* Get the current locale (short code, e.g. es_ES). */
286 const char *BLT_lang_get(void)
287 {
288 #ifdef WITH_INTERNATIONAL
289         if (BLT_translate()) {
290                 const char *locale = LOCALE(ULANGUAGE);
291                 if (locale[0] == '\0') {
292                         /* Default locale, we have to find which one we are actually using! */
293                         locale = bl_locale_get();
294                 }
295                 return locale;
296         }
297         return "en_US";  /* Kind of default locale in Blender when no translation enabled. */
298 #else
299         return "";
300 #endif
301 }
302
303 #undef LOCALE
304 #undef ULANGUAGE
305
306 /* Get locale's elements (if relevant pointer is not NULL and element actually exists, e.g. if there is no variant,
307  * *variant and *language_variant will always be NULL).
308  * Non-null elements are always MEM_mallocN'ed, it's the caller's responsibility to free them.
309  * NOTE: Keep that one always available, you never know, may become useful even in no-WITH_INTERNATIONAL context...
310  */
311 void BLT_lang_locale_explode(
312         const char *locale, char **language, char **country, char **variant,
313         char **language_country, char **language_variant)
314 {
315         char *m1, *m2, *_t = NULL;
316
317         m1 = strchr(locale, '_');
318         m2 = strchr(locale, '@');
319
320         if (language || language_variant) {
321                 if (m1 || m2) {
322                         _t = m1 ? BLI_strdupn(locale, m1 - locale) : BLI_strdupn(locale, m2 - locale);
323                         if (language)
324                                 *language = _t;
325                 }
326                 else if (language) {
327                         *language = BLI_strdup(locale);
328                 }
329         }
330         if (country) {
331                 if (m1)
332                         *country = m2 ? BLI_strdupn(m1 + 1, m2 - (m1 + 1)) : BLI_strdup(m1 + 1);
333                 else
334                         *country = NULL;
335         }
336         if (variant) {
337                 if (m2)
338                         *variant = BLI_strdup(m2 + 1);
339                 else
340                         *variant = NULL;
341         }
342         if (language_country) {
343                 if (m1)
344                         *language_country = m2 ? BLI_strdupn(locale, m2 - locale) : BLI_strdup(locale);
345                 else
346                         *language_country = NULL;
347         }
348         if (language_variant) {
349                 if (m2)
350                         *language_variant = m1 ? BLI_strdupcat(_t, m2) : BLI_strdup(locale);
351                 else
352                         *language_variant = NULL;
353         }
354         if (_t && !language) {
355                 MEM_freeN(_t);
356         }
357 }