1 #include <u.h>
2 
3 #include <fontconfig/fontconfig.h>
4 #include <ft2build.h>
5 #include FT_FREETYPE_H
6 
7 #include <libc.h>
8 #include <draw.h>
9 #include <memdraw.h>
10 #include "a.h"
11 
12 static FcConfig    *fc;
13 static FT_Library  lib;
14 static int         dpi = 96;
15 
16 void
17 loadfonts(void)
18 {
19 	int i;
20 	FT_Error e;
21 	FcFontSet *sysfonts;
22 
23 	if(!FcInit() || (fc=FcInitLoadConfigAndFonts()) == NULL) {
24 		fprint(2, "fontconfig initialization failed\n");
25 		exits("fontconfig failed");
26 	}
27 
28 	e = FT_Init_FreeType(&lib);
29 	if(e) {
30 		fprint(2, "freetype initialization failed: %d\n", e);
31 		exits("freetype failed");
32 	}
33 
34 	sysfonts = FcConfigGetFonts(fc, FcSetSystem);
35 
36 	xfont = emalloc9p(sysfonts->nfont*sizeof xfont[0]);
37 	memset(xfont, 0, sysfonts->nfont*sizeof xfont[0]);
38 	for(i=0; i<sysfonts->nfont; i++) {
39 		FcChar8 *fullname, *fontfile;
40 		int index;
41 		FcPattern *pat = sysfonts->fonts[i];
42 
43 		if(FcPatternGetString(pat, FC_FULLNAME, 0, &fullname) != FcResultMatch ||
44 		   FcPatternGetString(pat, FC_FILE, 0, &fontfile) != FcResultMatch     ||
45 		   FcPatternGetInteger(pat, FC_INDEX, 0, &index) != FcResultMatch)
46 			continue;
47 
48 		xfont[nxfont].name     = strdup((char*)fullname);
49 		xfont[nxfont].fontfile = strdup((char*)fontfile);
50 		xfont[nxfont].index    = index;
51 		nxfont++;
52 	}
53 
54 	FcFontSetDestroy(sysfonts);
55 }
56 
57 void
58 load(XFont *f)
59 {
60 	FT_Face face;
61 	FT_Error e;
62 	FT_ULong charcode;
63 	FT_UInt glyph_index;
64 
65 	if(f->loaded)
66 		return;
67 
68 	e = FT_New_Face(lib, f->fontfile, f->index, &face);
69 
70 	if(e){
71 		fprint(2, "load failed for %s (%s) index:%d\n", f->name, f->fontfile, f->index);
72 		return;
73 	}
74 
75 	if(!FT_IS_SCALABLE(face)) {
76 		fprint(2, "%s is a non scalable font, skipping\n", f->name);
77 		FT_Done_Face(face);
78 	    f->loaded = 1;
79 		return;
80 	}
81 
82 	f->unit = face->units_per_EM;
83 	f->height = (int)((face->ascender - face->descender) * 1.2);
84 	f->originy = face->descender; // bbox.yMin (or descender)  is negative, becase the baseline is y-coord 0
85 
86 	for(charcode=FT_Get_First_Char(face, &glyph_index); glyph_index != 0;
87 		charcode=FT_Get_Next_Char(face, charcode, &glyph_index)) {
88 
89 		int idx = charcode>>8;
90 
91 		if(charcode > 0xffff)
92 			break;
93 
94 		if(!f->range[idx]) {
95 			f->range[idx] = 1;
96 			f->nrange++;
97 		}
98 	}
99 
100 	FT_Done_Face(face);
101 	f->loaded = 1;
102 }
103 
104 Memsubfont*
105 mksubfont(char *name, int lo, int hi, int size, int antialias)
106 {
107 	XFont *xf, *xfp, *xfe;
108 	FT_Face face;
109 	FT_Error e;
110 	Memimage *m, *mc, *m1;
111 	double pixel_size;
112 	int x, y, y0;
113 	int i;
114 	Fontchar *fc, *fc0;
115 	Memsubfont *sf;
116 	Point rect_points[4];
117 
118 	xf = nil;
119 	for(xfp=xfont, xfe=xfont+nxfont; xfp != xfe; xfp++) {
120 		if(strcmp(xfp->name, name) == 0) {
121 			xf = xfp;
122 			break;
123 		}
124 	}
125 
126 	if(!xf)
127 		return nil;
128 
129 	e = FT_New_Face(lib, xf->fontfile, xf->index, &face);
130 
131 	if(e){
132 		fprint(2, "load failed for %s (%s) index:%d\n", xf->name, xf->fontfile, xf->index);
133 		return nil;
134 	}
135 
136 	e = FT_Set_Char_Size(face, 0, size<<6, dpi, dpi);
137 	if(e){
138 		fprint(2, "FT_Set_Char_Size failed\n");
139 		FT_Done_Face(face);
140 		return nil;
141 	}
142 
143 	pixel_size = (dpi*size)/72.0;
144 	x = (int)((face->max_advance_width) * pixel_size/xf->unit + 0.99999999);
145 	y = (int)((face->ascender - face->descender) * pixel_size/xf->unit + 0.99999999);
146 	y0 = (int)(-face->descender * pixel_size/xf->unit + 0.99999999);
147 
148 	m = allocmemimage(Rect(0, 0, x*(hi+1-lo), y), antialias ? GREY8 : GREY1);
149 	if(m == nil) {
150 		FT_Done_Face(face);
151 		return nil;
152 	}
153 	mc = allocmemimage(Rect(0, 0, x, y), antialias ? GREY8 : GREY1);
154 	if(mc == nil) {
155 		freememimage(m);
156 		FT_Done_Face(face);
157 		return nil;
158 	}
159 	memfillcolor(m, DBlack);
160 	memfillcolor(mc, DBlack);
161 	fc = malloc((hi+2 - lo) * sizeof fc[0]);
162 	sf = malloc(sizeof *sf);
163 	if(fc == nil || sf == nil) {
164 		freememimage(m);
165 		freememimage(mc);
166 		free(fc);
167 		free(sf);
168 		FT_Done_Face(face);
169 		return nil;
170 	}
171 	fc0 = fc;
172 
173 	//rect_points[0] = mc->r.min;
174 	//rect_points[1] = Pt(mc->r.max.x, mc->r.min.y);
175 	//rect_points[2] = mc->r.max;
176 	//rect_points[3] = Pt(mc->r.min.x, mc->r.max.y);
177 
178 	x = 0;
179 	for(i=lo; i<=hi; i++, fc++) {
180 		int r;
181 		int advance;
182 
183 		memfillcolor(mc, DBlack);
184 
185 		e = FT_Load_Char(face, i, FT_LOAD_RENDER|(antialias ? 0:FT_LOAD_TARGET_MONO));
186 		if(e){
187 			fprint(2, "FT_Load_Char failed for %d\n", i);
188 			//mempoly(mc, rect_points, 4, Endsquare, Endsquare, 0, memopaque, ZP, S);
189 			memimageline(mc, m->r.min, Pt(m->r.max.x, m->r.min.y), Endsquare, Endsquare, 0, memopaque, ZP, S);
190 			memimageline(mc, m->r.min, Pt(m->r.min.x, m->r.max.y), Endsquare, Endsquare, 0, memopaque, ZP, S);
191 			memimageline(mc, Pt(m->r.max.x, m->r.min.y), m->r.max, Endsquare, Endsquare, 0, memopaque, ZP, S);
192 			memimageline(mc, Pt(m->r.min.x, m->r.max.y), m->r.max, Endsquare, Endsquare, 0, memopaque, ZP, S);
193 			memimageline(mc, m->r.min, m->r.max, Endsquare, Endsquare, 0, memopaque, ZP, S);
194 			advance = Dx(m->r);
195 
196 			memimagedraw(m, Rect(x, 0, x + advance, y), mc, ZP, memopaque, ZP, S);
197 		} else {
198 			FT_Bitmap *bitmap = &face->glyph->bitmap;
199 			uchar *base = byteaddr(mc, mc->r.min);
200 			advance = (face->glyph->advance.x+32) >> 6;
201 
202 			for(r=0; r < bitmap->rows; r++)
203 				memmove(base + r*mc->width*sizeof(u32int), bitmap->buffer + r*bitmap->pitch, bitmap->pitch);
204 
205 			memimagedraw(m, Rect(x, 0, x + advance, y), mc,
206 				Pt(-face->glyph->bitmap_left, -(y - y0 - face->glyph->bitmap_top)),
207 				memopaque, ZP, S);
208 		}
209 
210 		fc->x = x;
211 		fc->top = 0;
212 		fc->bottom = y;
213 		fc->left = 0;
214 		fc->width = advance;
215 		x += advance;
216 
217 #ifdef DEBUG_FT_BITMAP
218 		for(r=0; r < bitmap->rows; r++) {
219 			int c;
220 			uchar *span = bitmap->buffer+(r*bitmap->pitch);
221 			for(c = 0; c < bitmap->width; c++) {
222 				fprint(1, "%02x", span[c]);
223 			}
224 			fprint(1,"\n");
225 		}
226 #endif
227 
228 #ifdef DEBUG_9_BITMAP
229 		for(r=0; r < mc->r.max.y; r++) {
230 			int c;
231 			uchar *span = base+(r*mc->width*sizeof(u32int));
232 			for(c = 0; c < Dx(mc->r); c++) {
233 				fprint(1, "%02x", span[c]);
234 			}
235 			fprint(1,"\n");
236 		}
237 #endif
238 	}
239 	fc->x = x;
240 
241 	// round up to 32-bit boundary
242 	// so that in-memory data is same
243 	// layout as in-file data.
244 	if(antialias)
245 		x += -x & 3;
246 	else
247 		x += -x & 31;
248 	m1 = allocmemimage(Rect(0, 0, x, y), antialias ? GREY8 : GREY1);
249 	memimagedraw(m1, m1->r, m, m->r.min, memopaque, ZP, S);
250 	freememimage(m);
251 
252 	sf->name = nil;
253 	sf->n = hi+1 - lo;
254 	sf->height = Dy(m1->r);
255 	sf->ascent = Dy(m1->r) - y0;
256 	sf->info = fc0;
257 	sf->bits = m1;
258 
259 	FT_Done_Face(face);
260 	return sf;
261 }