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