doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / blender / blenfont / intern / blf_dir.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2009 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 <ft2build.h>
33
34 #include FT_FREETYPE_H
35 #include FT_GLYPH_H
36
37 #include "MEM_guardedalloc.h"
38
39 #include "DNA_vec_types.h"
40
41 #include "BKE_utildefines.h"
42
43 #include "BLI_blenlib.h"
44
45 #include "BIF_gl.h"
46
47 #include "BLF_api.h"
48 #include "blf_internal_types.h"
49
50 static ListBase global_font_dir= { NULL, NULL };
51
52 static DirBLF *blf_dir_find(const char *path)
53 {
54         DirBLF *p;
55         
56         p= global_font_dir.first;
57         while (p) {
58                 if (!strcmp(p->path, path))
59                         return(p);
60                 p= p->next;
61         }
62         return(NULL);
63 }
64
65 void BLF_dir_add(const char *path)
66 {
67         DirBLF *dir;
68         
69         dir= blf_dir_find(path);
70         if (dir) /* already in the list ? just return. */
71                 return;
72         
73         dir= (DirBLF *)MEM_mallocN(sizeof(DirBLF), "BLF_dir_add");
74         dir->path= BLI_strdup(path);
75         BLI_addhead(&global_font_dir, dir);
76 }
77
78 void BLF_dir_rem(const char *path)
79 {
80         DirBLF *dir;
81         
82         dir= blf_dir_find(path);
83         if (dir) {
84                 BLI_remlink(&global_font_dir, dir);
85                 MEM_freeN(dir->path);
86                 MEM_freeN(dir);
87         }
88 }
89
90 char **BLF_dir_get(int *ndir)
91 {
92         DirBLF *p;
93         char **dirs;
94         char *path;
95         int i, count;
96         
97         count= BLI_countlist(&global_font_dir);
98         if (!count)
99                 return(NULL);
100         
101         dirs= (char **)MEM_mallocN(sizeof(char *) * count, "BLF_dir_get");
102         p= global_font_dir.first;
103         i= 0;
104         while (p) {
105                 path= BLI_strdup(p->path);
106                 dirs[i]= path;
107                 p= p->next;
108         }
109         *ndir= i;
110         return(dirs);
111 }
112
113 void BLF_dir_free(char **dirs, int count)
114 {
115         char *path;
116         int i;
117         
118         for (i= 0; i < count; i++) {
119                 path= dirs[i];
120                 MEM_freeN(path);
121         }
122         MEM_freeN(dirs);
123 }
124
125 char *blf_dir_search(const char *file)
126 {
127         DirBLF *dir;
128         char full_path[FILE_MAXDIR+FILE_MAXFILE];
129         char *s= NULL;
130
131         for(dir=global_font_dir.first; dir; dir= dir->next) {
132                 BLI_join_dirfile(full_path, sizeof(full_path), dir->path, file);
133                 if (BLI_exist(full_path)) {
134                         s= BLI_strdup(full_path);
135                         break;
136                 }
137         }
138
139         if (!s) {
140                 /* check the current directory, why not ? */
141                 if (BLI_exist(file))
142                         s= BLI_strdup(file);
143         }
144         
145         return(s);
146 }
147
148 int blf_dir_split(const char *str, char *file, int *size)
149 {
150         int i, len;
151         char *s;
152         
153         /* Window, Linux or Mac, this is always / */
154         s= strrchr(str, '/');
155         if (s) {
156                 len= s - str;
157                 for (i= 0; i < len; i++)
158                         file[i]= str[i];
159
160                 file[i]= '.';
161                 file[i+1]= 't';
162                 file[i+2]= 't';
163                 file[i+3]= 'f';
164                 file[i+4]= '\0';
165                 s++;
166                 *size= atoi(s);
167                 return(1);
168         }
169         return(0);
170 }
171
172 /* Some font have additional file with metrics information,
173  * in general, the extension of the file is: .afm or .pfm
174  */
175 char *blf_dir_metrics_search(const char *filename)
176 {
177         char *mfile;
178         char *s;
179
180         mfile= BLI_strdup(filename);
181         s= strrchr(mfile, '.');
182         if (s) {
183                 if (strlen(s) < 4) {
184                         MEM_freeN(mfile);
185                         return(NULL);
186                 }
187                 s++;
188                 s[0]= 'a';
189                 s[1]= 'f';
190                 s[2]= 'm';
191
192                 /* first check .afm */
193                 if (BLI_exist(s))
194                         return(s);
195
196                 /* and now check .pfm */
197                 s[0]= 'p';
198
199                 if (BLI_exist(s))
200                         return(s);
201         }
202         MEM_freeN(mfile);
203         return(NULL);
204 }