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