2.5
[blender-staging.git] / source / blender / blenfont / intern / blf.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) 2009 Blender Foundation.
21  * All rights reserved.
22  *
23  * 
24  * Contributor(s): Blender Foundation
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #ifdef WITH_FREETYPE2
34
35 #include <ft2build.h>
36
37 #include FT_FREETYPE_H
38 #include FT_GLYPH_H
39
40 #endif /* WITH_FREETYPE2 */
41
42 #include "MEM_guardedalloc.h"
43
44 #include "DNA_listBase.h"
45 #include "DNA_vec_types.h"
46
47 #include "BKE_utildefines.h"
48
49 #include "BLI_blenlib.h"
50 #include "BLI_linklist.h"       /* linknode */
51 #include "BLI_string.h"
52
53 #include "BIF_gl.h"
54 #include "BIF_glutil.h"
55
56 #include "blf_internal_types.h"
57 #include "blf_internal.h"
58
59
60 #ifdef WITH_FREETYPE2
61
62 /* Max number of font in memory.
63  * Take care that now every font have a glyph cache per size/dpi,
64  * so we don't need load the same font with different size, just
65  * load one and call BLF_size.
66  */
67 #define BLF_MAX_FONT 16
68
69 /* Font array. */
70 FontBLF *global_font[BLF_MAX_FONT];
71
72 /* Number of font. */
73 int global_font_num= 0;
74
75 /* Current font. */
76 int global_font_cur= 0;
77
78 #endif /* WITH_FREETYPE2 */
79
80 int BLF_init(void)
81 {
82 #ifdef WITH_FREETYPE2
83         int i;
84
85         for (i= 0; i < BLF_MAX_FONT; i++)
86                 global_font[i]= NULL;
87
88         return(blf_font_init());
89 #else
90         return(0);
91 #endif
92 }
93
94 void BLF_exit(void)
95 {
96 #ifdef WITH_FREETYPE2
97         FontBLF *font;
98         int i;
99
100         for (i= 0; i < global_font_num; i++) {
101                 font= global_font[i];
102                 if(font)
103                         blf_font_free(font);
104         }
105
106         blf_font_exit();
107 #endif
108 }
109
110 int blf_search(char *name)
111 {
112 #ifdef WITH_FREETYPE2
113         FontBLF *font;
114         int i;
115
116         for (i= 0; i < BLF_MAX_FONT; i++) {
117                 font= global_font[i];
118                 if (font && (!strcmp(font->name, name)))
119                         return(i);
120         }
121 #endif
122         return(-1);
123 }
124
125 int BLF_load(char *name)
126 {
127 #ifdef WITH_FREETYPE2
128         FontBLF *font;
129         char *filename;
130         int i;
131
132         if (!name)
133                 return(-1);
134
135         /* check if we already load this font. */
136         i= blf_search(name);
137         if (i >= 0) {
138                 font= global_font[i];
139                 font->ref++;
140                 printf("Increment reference (%d): %s\n", font->ref, name);
141                 return(i);
142         }
143
144         if (global_font_num+1 >= BLF_MAX_FONT) {
145                 printf("Too many fonts!!!\n");
146                 return(-1);
147         }
148
149         filename= blf_dir_search(name);
150         if (!filename) {
151                 printf("Can't found font: %s\n", name);
152                 return(-1);
153         }
154
155         font= blf_font_new(name, filename);
156         MEM_freeN(filename);
157
158         if (!font) {
159                 printf("Can't load font: %s\n", name);
160                 return(-1);
161         }
162
163         global_font[global_font_num]= font;
164         i= global_font_num;
165         global_font_num++;
166         return(i);
167 #else
168         return(-1);
169 #endif /* WITH_FREETYPE2 */
170 }
171
172 int BLF_load_mem(char *name, unsigned char *mem, int mem_size)
173 {
174 #ifdef WITH_FREETYPE2
175         FontBLF *font;
176         int i;
177
178         if (!name || !mem || !mem_size)
179                 return(-1);
180
181         i= blf_search(name);
182         if (i >= 0) {
183                 font= global_font[i];
184                 font->ref++;
185                 printf("Increment reference (%d): %s\n", font->ref, name);
186                 return(i);
187         }
188
189         if (global_font_num+1 >= BLF_MAX_FONT) {
190                 printf("Too many fonts!!!\n");
191                 return(-1);
192         }
193
194         font= blf_font_new_from_mem(name, mem, mem_size);
195         if (!font) {
196                 printf("Can't load font, %s from memory!!\n", name);
197                 return(-1);
198         }
199
200         global_font[global_font_num]= font;
201         i= global_font_num;
202         global_font_num++;
203         return(i);
204 #else
205         return(-1);
206 #endif /* WITH_FREETYPE2 */
207 }
208
209 void BLF_set(int fontid)
210 {
211 #ifdef WITH_FREETYPE2
212         if (fontid >= 0 && fontid < BLF_MAX_FONT)
213                 global_font_cur= fontid;
214 #endif
215 }
216
217 void BLF_aspect(float aspect)
218 {
219 #ifdef WITH_FREETYPE2
220         FontBLF *font;
221
222         font= global_font[global_font_cur];
223         if (font)
224                 font->aspect= aspect;
225 #endif
226 }
227
228 void BLF_position(float x, float y, float z)
229 {
230 #ifdef WITH_FREETYPE2
231         FontBLF *font;
232
233         font= global_font[global_font_cur];
234         if (font) {
235                 font->pos[0]= x;
236                 font->pos[1]= y;
237                 font->pos[2]= z;
238         }
239 #endif
240 }
241
242 void BLF_size(int size, int dpi)
243 {
244 #ifdef WITH_FREETYPE2
245         FontBLF *font;
246
247         font= global_font[global_font_cur];
248         if (font)
249                 blf_font_size(font, size, dpi);
250 #endif
251 }
252
253 void BLF_draw(char *str)
254 {
255 #ifdef WITH_FREETYPE2
256         FontBLF *font;
257
258         font= global_font[global_font_cur];
259         if (font && font->glyph_cache) {
260                 glEnable(GL_BLEND);
261                 glEnable(GL_TEXTURE_2D);
262                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
263
264                 glPushMatrix();
265                 glTranslatef(font->pos[0], font->pos[1], font->pos[2]);
266
267                 blf_font_draw(font, str);
268
269                 glPopMatrix();
270                 glDisable(GL_BLEND);
271                 glDisable(GL_TEXTURE_2D);
272         }
273 #endif /* WITH_FREETYPE2 */
274 }