Docs: doxygen file descriptions for BLF, GPU and WM
[blender.git] / source / blender / blenfont / intern / blf_dir.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) 2009 Blender Foundation.
19  * All rights reserved.
20  * 
21  * Contributor(s): Blender Foundation.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/blenfont/intern/blf_dir.c
27  *  \ingroup blf
28  *
29  * Manage search paths for font files.
30  */
31
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36
37 #include <ft2build.h>
38
39 #include FT_FREETYPE_H
40 #include FT_GLYPH_H
41
42 #include "MEM_guardedalloc.h"
43
44 #include "DNA_vec_types.h"
45
46 #include "BLI_utildefines.h"
47 #include "BLI_fileops.h"
48 #include "BLI_listbase.h"
49 #include "BLI_path_util.h"
50 #include "BLI_string.h"
51 #include "BLI_threads.h"
52
53 #include "BIF_gl.h"
54
55 #include "BLF_api.h"
56 #include "blf_internal_types.h"
57 #include "blf_internal.h"
58
59 static ListBase global_font_dir = { NULL, NULL };
60
61 static DirBLF *blf_dir_find(const char *path)
62 {
63         DirBLF *p;
64         
65         p = global_font_dir.first;
66         while (p) {
67                 if (BLI_path_cmp(p->path, path) == 0)
68                         return p;
69                 p = p->next;
70         }
71         return NULL;
72 }
73
74 void BLF_dir_add(const char *path)
75 {
76         DirBLF *dir;
77         
78         dir = blf_dir_find(path);
79         if (dir) /* already in the list ? just return. */
80                 return;
81         
82         dir = (DirBLF *)MEM_callocN(sizeof(DirBLF), "BLF_dir_add");
83         dir->path = BLI_strdup(path);
84         BLI_addhead(&global_font_dir, dir);
85 }
86
87 void BLF_dir_rem(const char *path)
88 {
89         DirBLF *dir;
90         
91         dir = blf_dir_find(path);
92         if (dir) {
93                 BLI_remlink(&global_font_dir, dir);
94                 MEM_freeN(dir->path);
95                 MEM_freeN(dir);
96         }
97 }
98
99 char **BLF_dir_get(int *ndir)
100 {
101         DirBLF *p;
102         char **dirs;
103         char *path;
104         int i, count;
105         
106         count = BLI_countlist(&global_font_dir);
107         if (!count)
108                 return NULL;
109         
110         dirs = (char **)MEM_callocN(sizeof(char *) * count, "BLF_dir_get");
111         p = global_font_dir.first;
112         i = 0;
113         while (p) {
114                 path = BLI_strdup(p->path);
115                 dirs[i] = path;
116                 p = p->next;
117         }
118         *ndir = i;
119         return dirs;
120 }
121
122 void BLF_dir_free(char **dirs, int count)
123 {
124         char *path;
125         int i;
126         
127         for (i = 0; i < count; i++) {
128                 path = dirs[i];
129                 MEM_freeN(path);
130         }
131         MEM_freeN(dirs);
132 }
133
134 char *blf_dir_search(const char *file)
135 {
136         DirBLF *dir;
137         char full_path[FILE_MAX];
138         char *s = NULL;
139
140         for (dir = global_font_dir.first; dir; dir = dir->next) {
141                 BLI_join_dirfile(full_path, sizeof(full_path), dir->path, file);
142                 if (BLI_exists(full_path)) {
143                         s = BLI_strdup(full_path);
144                         break;
145                 }
146         }
147
148         if (!s) {
149                 /* check the current directory, why not ? */
150                 if (BLI_exists(file))
151                         s = BLI_strdup(file);
152         }
153
154         return s;
155 }
156
157 #if 0 /* UNUSED */
158 int blf_dir_split(const char *str, char *file, int *size)
159 {
160         int i, len;
161         char *s;
162         
163         /* Window, Linux or Mac, this is always / */
164         s = strrchr(str, '/');
165         if (s) {
166                 len = s - str;
167                 for (i = 0; i < len; i++)
168                         file[i] = str[i];
169
170                 file[i] = '.';
171                 file[i + 1] = 't';
172                 file[i + 2] = 't';
173                 file[i + 3] = 'f';
174                 file[i + 4] = '\0';
175                 s++;
176                 *size = atoi(s);
177                 return 1;
178         }
179         return 0;
180 }
181 #endif
182
183 /* Some font have additional file with metrics information,
184  * in general, the extension of the file is: .afm or .pfm
185  */
186 char *blf_dir_metrics_search(const char *filename)
187 {
188         char *mfile;
189         char *s;
190
191         mfile = BLI_strdup(filename);
192         s = strrchr(mfile, '.');
193         if (s) {
194                 if (BLI_strnlen(s, 4) < 4) {
195                         MEM_freeN(mfile);
196                         return NULL;
197                 }
198                 s++;
199                 s[0] = 'a';
200                 s[1] = 'f';
201                 s[2] = 'm';
202
203                 /* first check .afm */
204                 if (BLI_exists(mfile))
205                         return mfile;
206
207                 /* and now check .pfm */
208                 s[0] = 'p';
209
210                 if (BLI_exists(mfile))
211                         return mfile;
212         }
213         MEM_freeN(mfile);
214         return NULL;
215 }