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 #ifdef WITH_FREETYPE2
  33 #include <ft2build.h>
  34
  35 #include FT_FREETYPE_H
  36 #include FT_GLYPH_H
  37 #endif
  38
  39 #include "MEM_guardedalloc.h"
  40
  41 #include "DNA_listBase.h"
  42 #include "DNA_vec_types.h"
  43
  44 #include "BKE_utildefines.h"
  45
  46 #include "BLI_blenlib.h"
  47 #include "BLI_linklist.h"       /* linknode */
  48 #include "BLI_string.h"
  49
  50 #include "BIF_gl.h"
  51
  52 #include "blf_internal_types.h"
  53
  54 // XXX 2.50 Remove this later.
  55 #ifdef WITH_FREETYPE2
  56 #include "FTF_Api.h"
  57 #endif
  58
  59 static ListBase global_lang= { NULL, NULL };
  60 static int global_tot_lang= 0;
  61 static int global_err_lang= 0;
  62
  63 int BLF_lang_error(void)
  64 {
  65         return(global_err_lang);
  66 }
  67
  68 char *BLF_lang_pup(void)
  69 {
  70         LangBLF *lme;
  71         static char string[1024];
  72         static char tmp[1024];
  73
  74         if(global_tot_lang == 0)
  75                 sprintf(string, "Choose Language: %%t|Language:  English %%x0");
  76         else {
  77                 lme= global_lang.first;
  78                 sprintf(string, "Choose Language: %%t");
  79                 while (lme) {
  80                         sprintf(tmp, "|Language:  %s %%x%d", lme->language, lme->id);
  81                         strcat(string, tmp);
  82                         lme= lme->next;
  83                 }
  84         }
  85
  86         return(string);
  87 }
  88
  89 LangBLF *blf_lang_find_by_id(short langid)
  90 {
  91         LangBLF *p;
  92
  93         p= global_lang.first;
  94         while (p) {
  95                 if (p->id == langid)
  96                         return(p);
  97                 p= p->next;
  98         }
  99         return(NULL);
 100 }
 101
 102 char *BLF_lang_find_code(short langid)
 103 {
 104         LangBLF *p;
 105
 106         p= blf_lang_find_by_id(langid);
 107         if (p)
 108                 return(p->code);
 109         return(NULL);
 110 }
 111
 112 void BLF_lang_set(int id)
 113 {
 114 #ifdef WITH_FREETYPE2
 115         LangBLF *lme;
 116
 117         // XXX 2.50 Remove this later, with ftfont
 118         lme= blf_lang_find_by_id(id);
 119         if(lme) FTF_SetLanguage(lme->code);
 120         else FTF_SetLanguage("en_US");
 121 #endif
 122 }
 123
 124 static void blf_lang_split(char *line, LangBLF* lme)
 125 {
 126         char *dpointchar= strchr(line, ':');
 127
 128         if (dpointchar) {
 129                 lme->code= BLI_strdup(dpointchar+1);
 130                 *(dpointchar)=0;
 131                 lme->language= BLI_strdup(line);
 132         } else {
 133                 lme->code= NULL;
 134                 lme->language= NULL;
 135                 /* XXX 2.50 bad call error("Invalid language file");
 136                  * If we set this to NULL, the function blf_lang_new
 137                  * drop the line and increment the error lang value
 138                  * so the init code can call BLF_lang_error to get
 139                  * the number of invalid lines and show the error.
 140                  */
 141         }
 142 }
 143
 144 LangBLF *blf_lang_find(char *s, int find_by)
 145 {
 146         LangBLF *p;
 147
 148         p= global_lang.first;
 149         while (p) {
 150                 if (find_by == BLF_LANG_FIND_BY_LINE) {
 151                         if (BLI_streq(s, p->line))
 152                                 return(p);
 153                 }
 154                 else if (find_by == BLF_LANG_FIND_BY_CODE) {
 155                         if (BLI_streq(s, p->code))
 156                                 return(p);
 157                 }
 158                 else if (find_by == BLF_LANG_FIND_BY_LANGUAGE) {
 159                         if (BLI_streq(s, p->language))
 160                                 return(p);
 161                 }
 162                 p= p->next;
 163         }
 164         return(NULL);
 165 }
 166
 167 static void blf_lang_new(char *line)
 168 {
 169         LangBLF *lme;
 170
 171         lme= blf_lang_find(line, BLF_LANG_FIND_BY_LINE);
 172         if (!lme) {
 173                 lme= MEM_mallocN(sizeof(LangBLF), "blf_lang_new");
 174                 lme->next= NULL;
 175                 lme->prev= NULL;
 176                 lme->line = BLI_strdup(line);
 177                 blf_lang_split(line, lme);
 178
 179                 if (lme->code && lme->language) {
 180                         lme->id = global_tot_lang;
 181                         global_tot_lang++;
 182                         BLI_addhead(&global_lang, lme);
 183                 }
 184                 else {
 185                         global_err_lang++;
 186                         MEM_freeN(lme->line);
 187                         MEM_freeN(lme);
 188                 }
 189         }
 190 }
 191
 192 int BLF_lang_init(void)
 193 {
 194         char name[FILE_MAXDIR+FILE_MAXFILE];
 195         LinkNode *l, *lines;
 196
 197         /* .Blanguages, http://www.blender3d.org/cms/Installation_Policy.352.0.html*/
 198 #if defined (__APPLE__) || (WIN32)
 199         BLI_make_file_string("/", name, BLI_gethome(), ".Blanguages");
 200 #else
 201         BLI_make_file_string("/", name, BLI_gethome(), ".blender/.Blanguages");
 202 #endif
 203
 204         lines= BLI_read_file_as_lines(name);
 205
 206         if(lines == NULL) {
 207                 /* If not found in home, try current dir
 208                  * (Resources folder of app bundle on OS X) */
 209 #if defined (__APPLE__)
 210                 char *bundlePath = BLI_getbundle();
 211                 strcpy(name, bundlePath);
 212                 strcat(name, "/Contents/Resources/.Blanguages");
 213 #else
 214                 /* Check the CWD. Takes care of the case where users
 215                  * unpack blender tarball; cd blender-dir; ./blender */
 216                 strcpy(name, ".blender/.Blanguages");
 217 #endif
 218                 lines= BLI_read_file_as_lines(name);
 219
 220                 if(lines == NULL) {
 221                         /* If not found in .blender, try current dir */
 222                         strcpy(name, ".Blanguages");
 223                         lines= BLI_read_file_as_lines(name);
 224                         if(lines == NULL) {
 225 // XXX 2.50                             if(G.f & G_DEBUG)
 226                                 printf("File .Blanguages not found\n");
 227                                 return(0);
 228                         }
 229                 }
 230         }
 231
 232         for (l= lines; l; l= l->next) {
 233                 char *line= l->link;
 234
 235                 if (!BLI_streq(line, "")) {
 236                         blf_lang_new(line);
 237                 }
 238         }
 239
 240         BLI_free_file_lines(lines);
 241         return(1);
 242 }
 243
 244 void BLF_lang_exit(void)
 245 {
 246         LangBLF *p;
 247
 248         while (global_lang.first) {
 249                 p= global_lang.first;
 250                 BLI_remlink(&global_lang, p);
 251                 MEM_freeN(p->line);
 252                 MEM_freeN(p->language);
 253                 MEM_freeN(p->code);
 254                 MEM_freeN(p);
 255         }
 256 }