source/blender/blenfont/intern/blf_lang.c

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2008 Blender Foundation.
  21  * All rights reserved.
  22  *
  23  * Contributor(s): Blender Foundation.
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include "MEM_guardedalloc.h"
  33
  34 #include "DNA_listBase.h"
  35
  36 #include "BKE_utildefines.h"
  37
  38 #include "BLI_blenlib.h"
  39 #include "BLI_linklist.h"       /* linknode */
  40 #include "BLI_string.h"
  41
  42 #include "blf_internal_types.h"
  43
  44 // XXX 2.50 Remove this later.
  45 #ifdef WITH_FREETYPE2
  46 #include "FTF_Api.h"
  47 #endif
  48
  49 static ListBase global_lang= { NULL, NULL };
  50 static int global_tot_lang= 0;
  51 static int global_err_lang= 0;
  52
  53 int BLF_lang_error(void)
  54 {
  55         return(global_err_lang);
  56 }
  57
  58 char *BLF_lang_pup(void)
  59 {
  60         LangBLF *lme;
  61         static char string[1024];
  62         static char tmp[1024];
  63
  64         if(global_tot_lang == 0)
  65                 sprintf(string, "Choose Language: %%t|Language:  English %%x0");
  66         else {
  67                 lme= global_lang.first;
  68                 sprintf(string, "Choose Language: %%t");
  69                 while (lme) {
  70                         sprintf(tmp, "|Language:  %s %%x%d", lme->language, lme->id);
  71                         strcat(string, tmp);
  72                         lme= lme->next;
  73                 }
  74         }
  75
  76         return(string);
  77 }
  78
  79 LangBLF *blf_lang_find_by_id(short langid)
  80 {
  81         LangBLF *p;
  82
  83         p= global_lang.first;
  84         while (p) {
  85                 if (p->id == langid)
  86                         return(p);
  87                 p= p->next;
  88         }
  89         return(NULL);
  90 }
  91
  92 char *BLF_lang_find_code(short langid)
  93 {
  94         LangBLF *p;
  95
  96         p= blf_lang_find_by_id(langid);
  97         if (p)
  98                 return(p->code);
  99         return(NULL);
 100 }
 101
 102 void BLF_lang_set(int id)
 103 {
 104 #ifdef WITH_FREETYPE2
 105         LangBLF *lme;
 106
 107         // XXX 2.50 Remove this later, with ftfont
 108         lme= blf_lang_find_by_id(id);
 109         if(lme) FTF_SetLanguage(lme->code);
 110         else FTF_SetLanguage("en_US");
 111 #endif
 112 }
 113
 114 static void blf_lang_split(char *line, LangBLF* lme)
 115 {
 116         char *dpointchar= strchr(line, ':');
 117
 118         if (dpointchar) {
 119                 lme->code= BLI_strdup(dpointchar+1);
 120                 *(dpointchar)=0;
 121                 lme->language= BLI_strdup(line);
 122         } else {
 123                 lme->code= NULL;
 124                 lme->language= NULL;
 125                 /* XXX 2.50 bad call error("Invalid language file");
 126                  * If we set this to NULL, the function blf_lang_new
 127                  * drop the line and increment the error lang value
 128                  * so the init code can call BLF_lang_error to get
 129                  * the number of invalid lines and show the error.
 130                  */
 131         }
 132 }
 133
 134 LangBLF *blf_lang_find(char *s, int find_by)
 135 {
 136         LangBLF *p;
 137
 138         p= global_lang.first;
 139         while (p) {
 140                 if (find_by == BLF_LANG_FIND_BY_LINE) {
 141                         if (BLI_streq(s, p->line))
 142                                 return(p);
 143                 }
 144                 else if (find_by == BLF_LANG_FIND_BY_CODE) {
 145                         if (BLI_streq(s, p->code))
 146                                 return(p);
 147                 }
 148                 else if (find_by == BLF_LANG_FIND_BY_LANGUAGE) {
 149                         if (BLI_streq(s, p->language))
 150                                 return(p);
 151                 }
 152                 p= p->next;
 153         }
 154         return(NULL);
 155 }
 156
 157 static void blf_lang_new(char *line)
 158 {
 159         LangBLF *lme;
 160
 161         lme= blf_lang_find(line, BLF_LANG_FIND_BY_LINE);
 162         if (!lme) {
 163                 lme= MEM_mallocN(sizeof(LangBLF), "blf_lang_new");
 164                 lme->next= NULL;
 165                 lme->prev= NULL;
 166                 lme->line = BLI_strdup(line);
 167                 blf_lang_split(line, lme);
 168
 169                 if (lme->code && lme->language) {
 170                         lme->id = global_tot_lang;
 171                         global_tot_lang++;
 172                         BLI_addhead(&global_lang, lme);
 173                 }
 174                 else {
 175                         global_err_lang++;
 176                         MEM_freeN(lme->line);
 177                         MEM_freeN(lme);
 178                 }
 179         }
 180 }
 181
 182 int BLF_lang_init(void)
 183 {
 184         char name[FILE_MAXDIR+FILE_MAXFILE];
 185         LinkNode *l, *lines;
 186
 187         /* .Blanguages, http://www.blender3d.org/cms/Installation_Policy.352.0.html*/
 188 #if defined (__APPLE__) || (WIN32)
 189         BLI_make_file_string("/", name, BLI_gethome(), ".Blanguages");
 190 #else
 191         BLI_make_file_string("/", name, BLI_gethome(), ".blender/.Blanguages");
 192 #endif
 193
 194         lines= BLI_read_file_as_lines(name);
 195
 196         if(lines == NULL) {
 197                 /* If not found in home, try current dir
 198                  * (Resources folder of app bundle on OS X) */
 199 #if defined (__APPLE__)
 200                 char *bundlePath = BLI_getbundle();
 201                 strcpy(name, bundlePath);
 202                 strcat(name, "/Contents/Resources/.Blanguages");
 203 #else
 204                 /* Check the CWD. Takes care of the case where users
 205                  * unpack blender tarball; cd blender-dir; ./blender */
 206                 strcpy(name, ".blender/.Blanguages");
 207 #endif
 208                 lines= BLI_read_file_as_lines(name);
 209
 210                 if(lines == NULL) {
 211                         /* If not found in .blender, try current dir */
 212                         strcpy(name, ".Blanguages");
 213                         lines= BLI_read_file_as_lines(name);
 214                         if(lines == NULL) {
 215 // XXX 2.50                             if(G.f & G_DEBUG)
 216                                 printf("File .Blanguages not found\n");
 217                                 return(0);
 218                         }
 219                 }
 220         }
 221
 222         for (l= lines; l; l= l->next) {
 223                 char *line= l->link;
 224
 225                 if (!BLI_streq(line, "")) {
 226                         blf_lang_new(line);
 227                 }
 228         }
 229
 230         BLI_free_file_lines(lines);
 231         return(1);
 232 }
 233
 234 void BLF_lang_exit(void)
 235 {
 236         LangBLF *p;
 237
 238         while (global_lang.first) {
 239                 p= global_lang.first;
 240                 BLI_remlink(&global_lang, p);
 241                 MEM_freeN(p->line);
 242                 MEM_freeN(p->language);
 243                 MEM_freeN(p->code);
 244                 MEM_freeN(p);
 245         }
 246 }