Merge branch 'blender2.7'
[blender.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_path_util.h"
46 #include "BLI_string.h"
47 #include "BLI_utildefines.h"
48
49 #include "BKE_appdir.h"
50
51 #include "DNA_userdef_types.h"
52
53 #include "MEM_guardedalloc.h"
54
55 /* Cached IME support flags */
56 static bool ime_is_lang_supported = false;
57 static void blt_lang_check_ime_supported(void);
58
59 #ifdef WITH_INTERNATIONAL
60
61 #include "BLI_fileops.h"
62 #include "BLI_linklist.h"
63
64 #include "boost_locale_wrapper.h"
65
66 /* Locale options. */
67 static const char **locales = NULL;
68 static int num_locales = 0;
69 static EnumPropertyItem *locales_menu = NULL;
70 static int num_locales_menu = 0;
71
72 static void free_locales(void)
73 {
74         if (locales) {
75                 int idx = num_locales_menu - 1; /* Last item does not need to be freed! */
76                 while (idx--) {
77                         MEM_freeN((void *)locales_menu[idx].identifier);
78                         MEM_freeN((void *)locales_menu[idx].name);
79                         MEM_freeN((void *)locales_menu[idx].description); /* Also frees locales's relevant value! */
80                 }
81
82                 MEM_freeN((void *)locales);
83                 locales = NULL;
84         }
85         if (locales_menu) {
86                 MEM_freeN(locales_menu);
87                 locales_menu = NULL;
88         }
89         num_locales = num_locales_menu = 0;
90 }
91
92 static void fill_locales(void)
93 {
94         const char * const languages_path = BKE_appdir_folder_id(BLENDER_DATAFILES, "locale");
95         char languages[FILE_MAX];
96         LinkNode *lines = NULL, *line;
97         char *str;
98         int idx = 0;
99
100         free_locales();
101
102         BLI_join_dirfile(languages, FILE_MAX, languages_path, "languages");
103         line = lines = BLI_file_read_as_lines(languages);
104
105         /* This whole "parsing" code is a bit weak, in that it expects strictly formatted input file...
106          * Should not be a problem, though, as this file is script-generated! */
107
108         /* First loop to find highest locale ID */
109         while (line) {
110                 int t;
111                 str = (char *)line->link;
112                 if (str[0] == '#' || str[0] == '\0') {
113                         line = line->next;
114                         continue; /* Comment or void... */
115                 }
116                 t = atoi(str);
117                 if (t >= num_locales)
118                         num_locales = t + 1;
119                 num_locales_menu++;
120                 line = line->next;
121         }
122         num_locales_menu++; /* The "closing" void item... */
123
124         /* And now, build locales and locale_menu! */
125         locales_menu = MEM_callocN(num_locales_menu * sizeof(EnumPropertyItem), __func__);
126         line = lines;
127         /* Do not allocate locales with zero-sized mem, as LOCALE macro uses NULL locales as invalid marker! */
128         if (num_locales > 0) {
129                 locales = MEM_callocN(num_locales * sizeof(char *), __func__);
130                 while (line) {
131                         int id;
132                         char *loc, *sep1, *sep2, *sep3;
133
134                         str = (char *)line->link;
135                         if (str[0] == '#' || str[0] == '\0') {
136                                 line = line->next;
137                                 continue;
138                         }
139
140                         id = atoi(str);
141                         sep1 = strchr(str, ':');
142                         if (sep1) {
143                                 sep1++;
144                                 sep2 = strchr(sep1, ':');
145                                 if (sep2) {
146                                         locales_menu[idx].value = id;
147                                         locales_menu[idx].icon = 0;
148                                         locales_menu[idx].name = BLI_strdupn(sep1, sep2 - sep1);
149
150                                         sep2++;
151                                         sep3 = strchr(sep2, ':');
152
153                                         if (sep3) {
154                                                 locales_menu[idx].identifier = loc = BLI_strdupn(sep2, sep3 - sep2);
155                                         }
156                                         else {
157                                                 locales_menu[idx].identifier = loc = BLI_strdup(sep2);
158                                         }
159
160                                         if (id == 0) {
161                                                 /* The DEFAULT/Automatic item... */
162                                                 if (BLI_strnlen(loc, 2)) {
163                                                         locales[id] = "";
164                                                         /* Keep this tip in sync with the one in rna_userdef (rna_enum_language_default_items). */
165                                                         locales_menu[idx].description = BLI_strdup("Automatically choose system's defined language "
166                                                                                                    "if available, or fall-back to English");
167                                                 }
168                                                 /* Menu "label", not to be stored in locales! */
169                                                 else {
170                                                         locales_menu[idx].description = BLI_strdup("");
171                                                 }
172                                         }
173                                         else {
174                                                 locales[id] = locales_menu[idx].description = BLI_strdup(loc);
175                                         }
176                                         idx++;
177                                 }
178                         }
179
180                         line = line->next;
181                 }
182         }
183
184         /* Add closing item to menu! */
185         locales_menu[idx].identifier = NULL;
186         locales_menu[idx].value = locales_menu[idx].icon = 0;
187         locales_menu[idx].name = locales_menu[idx].description = "";
188
189         BLI_file_free_lines(lines);
190 }
191 #endif  /* WITH_INTERNATIONAL */
192
193 EnumPropertyItem *BLT_lang_RNA_enum_properties(void)
194 {
195 #ifdef WITH_INTERNATIONAL
196         return locales_menu;
197 #else
198         return NULL;
199 #endif
200 }
201
202 void BLT_lang_init(void)
203 {
204 #ifdef WITH_INTERNATIONAL
205         const char * const messagepath = BKE_appdir_folder_id(BLENDER_DATAFILES, "locale");
206 #endif
207
208         /* Make sure LANG is correct and wouldn't cause std::rumtime_error. */
209 #ifndef _WIN32
210         /* TODO(sergey): This code only ensures LANG is set properly, so later when
211          * Cycles will try to use file system API from boost there'll be no runtime
212          * exception generated by std::locale() which _requires_ having proper LANG
213          * set in the environment.
214          *
215          * Ideally we also need to ensure LC_ALL, LC_MESSAGES and others are also
216          * set to a proper value, but currently it's not a huge deal and doesn't
217          * cause any headache.
218          *
219          * Would also be good to find nicer way to check if LANG is correct.
220          */
221         const char *lang = BLI_getenv("LANG");
222         if (lang != NULL) {
223                 char *old_locale = setlocale(LC_ALL, NULL);
224                 /* Make a copy so subsequenct setlocale() doesn't interfere. */
225                 old_locale = BLI_strdup(old_locale);
226                 if (setlocale(LC_ALL, lang) == NULL) {
227                         setenv("LANG", "C", 1);
228                         printf("Warning: Falling back to the standard locale (\"C\")\n");
229                 }
230                 setlocale(LC_ALL, old_locale);
231                 MEM_freeN(old_locale);
232         }
233 #endif
234
235 #ifdef WITH_INTERNATIONAL
236         if (messagepath) {
237                 bl_locale_init(messagepath, TEXT_DOMAIN_NAME);
238                 fill_locales();
239         }
240         else {
241                 printf("%s: 'locale' data path for translations not found, continuing\n", __func__);
242         }
243 #else
244 #endif
245 }
246
247 void BLT_lang_free(void)
248 {
249 #ifdef WITH_INTERNATIONAL
250         free_locales();
251 #else
252 #endif
253 }
254
255 #ifdef WITH_INTERNATIONAL
256 #  define ULANGUAGE ((U.language >= 0 && U.language < num_locales) ? U.language : 0)
257 #  define LOCALE(_id) (locales ? locales[(_id)] : "")
258 #endif
259
260 void BLT_lang_set(const char *str)
261 {
262 #ifdef WITH_INTERNATIONAL
263         int ulang = ULANGUAGE;
264         const char *short_locale = str ? str : LOCALE(ulang);
265         const char *short_locale_utf8 = NULL;
266
267         if ((U.transopts & USER_DOTRANSLATE) == 0)
268                 return;
269
270         /* We want to avoid locales like '.UTF-8'! */
271         if (short_locale[0]) {
272                 /* Hurrey! encoding needs to be placed *before* variant! */
273                 char *variant = strchr(short_locale, '@');
274                 if (variant) {
275                         char *locale = BLI_strdupn(short_locale, variant - short_locale);
276                         short_locale_utf8 = BLI_sprintfN("%s.UTF-8%s", locale, variant);
277                         MEM_freeN(locale);
278                 }
279                 else {
280                         short_locale_utf8 = BLI_sprintfN("%s.UTF-8", short_locale);
281                 }
282                 bl_locale_set(short_locale_utf8);
283                 MEM_freeN((void *)short_locale_utf8);
284         }
285         else {
286                 bl_locale_set(short_locale);
287         }
288 #else
289         (void)str;
290 #endif
291         blt_lang_check_ime_supported();
292 }
293
294 /* Get the current locale (short code, e.g. es_ES). */
295 const char *BLT_lang_get(void)
296 {
297 #ifdef WITH_INTERNATIONAL
298         if (BLT_translate()) {
299                 const char *locale = LOCALE(ULANGUAGE);
300                 if (locale[0] == '\0') {
301                         /* Default locale, we have to find which one we are actually using! */
302                         locale = bl_locale_get();
303                 }
304                 return locale;
305         }
306         return "en_US";  /* Kind of default locale in Blender when no translation enabled. */
307 #else
308         return "";
309 #endif
310 }
311
312 #undef LOCALE
313 #undef ULANGUAGE
314
315 /* Get locale's elements (if relevant pointer is not NULL and element actually exists, e.g. if there is no variant,
316  * *variant and *language_variant will always be NULL).
317  * Non-null elements are always MEM_mallocN'ed, it's the caller's responsibility to free them.
318  * NOTE: Keep that one always available, you never know, may become useful even in no-WITH_INTERNATIONAL context...
319  */
320 void BLT_lang_locale_explode(
321         const char *locale, char **language, char **country, char **variant,
322         char **language_country, char **language_variant)
323 {
324         char *m1, *m2, *_t = NULL;
325
326         m1 = strchr(locale, '_');
327         m2 = strchr(locale, '@');
328
329         if (language || language_variant) {
330                 if (m1 || m2) {
331                         _t = m1 ? BLI_strdupn(locale, m1 - locale) : BLI_strdupn(locale, m2 - locale);
332                         if (language)
333                                 *language = _t;
334                 }
335                 else if (language) {
336                         *language = BLI_strdup(locale);
337                 }
338         }
339         if (country) {
340                 if (m1)
341                         *country = m2 ? BLI_strdupn(m1 + 1, m2 - (m1 + 1)) : BLI_strdup(m1 + 1);
342                 else
343                         *country = NULL;
344         }
345         if (variant) {
346                 if (m2)
347                         *variant = BLI_strdup(m2 + 1);
348                 else
349                         *variant = NULL;
350         }
351         if (language_country) {
352                 if (m1)
353                         *language_country = m2 ? BLI_strdupn(locale, m2 - locale) : BLI_strdup(locale);
354                 else
355                         *language_country = NULL;
356         }
357         if (language_variant) {
358                 if (m2)
359                         *language_variant = m1 ? BLI_strdupcat(_t, m2) : BLI_strdup(locale);
360                 else
361                         *language_variant = NULL;
362         }
363         if (_t && !language) {
364                 MEM_freeN(_t);
365         }
366 }
367
368 /* Test if the translation context allows IME input - used to
369  * avoid weird character drawing if IME inputs non-ascii chars.
370  */
371 static void blt_lang_check_ime_supported(void)
372 {
373 #ifdef WITH_INPUT_IME
374         const char *uilng = BLT_lang_get();
375         if (U.transopts & USER_DOTRANSLATE) {
376                 ime_is_lang_supported = STREQ(uilng, "zh_CN") ||
377                                         STREQ(uilng, "zh_TW") ||
378                                         STREQ(uilng, "ja_JP");
379         }
380         else {
381                 ime_is_lang_supported = false;
382         }
383 #else
384         ime_is_lang_supported = false;
385 #endif
386 }
387
388 bool BLT_lang_is_ime_supported(void)
389 {
390 #ifdef WITH_INPUT_IME
391         return ime_is_lang_supported;
392 #else
393         return false;
394 #endif
395 }