?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add tests for NORM_IGNORENONSPACE and NORM_IGNORESYMBOLS in the
[wine/wine64.git] / dlls / gdi / freetype.c
blob6e3b52b60d693e9ca57d512b955b14d2ad1345e9
1 /*
2 * FreeType font engine interface
3 *
4 * Copyright 2001 Huw D M Davies for CodeWeavers.
5 *
6 * This file contains the WineEng* functions.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23
24 #include "config.h"
25
26 #include "windef.h"
27 #include "winerror.h"
28 #include "winreg.h"
29 #include "wingdi.h"
30 #include "wine/unicode.h"
31 #include "wine/port.h"
32 #include "wine/debug.h"
33 #include "gdi.h"
34
35 #include <stdlib.h>
36 #include <sys/stat.h>
37 #include <string.h>
38 #include <dirent.h>
39 #include <stdio.h>
40 #include <assert.h>
41
42 WINE_DEFAULT_DEBUG_CHANNEL(font);
43
44 #ifdef HAVE_FREETYPE
45
46 #ifdef HAVE_FREETYPE_FREETYPE_H
47 #include <freetype/freetype.h>
48 #endif
49 #ifdef HAVE_FREETYPE_FTGLYPH_H
50 #include <freetype/ftglyph.h>
51 #endif
52 #ifdef HAVE_FREETYPE_TTTABLES_H
53 #include <freetype/tttables.h>
54 #endif
55 #ifdef HAVE_FREETYPE_FTSNAMES_H
56 #include <freetype/ftsnames.h>
57 #else
58 # ifdef HAVE_FREETYPE_FTNAMES_H
59 # include <freetype/ftnames.h>
60 # endif
61 #endif
62 #ifdef HAVE_FREETYPE_TTNAMEID_H
63 #include <freetype/ttnameid.h>
64 #endif
65 #ifdef HAVE_FREETYPE_FTOUTLN_H
66 #include <freetype/ftoutln.h>
67 #endif
68 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
69 #include <freetype/internal/sfnt.h>
70 #endif
71 #ifdef HAVE_FREETYPE_FTTRIGON_H
72 #include <freetype/fttrigon.h>
73 #endif
74
75 #ifndef SONAME_LIBFREETYPE
76 #define SONAME_LIBFREETYPE "libfreetype.so"
77 #endif
78
79 static FT_Library library = 0;
80 typedef struct
81 {
82 FT_Int major;
83 FT_Int minor;
84 FT_Int patch;
85 } FT_Version_t;
86 static FT_Version_t FT_Version;
87
88 static void *ft_handle = NULL;
89
90 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
91 MAKE_FUNCPTR(FT_Cos);
92 MAKE_FUNCPTR(FT_Done_Face);
93 MAKE_FUNCPTR(FT_Get_Char_Index);
94 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
95 MAKE_FUNCPTR(FT_Init_FreeType);
96 MAKE_FUNCPTR(FT_Load_Glyph);
97 MAKE_FUNCPTR(FT_MulFix);
98 MAKE_FUNCPTR(FT_New_Face);
99 MAKE_FUNCPTR(FT_Outline_Get_Bitmap);
100 MAKE_FUNCPTR(FT_Outline_Transform);
101 MAKE_FUNCPTR(FT_Outline_Translate);
102 MAKE_FUNCPTR(FT_Select_Charmap);
103 MAKE_FUNCPTR(FT_Set_Pixel_Sizes);
104 MAKE_FUNCPTR(FT_Sin);
105 MAKE_FUNCPTR(FT_Vector_Rotate);
106 #undef MAKE_FUNCPTR
107 static void (*pFT_Library_Version)(FT_Library,FT_Int*,FT_Int*,FT_Int*);
108 static FT_Error (*pFT_Load_Sfnt_Table)(FT_Face,FT_ULong,FT_Long,FT_Byte*,FT_ULong*);
109
110 #define GET_BE_WORD(ptr) MAKEWORD( ((BYTE *)(ptr))[1], ((BYTE *)(ptr))[0] )
111
112 typedef struct tagFace {
113 WCHAR *StyleName;
114 char *file;
115 FT_Long face_index;
116 BOOL Italic;
117 BOOL Bold;
118 FONTSIGNATURE fs;
119 FT_Fixed font_version;
120 struct tagFace *next;
121 struct tagFamily *family;
122 } Face;
123
124 typedef struct tagFamily {
125 WCHAR *FamilyName;
126 Face *FirstFace;
127 struct tagFamily *next;
128 } Family;
129
130 typedef struct {
131 GLYPHMETRICS gm;
132 INT adv; /* These three hold to widths of the unrotated chars */
133 INT lsb;
134 INT bbx;
135 BOOL init;
136 } GM;
137
138 struct tagGdiFont {
139 FT_Face ft_face;
140 XFORM xform;
141 LPWSTR name;
142 int charset;
143 BOOL fake_italic;
144 BOOL fake_bold;
145 INT orientation;
146 GM *gm;
147 DWORD gmsize;
148 HFONT hfont;
149 SHORT yMax;
150 SHORT yMin;
151 OUTLINETEXTMETRICW *potm;
152 FONTSIGNATURE fs;
153 struct tagGdiFont *next;
154 };
155
156 #define INIT_GM_SIZE 128
157
158 static GdiFont GdiFontList = NULL;
159
160 static Family *FontList = NULL;
161
162 static WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ',
163 'R','o','m','a','n','\0'};
164 static WCHAR defSans[] = {'A','r','i','a','l','\0'};
165 static WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
166
167 static WCHAR defSystem[] = {'A','r','i','a','l','\0'};
168 static WCHAR SystemW[] = {'S','y','s','t','e','m','\0'};
169 static WCHAR MSSansSerifW[] = {'M','S',' ','S','a','n','s',' ',
170 'S','e','r','i','f','\0'};
171 static WCHAR HelvW[] = {'H','e','l','v','\0'};
172
173 static WCHAR ArabicW[] = {'A','r','a','b','i','c','\0'};
174 static WCHAR BalticW[] = {'B','a','l','t','i','c','\0'};
175 static WCHAR CHINESE_BIG5W[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
176 static WCHAR CHINESE_GB2312W[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
177 static WCHAR Central_EuropeanW[] = {'C','e','n','t','r','a','l',' ',
178 'E','u','r','o','p','e','a','n','\0'};
179 static WCHAR CyrillicW[] = {'C','y','r','i','l','l','i','c','\0'};
180 static WCHAR GreekW[] = {'G','r','e','e','k','\0'};
181 static WCHAR HangulW[] = {'H','a','n','g','u','l','\0'};
182 static WCHAR Hangul_Johab_W[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
183 static WCHAR HebrewW[] = {'H','e','b','r','e','w','\0'};
184 static WCHAR JapaneseW[] = {'J','a','p','a','n','e','s','e','\0'};
185 static WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
186 static WCHAR ThaiW[] = {'T','h','a','i','\0'};
187 static WCHAR TurkishW[] = {'T','u','r','k','i','s','h','\0'};
188 static WCHAR VietnameseW[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
189 static WCHAR WesternW[] = {'W','e','s','t','e','r','n','\0'};
190
191 static WCHAR *ElfScriptsW[32] = { /* these are in the order of the fsCsb[0] bits */
192 WesternW, /*00*/
193 Central_EuropeanW,
194 CyrillicW,
195 GreekW,
196 TurkishW,
197 HebrewW,
198 ArabicW,
199 BalticW,
200 VietnameseW, /*08*/
201 NULL, NULL, NULL, NULL, NULL, NULL, NULL, /*15*/
202 ThaiW,
203 JapaneseW,
204 CHINESE_GB2312W,
205 HangulW,
206 CHINESE_BIG5W,
207 Hangul_Johab_W,
208 NULL, NULL, /*23*/
209 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
210 SymbolW /*31*/
211 };
212
213 typedef struct {
214 WCHAR *name;
215 INT charset;
216 } NameCs;
217
218 typedef struct tagFontSubst {
219 NameCs from;
220 NameCs to;
221 struct tagFontSubst *next;
222 } FontSubst;
223
224 static FontSubst *substlist = NULL;
225 static BOOL have_installed_roman_font = FALSE; /* CreateFontInstance will fail if this is still FALSE */
226
227 static BOOL AddFontFileToList(char *file, char *fake_family)
228 {
229 FT_Face ft_face;
230 TT_OS2 *pOS2;
231 TT_Header *pHeader;
232 WCHAR *FamilyW, *StyleW;
233 DWORD len;
234 Family *family = FontList;
235 Family **insert = &FontList;
236 Face **insertface, *next;
237 FT_Error err;
238 FT_Long face_index = 0, num_faces;
239 int i;
240
241 do {
242 char *family_name = fake_family;
243
244 TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
245 if((err = pFT_New_Face(library, file, face_index, &ft_face)) != 0) {
246 WARN("Unable to load font file %s err = %x\n", debugstr_a(file), err);
247 return FALSE;
248 }
249
250 if(!FT_IS_SFNT(ft_face)) { /* for now we'll skip everything but TT/OT */
251 pFT_Done_Face(ft_face);
252 return FALSE;
253 }
254 if(!pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2) ||
255 !pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea) ||
256 !(pHeader = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_head))) {
257 TRACE("Font file %s lacks either an OS2, HHEA or HEAD table.\n"
258 "Skipping this font.\n", debugstr_a(file));
259 pFT_Done_Face(ft_face);
260 return FALSE;
261 }
262
263 if(!ft_face->family_name || !ft_face->style_name) {
264 TRACE("Font file %s lacks either a family or style name\n", debugstr_a(file));
265 pFT_Done_Face(ft_face);
266 return FALSE;
267 }
268
269 if(!family_name)
270 family_name = ft_face->family_name;
271
272 len = MultiByteToWideChar(CP_ACP, 0, family_name, -1, NULL, 0);
273 FamilyW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
274 MultiByteToWideChar(CP_ACP, 0, family_name, -1, FamilyW, len);
275
276 while(family) {
277 if(!strcmpW(family->FamilyName, FamilyW))
278 break;
279 insert = &family->next;
280 family = family->next;
281 }
282 if(!family) {
283 family = *insert = HeapAlloc(GetProcessHeap(), 0, sizeof(*family));
284 family->FamilyName = FamilyW;
285 family->FirstFace = NULL;
286 family->next = NULL;
287 } else {
288 HeapFree(GetProcessHeap(), 0, FamilyW);
289 }
290
291 len = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0);
292 StyleW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
293 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, StyleW, len);
294
295 next = NULL;
296 for(insertface = &family->FirstFace; *insertface;
297 insertface = &(*insertface)->next) {
298 if(!strcmpW((*insertface)->StyleName, StyleW)) {
299 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
300 debugstr_w(family->FamilyName), debugstr_w(StyleW),
301 (*insertface)->font_version, pHeader->Font_Revision);
302
303 if(fake_family) {
304 TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
305 HeapFree(GetProcessHeap(), 0, StyleW);
306 pFT_Done_Face(ft_face);
307 return FALSE;
308 }
309 if(pHeader->Font_Revision <= (*insertface)->font_version) {
310 TRACE("Original font is newer so skipping this one\n");
311 HeapFree(GetProcessHeap(), 0, StyleW);
312 pFT_Done_Face(ft_face);
313 return FALSE;
314 } else {
315 TRACE("Replacing original with this one\n");
316 next = (*insertface)->next;
317 HeapFree(GetProcessHeap(), 0, (*insertface)->file);
318 HeapFree(GetProcessHeap(), 0, (*insertface)->StyleName);
319 HeapFree(GetProcessHeap(), 0, *insertface);
320 break;
321 }
322 }
323 }
324 *insertface = HeapAlloc(GetProcessHeap(), 0, sizeof(**insertface));
325 (*insertface)->StyleName = StyleW;
326 (*insertface)->file = HeapAlloc(GetProcessHeap(),0,strlen(file)+1);
327 strcpy((*insertface)->file, file);
328 (*insertface)->face_index = face_index;
329 (*insertface)->next = next;
330 (*insertface)->Italic = (ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 1 : 0;
331 (*insertface)->Bold = (ft_face->style_flags & FT_STYLE_FLAG_BOLD) ? 1 : 0;
332 (*insertface)->font_version = pHeader->Font_Revision;
333 (*insertface)->family = family;
334
335 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
336 if(pOS2) {
337 (*insertface)->fs.fsCsb[0] = pOS2->ulCodePageRange1;
338 (*insertface)->fs.fsCsb[1] = pOS2->ulCodePageRange2;
339 (*insertface)->fs.fsUsb[0] = pOS2->ulUnicodeRange1;
340 (*insertface)->fs.fsUsb[1] = pOS2->ulUnicodeRange2;
341 (*insertface)->fs.fsUsb[2] = pOS2->ulUnicodeRange3;
342 (*insertface)->fs.fsUsb[3] = pOS2->ulUnicodeRange4;
343 } else {
344 (*insertface)->fs.fsCsb[0] = (*insertface)->fs.fsCsb[1] = 0;
345 (*insertface)->fs.fsUsb[0] = 0;
346 (*insertface)->fs.fsUsb[1] = 0;
347 (*insertface)->fs.fsUsb[2] = 0;
348 (*insertface)->fs.fsUsb[3] = 0;
349 }
350 TRACE("fsCsb = %08lx %08lx/%08lx %08lx %08lx %08lx\n",
351 (*insertface)->fs.fsCsb[0], (*insertface)->fs.fsCsb[1],
352 (*insertface)->fs.fsUsb[0], (*insertface)->fs.fsUsb[1],
353 (*insertface)->fs.fsUsb[2], (*insertface)->fs.fsUsb[3]);
354
355 if((*insertface)->fs.fsCsb[0] == 0) { /* let's see if we can find any interesting cmaps */
356 for(i = 0; i < ft_face->num_charmaps &&
357 !(*insertface)->fs.fsCsb[0]; i++) {
358 switch(ft_face->charmaps[i]->encoding) {
359 case ft_encoding_unicode:
360 (*insertface)->fs.fsCsb[0] = 1;
361 break;
362 case ft_encoding_symbol:
363 (*insertface)->fs.fsCsb[0] = 1L << 31;
364 break;
365 default:
366 break;
367 }
368 }
369 }
370
371 if((*insertface)->fs.fsCsb[0] & ~(1L << 31))
372 have_installed_roman_font = TRUE;
373
374 num_faces = ft_face->num_faces;
375 pFT_Done_Face(ft_face);
376 TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
377 debugstr_w(StyleW));
378 } while(num_faces > ++face_index);
379 return TRUE;
380 }
381
382 static void DumpFontList(void)
383 {
384 Family *family;
385 Face *face;
386
387 for(family = FontList; family; family = family->next) {
388 TRACE("Family: %s\n", debugstr_w(family->FamilyName));
389 for(face = family->FirstFace; face; face = face->next) {
390 TRACE("\t%s\n", debugstr_w(face->StyleName));
391 }
392 }
393 return;
394 }
395
396 static void DumpSubstList(void)
397 {
398 FontSubst *psub;
399
400 for(psub = substlist; psub; psub = psub->next)
401 if(psub->from.charset != -1 || psub->to.charset != -1)
402 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
403 psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
404 else
405 TRACE("%s -> %s\n", debugstr_w(psub->from.name),
406 debugstr_w(psub->to.name));
407 return;
408 }
409
410 static LPWSTR strdupW(LPWSTR p)
411 {
412 LPWSTR ret;
413 DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
414 ret = HeapAlloc(GetProcessHeap(), 0, len);
415 memcpy(ret, p, len);
416 return ret;
417 }
418
419 static void split_subst_info(NameCs *nc, LPSTR str)
420 {
421 CHAR *p = strrchr(str, ',');
422 DWORD len;
423
424 nc->charset = -1;
425 if(p && *(p+1)) {
426 nc->charset = strtol(p+1, NULL, 10);
427 *p = '\0';
428 }
429 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
430 nc->name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
431 MultiByteToWideChar(CP_ACP, 0, str, -1, nc->name, len);
432 }
433
434 static void LoadSubstList(void)
435 {
436 FontSubst *psub, **ppsub;
437 HKEY hkey;
438 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
439 LPSTR value;
440 LPVOID data;
441
442 if(substlist) {
443 for(psub = substlist; psub;) {
444 FontSubst *ptmp;
445 HeapFree(GetProcessHeap(), 0, psub->to.name);
446 HeapFree(GetProcessHeap(), 0, psub->from.name);
447 ptmp = psub;
448 psub = psub->next;
449 HeapFree(GetProcessHeap(), 0, ptmp);
450 }
451 substlist = NULL;
452 }
453
454 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
455 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
456 &hkey) == ERROR_SUCCESS) {
457
458 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
459 &valuelen, &datalen, NULL, NULL);
460
461 valuelen++; /* returned value doesn't include room for '\0' */
462 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
463 data = HeapAlloc(GetProcessHeap(), 0, datalen);
464
465 dlen = datalen;
466 vlen = valuelen;
467 ppsub = &substlist;
468 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
469 &dlen) == ERROR_SUCCESS) {
470 TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
471
472 *ppsub = HeapAlloc(GetProcessHeap(), 0, sizeof(**ppsub));
473 (*ppsub)->next = NULL;
474 split_subst_info(&((*ppsub)->from), value);
475 split_subst_info(&((*ppsub)->to), data);
476
477 /* Win 2000 doesn't allow mapping between different charsets
478 or mapping of DEFAULT_CHARSET */
479 if(((*ppsub)->to.charset != (*ppsub)->from.charset) ||
480 (*ppsub)->to.charset == DEFAULT_CHARSET) {
481 HeapFree(GetProcessHeap(), 0, (*ppsub)->to.name);
482 HeapFree(GetProcessHeap(), 0, (*ppsub)->from.name);
483 HeapFree(GetProcessHeap(), 0, *ppsub);
484 *ppsub = NULL;
485 } else {
486 ppsub = &((*ppsub)->next);
487 }
488 /* reset dlen and vlen */
489 dlen = datalen;
490 vlen = valuelen;
491 }
492 HeapFree(GetProcessHeap(), 0, data);
493 HeapFree(GetProcessHeap(), 0, value);
494 RegCloseKey(hkey);
495 }
496 }
497
498 /***********************************************************
499 * The replacement list is a way to map an entire font
500 * family onto another family. For example adding
501 *
502 * [HKLM\Software\Wine\Wine\FontReplacements]
503 * "Wingdings"="Winedings"
504 *
505 * would enumerate the Winedings font both as Winedings and
506 * Wingdings. However if a real Wingdings font is present the
507 * replacement does not take place.
508 *
509 */
510 static void LoadReplaceList(void)
511 {
512 HKEY hkey;
513 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
514 LPSTR value;
515 LPVOID data;
516 Family *family;
517 Face *face;
518 WCHAR old_nameW[200];
519
520 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
521 "Software\\Wine\\Wine\\FontReplacements",
522 &hkey) == ERROR_SUCCESS) {
523
524 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
525 &valuelen, &datalen, NULL, NULL);
526
527 valuelen++; /* returned value doesn't include room for '\0' */
528 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
529 data = HeapAlloc(GetProcessHeap(), 0, datalen);
530
531 dlen = datalen;
532 vlen = valuelen;
533 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
534 &dlen) == ERROR_SUCCESS) {
535 TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
536 /* "NewName"="Oldname" */
537 if(!MultiByteToWideChar(CP_ACP, 0, data, -1, old_nameW, sizeof(old_nameW)))
538 break;
539
540 /* Find the old family and hence all of the font files
541 in that family */
542 for(family = FontList; family; family = family->next) {
543 if(!strcmpiW(family->FamilyName, old_nameW)) {
544 for(face = family->FirstFace; face; face = face->next) {
545 TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
546 debugstr_w(face->StyleName), value);
547 /* Now add a new entry with the new family name */
548 AddFontFileToList(face->file, value);
549 }
550 break;
551 }
552 }
553 /* reset dlen and vlen */
554 dlen = datalen;
555 vlen = valuelen;
556 }
557 HeapFree(GetProcessHeap(), 0, data);
558 HeapFree(GetProcessHeap(), 0, value);
559 RegCloseKey(hkey);
560 }
561 }
562
563
564 static BOOL ReadFontDir(char *dirname)
565 {
566 DIR *dir;
567 struct dirent *dent;
568 char path[MAX_PATH];
569
570 TRACE("Loading fonts from %s\n", debugstr_a(dirname));
571
572 dir = opendir(dirname);
573 if(!dir) {
574 ERR("Can't open directory %s\n", debugstr_a(dirname));
575 return FALSE;
576 }
577 while((dent = readdir(dir)) != NULL) {
578 struct stat statbuf;
579
580 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
581 continue;
582
583 TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
584
585 sprintf(path, "%s/%s", dirname, dent->d_name);
586
587 if(stat(path, &statbuf) == -1)
588 {
589 WARN("Can't stat %s\n", debugstr_a(path));
590 continue;
591 }
592 if(S_ISDIR(statbuf.st_mode))
593 ReadFontDir(path);
594 else
595 AddFontFileToList(path, NULL);
596 }
597 closedir(dir);
598 return TRUE;
599 }
600
601 /*************************************************************
602 * WineEngAddFontResourceEx
603 *
604 */
605 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
606 {
607 if (ft_handle) /* do it only if we have freetype up and running */
608 {
609 DWORD len = WideCharToMultiByte(CP_ACP, 0, file, -1, NULL, 0, NULL, NULL);
610 LPSTR fileA = HeapAlloc(GetProcessHeap(), 0, len);
611 char unixname[MAX_PATH];
612 WideCharToMultiByte(CP_ACP, 0, file, -1, fileA, len, NULL, NULL);
613
614 if(flags)
615 FIXME("Ignoring flags %lx\n", flags);
616
617 if(wine_get_unix_file_name(fileA, unixname, sizeof(unixname)))
618 AddFontFileToList(unixname, NULL);
619 HeapFree(GetProcessHeap(), 0, fileA);
620 }
621 return 1;
622 }
623
624 /*************************************************************
625 * WineEngRemoveFontResourceEx
626 *
627 */
628 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
629 {
630 FIXME(":stub\n");
631 return TRUE;
632 }
633
634 /*************************************************************
635 * WineEngInit
636 *
637 * Initialize FreeType library and create a list of available faces
638 */
639 BOOL WineEngInit(void)
640 {
641 HKEY hkey;
642 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
643 LPSTR value;
644 LPVOID data;
645 char windowsdir[MAX_PATH];
646 char unixname[MAX_PATH];
647
648 TRACE("\n");
649
650 ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
651 if(!ft_handle) {
652 WINE_MESSAGE(
653 "Wine cannot find the FreeType font library. To enable Wine to\n"
654 "use TrueType fonts please install a version of FreeType greater than\n"
655 "or equal to 2.0.5.\n"
656 "http://www.freetype.org\n");
657 return FALSE;
658 }
659
660 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(ft_handle, #f, NULL, 0)) == NULL){WARN("Can't find symbol %s\n", #f); goto sym_not_found;}
661
662 LOAD_FUNCPTR(FT_Cos)
663 LOAD_FUNCPTR(FT_Done_Face)
664 LOAD_FUNCPTR(FT_Get_Char_Index)
665 LOAD_FUNCPTR(FT_Get_Sfnt_Table)
666 LOAD_FUNCPTR(FT_Init_FreeType)
667 LOAD_FUNCPTR(FT_Load_Glyph)
668 LOAD_FUNCPTR(FT_MulFix)
669 LOAD_FUNCPTR(FT_New_Face)
670 LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
671 LOAD_FUNCPTR(FT_Outline_Transform)
672 LOAD_FUNCPTR(FT_Outline_Translate)
673 LOAD_FUNCPTR(FT_Select_Charmap)
674 LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
675 LOAD_FUNCPTR(FT_Sin)
676 LOAD_FUNCPTR(FT_Vector_Rotate)
677
678 #undef LOAD_FUNCPTR
679 /* Don't warn if this one is missing */
680 pFT_Library_Version = wine_dlsym(ft_handle, "FT_Library_Version", NULL, 0);
681 pFT_Load_Sfnt_Table = wine_dlsym(ft_handle, "FT_Load_Sfnt_Table", NULL, 0);
682
683 if(!wine_dlsym(ft_handle, "FT_Get_Postscript_Name", NULL, 0) &&
684 !wine_dlsym(ft_handle, "FT_Sqrt64", NULL, 0)) {
685 /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
686 <= 2.0.3 has FT_Sqrt64 */
687 goto sym_not_found;
688 }
689
690 if(pFT_Init_FreeType(&library) != 0) {
691 ERR("Can't init FreeType library\n");
692 wine_dlclose(ft_handle, NULL, 0);
693 ft_handle = NULL;
694 return FALSE;
695 }
696 FT_Version.major=FT_Version.minor=FT_Version.patch=-1;
697 if (pFT_Library_Version)
698 {
699 pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
700 }
701 if (FT_Version.major<=0)
702 {
703 FT_Version.major=2;
704 FT_Version.minor=0;
705 FT_Version.patch=5;
706 }
707 TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
708
709 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
710 GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
711 strcat(windowsdir, "\\Fonts");
712 if(wine_get_unix_file_name(windowsdir, unixname, sizeof(unixname)))
713 ReadFontDir(unixname);
714
715 /* now look under HKLM\Software\Microsoft\Windows\CurrentVersion\Fonts
716 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
717 full path as the entry */
718 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
719 "Software\\Microsoft\\Windows\\CurrentVersion\\Fonts",
720 &hkey) == ERROR_SUCCESS) {
721 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
722 &valuelen, &datalen, NULL, NULL);
723
724 valuelen++; /* returned value doesn't include room for '\0' */
725 value = HeapAlloc(GetProcessHeap(), 0, valuelen);
726 data = HeapAlloc(GetProcessHeap(), 0, datalen);
727
728 dlen = datalen;
729 vlen = valuelen;
730 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
731 &dlen) == ERROR_SUCCESS) {
732 if(((LPSTR)data)[0] && ((LPSTR)data)[1] == ':')
733 if(wine_get_unix_file_name((LPSTR)data, unixname, sizeof(unixname)))
734 AddFontFileToList(unixname, NULL);
735
736 /* reset dlen and vlen */
737 dlen = datalen;
738 vlen = valuelen;
739 }
740 HeapFree(GetProcessHeap(), 0, data);
741 HeapFree(GetProcessHeap(), 0, value);
742 RegCloseKey(hkey);
743 }
744
745
746 /* then look in any directories that we've specified in the config file */
747 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
748 "Software\\Wine\\Wine\\Config\\FontDirs",
749 &hkey) == ERROR_SUCCESS) {
750
751 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
752 &valuelen, &datalen, NULL, NULL);
753
754 valuelen++; /* returned value doesn't include room for '\0' */
755 value = HeapAlloc(GetProcessHeap(), 0, valuelen);
756 data = HeapAlloc(GetProcessHeap(), 0, datalen);
757
758 dlen = datalen;
759 vlen = valuelen;
760 i = 0;
761 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
762 &dlen) == ERROR_SUCCESS) {
763 TRACE("Got %s=%s\n", value, (LPSTR)data);
764 ReadFontDir((LPSTR)data);
765 /* reset dlen and vlen */
766 dlen = datalen;
767 vlen = valuelen;
768 }
769 HeapFree(GetProcessHeap(), 0, data);
770 HeapFree(GetProcessHeap(), 0, value);
771 RegCloseKey(hkey);
772 }
773
774 DumpFontList();
775 LoadSubstList();
776 DumpSubstList();
777 LoadReplaceList();
778 return TRUE;
779 sym_not_found:
780 WINE_MESSAGE(
781 "Wine cannot find certain functions that it needs inside the FreeType\n"
782 "font library. To enable Wine to use TrueType fonts please upgrade\n"
783 "FreeType to at least version 2.0.5.\n"
784 "http://www.freetype.org\n");
785 wine_dlclose(ft_handle, NULL, 0);
786 ft_handle = NULL;
787 return FALSE;
788 }
789
790
791 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
792 {
793 TT_OS2 *pOS2;
794 LONG ppem;
795
796 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
797
798 if(height == 0) height = 16;
799
800 /* Calc. height of EM square:
801 *
802 * For +ve lfHeight we have
803 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
804 * Re-arranging gives:
805 * ppem = units_per_em * lfheight / (winAscent + winDescent)
806 *
807 * For -ve lfHeight we have
808 * |lfHeight| = ppem
809 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
810 * with il = winAscent + winDescent - units_per_em]
811 *
812 */
813
814 if(height > 0)
815 ppem = ft_face->units_per_EM * height /
816 (pOS2->usWinAscent + pOS2->usWinDescent);
817 else
818 ppem = -height;
819
820 return ppem;
821 }
822
823 static LONG load_VDMX(GdiFont, LONG);
824
825 static FT_Face OpenFontFile(GdiFont font, char *file, FT_Long face_index, LONG height)
826 {
827 FT_Error err;
828 FT_Face ft_face;
829 LONG ppem;
830
831 err = pFT_New_Face(library, file, face_index, &ft_face);
832 if(err) {
833 ERR("FT_New_Face rets %d\n", err);
834 return 0;
835 }
836
837 /* set it here, as load_VDMX needs it */
838 font->ft_face = ft_face;
839
840 /* load the VDMX table if we have one */
841 ppem = load_VDMX(font, height);
842 if(ppem == 0)
843 ppem = calc_ppem_for_height(ft_face, height);
844
845 pFT_Set_Pixel_Sizes(ft_face, 0, ppem);
846
847 return ft_face;
848 }
849
850
851 static int get_nearest_charset(Face *face)
852 {
853 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
854 a single face with the requested charset. The idea is to check if
855 the selected font supports the current ANSI codepage, if it does
856 return the corresponding charset, else return the first charset */
857
858 CHARSETINFO csi;
859 int acp = GetACP(), i;
860 DWORD fs0;
861
862 if(TranslateCharsetInfo((DWORD*)acp, &csi, TCI_SRCCODEPAGE))
863 if(csi.fs.fsCsb[0] & face->fs.fsCsb[0])
864 return csi.ciCharset;
865
866 for(i = 0; i < 32; i++) {
867 fs0 = 1L << i;
868 if(face->fs.fsCsb[0] & fs0) {
869 if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG))
870 return csi.ciCharset;
871 else
872 FIXME("TCI failing on %lx\n", fs0);
873 }
874 }
875
876 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08lx file = %s\n",
877 face->fs.fsCsb[0], face->file);
878 return DEFAULT_CHARSET;
879 }
880
881 static GdiFont alloc_font(void)
882 {
883 GdiFont ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
884 ret->gmsize = INIT_GM_SIZE;
885 ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
886 ret->gmsize * sizeof(*ret->gm));
887 ret->next = NULL;
888 ret->potm = NULL;
889 ret->xform.eM11 = ret->xform.eM22 = 1.0;
890 return ret;
891 }
892
893 static void free_font(GdiFont font)
894 {
895 if (font->ft_face) pFT_Done_Face(font->ft_face);
896 if (font->potm) HeapFree(GetProcessHeap(), 0, font->potm);
897 if (font->name) HeapFree(GetProcessHeap(), 0, font->name);
898 HeapFree(GetProcessHeap(), 0, font->gm);
899 HeapFree(GetProcessHeap(), 0, font);
900 }
901
902
903 /*************************************************************
904 * load_VDMX
905 *
906 * load the vdmx entry for the specified height
907 */
908
909 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
910 ( ( (FT_ULong)_x4 << 24 ) | \
911 ( (FT_ULong)_x3 << 16 ) | \
912 ( (FT_ULong)_x2 << 8 ) | \
913 (FT_ULong)_x1 )
914
915 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
916
917 typedef struct {
918 BYTE bCharSet;
919 BYTE xRatio;
920 BYTE yStartRatio;
921 BYTE yEndRatio;
922 } Ratios;
923
924
925 static LONG load_VDMX(GdiFont font, LONG height)
926 {
927 BYTE hdr[6], tmp[2], group[4];
928 BYTE devXRatio, devYRatio;
929 USHORT numRecs, numRatios;
930 DWORD offset = -1;
931 LONG ppem = 0;
932 int i, result;
933
934 result = WineEngGetFontData(font, MS_VDMX_TAG, 0, hdr, 6);
935
936 if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
937 return ppem;
938
939 /* FIXME: need the real device aspect ratio */
940 devXRatio = 1;
941 devYRatio = 1;
942
943 numRecs = GET_BE_WORD(&hdr[2]);
944 numRatios = GET_BE_WORD(&hdr[4]);
945
946 TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
947 for(i = 0; i < numRatios; i++) {
948 Ratios ratio;
949
950 offset = (3 * 2) + (i * sizeof(Ratios));
951 WineEngGetFontData(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
952 offset = -1;
953
954 TRACE("Ratios[%d] %d %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
955
956 if(ratio.bCharSet != 1)
957 continue;
958
959 if((ratio.xRatio == 0 &&
960 ratio.yStartRatio == 0 &&
961 ratio.yEndRatio == 0) ||
962 (devXRatio == ratio.xRatio &&
963 devYRatio >= ratio.yStartRatio &&
964 devYRatio <= ratio.yEndRatio))
965 {
966 offset = (3 * 2) + (numRatios * 4) + (i * 2);
967 WineEngGetFontData(font, MS_VDMX_TAG, offset, tmp, 2);
968 offset = GET_BE_WORD(tmp);
969 break;
970 }
971 }
972
973 if(offset < 0) {
974 FIXME("No suitable ratio found\n");
975 return ppem;
976 }
977
978 if(WineEngGetFontData(font, MS_VDMX_TAG, offset, group, 4) != GDI_ERROR) {
979 USHORT recs;
980 BYTE startsz, endsz;
981 BYTE *vTable;
982
983 recs = GET_BE_WORD(group);
984 startsz = group[2];
985 endsz = group[3];
986
987 TRACE("recs=%d startsz=%d endsz=%d\n", recs, startsz, endsz);
988
989 vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
990 result = WineEngGetFontData(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
991 if(result == GDI_ERROR) {
992 FIXME("Failed to retrieve vTable\n");
993 goto end;
994 }
995
996 if(height > 0) {
997 for(i = 0; i < recs; i++) {
998 SHORT yMax = GET_BE_WORD(&vTable[(i * 6) + 2]);
999 SHORT yMin = GET_BE_WORD(&vTable[(i * 6) + 4]);
1000 ppem = GET_BE_WORD(&vTable[i * 6]);
1001
1002 if(yMax + -yMin == height) {
1003 font->yMax = yMax;
1004 font->yMin = yMin;
1005 TRACE("ppem %ld found; height=%ld yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
1006 break;
1007 }
1008 if(yMax + -yMin > height) {
1009 if(--i < 0) {
1010 ppem = 0;
1011 goto end; /* failed */
1012 }
1013 font->yMax = GET_BE_WORD(&vTable[(i * 6) + 2]);
1014 font->yMin = GET_BE_WORD(&vTable[(i * 6) + 4]);
1015 TRACE("ppem %ld found; height=%ld yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
1016 break;
1017 }
1018 }
1019 if(!font->yMax) {
1020 ppem = 0;
1021 TRACE("ppem not found for height %ld\n", height);
1022 }
1023 } else {
1024 ppem = -height;
1025 if(ppem < startsz || ppem > endsz)
1026 goto end;
1027
1028 for(i = 0; i < recs; i++) {
1029 USHORT yPelHeight;
1030 yPelHeight = GET_BE_WORD(&vTable[i * 6]);
1031
1032 if(yPelHeight > ppem)
1033 break; /* failed */
1034
1035 if(yPelHeight == ppem) {
1036 font->yMax = GET_BE_WORD(&vTable[(i * 6) + 2]);
1037 font->yMin = GET_BE_WORD(&vTable[(i * 6) + 4]);
1038 TRACE("ppem %ld found; yMax=%d yMin=%d\n", ppem, font->yMax, font->yMin);
1039 break;
1040 }
1041 }
1042 }
1043 end:
1044 HeapFree(GetProcessHeap(), 0, vTable);
1045 }
1046
1047 return ppem;
1048 }
1049
1050
1051 /*************************************************************
1052 * WineEngCreateFontInstance
1053 *
1054 */
1055 GdiFont WineEngCreateFontInstance(DC *dc, HFONT hfont)
1056 {
1057 GdiFont ret;
1058 Face *face;
1059 Family *family = NULL;
1060 BOOL bd, it;
1061 LOGFONTW lf;
1062 CHARSETINFO csi;
1063
1064 if (!GetObjectW( hfont, sizeof(lf), &lf )) return NULL;
1065
1066 TRACE("%s, h=%ld, it=%d, weight=%ld, PandF=%02x, charset=%d orient %ld escapement %ld\n",
1067 debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
1068 lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
1069 lf.lfEscapement);
1070
1071 /* check the cache first */
1072 for(ret = GdiFontList; ret; ret = ret->next) {
1073 if(ret->hfont == hfont && !memcmp(&ret->xform, &dc->xformWorld2Vport, offsetof(XFORM, eDx))) {
1074 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
1075 return ret;
1076 }
1077 }
1078
1079 if(!FontList || !have_installed_roman_font) /* No fonts installed */
1080 {
1081 TRACE("No fonts installed\n");
1082 return NULL;
1083 }
1084
1085 ret = alloc_font();
1086 memcpy(&ret->xform, &dc->xformWorld2Vport, sizeof(XFORM));
1087
1088 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
1089 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
1090 original value lfCharSet. Note this is a special case for
1091 Symbol and doesn't happen at least for "Wingdings*" */
1092
1093 if(!strcmpiW(lf.lfFaceName, SymbolW))
1094 lf.lfCharSet = SYMBOL_CHARSET;
1095
1096 if(!TranslateCharsetInfo((DWORD*)(INT)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
1097 switch(lf.lfCharSet) {
1098 case DEFAULT_CHARSET:
1099 csi.fs.fsCsb[0] = 0;
1100 break;
1101 default:
1102 FIXME("Untranslated charset %d\n", lf.lfCharSet);
1103 csi.fs.fsCsb[0] = 0;
1104 break;
1105 }
1106 }
1107
1108 if(lf.lfFaceName[0] != '\0') {
1109 FontSubst *psub;
1110 for(psub = substlist; psub; psub = psub->next)
1111 if(!strcmpiW(lf.lfFaceName, psub->from.name) &&
1112 (psub->from.charset == -1 ||
1113 psub->from.charset == lf.lfCharSet))
1114 break;
1115 if(psub) {
1116 TRACE("substituting %s -> %s\n", debugstr_w(lf.lfFaceName),
1117 debugstr_w(psub->to.name));
1118 strcpyW(lf.lfFaceName, psub->to.name);
1119 }
1120
1121 /* We want a match on name and charset or just name if
1122 charset was DEFAULT_CHARSET. If the latter then
1123 we fixup the returned charset later in get_nearest_charset
1124 where we'll either use the charset of the current ansi codepage
1125 or if that's unavailable the first charset that the font supports.
1126 */
1127 for(family = FontList; family; family = family->next) {
1128 if(!strcmpiW(family->FamilyName, lf.lfFaceName))
1129 if((csi.fs.fsCsb[0] & family->FirstFace->fs.fsCsb[0]) || !csi.fs.fsCsb[0])
1130 break;
1131 }
1132
1133 if(!family) { /* do other aliases here */
1134 if(!strcmpiW(lf.lfFaceName, SystemW))
1135 strcpyW(lf.lfFaceName, defSystem);
1136 else if(!strcmpiW(lf.lfFaceName, MSSansSerifW))
1137 strcpyW(lf.lfFaceName, defSans);
1138 else if(!strcmpiW(lf.lfFaceName, HelvW))
1139 strcpyW(lf.lfFaceName, defSans);
1140 else
1141 goto not_found;
1142
1143 for(family = FontList; family; family = family->next) {
1144 if(!strcmpiW(family->FamilyName, lf.lfFaceName))
1145 if((csi.fs.fsCsb[0] & family->FirstFace->fs.fsCsb[0]) || !csi.fs.fsCsb[0])
1146 break;
1147 }
1148 }
1149 }
1150
1151 not_found:
1152 if(!family) {
1153 /* If requested charset was DEFAULT_CHARSET then try using charset
1154 corresponding to the current ansi codepage */
1155 if(!csi.fs.fsCsb[0]) {
1156 INT acp = GetACP();
1157 if(!TranslateCharsetInfo((DWORD*)acp, &csi, TCI_SRCCODEPAGE)) {
1158 FIXME("TCI failed on codepage %d\n", acp);
1159 csi.fs.fsCsb[0] = 0;
1160 } else
1161 lf.lfCharSet = csi.ciCharset;
1162 }
1163 if(lf.lfPitchAndFamily & FIXED_PITCH ||
1164 lf.lfPitchAndFamily & FF_MODERN)
1165 strcpyW(lf.lfFaceName, defFixed);
1166 else if(lf.lfPitchAndFamily & FF_ROMAN)
1167 strcpyW(lf.lfFaceName, defSerif);
1168 else if(lf.lfPitchAndFamily & FF_SWISS)
1169 strcpyW(lf.lfFaceName, defSans);
1170 else
1171 strcpyW(lf.lfFaceName, defSans);
1172 for(family = FontList; family; family = family->next) {
1173 if(!strcmpiW(family->FamilyName, lf.lfFaceName) &&
1174 (csi.fs.fsCsb[0] & family->FirstFace->fs.fsCsb[0]))
1175 break;
1176 }
1177 }
1178
1179 if(!family) {
1180 for(family = FontList; family; family = family->next) {
1181 if(csi.fs.fsCsb[0] & family->FirstFace->fs.fsCsb[0])
1182 break;
1183 }
1184 }
1185
1186 if(!family) {
1187 family = FontList;
1188 csi.fs.fsCsb[0] = 0;
1189 FIXME("just using first face for now\n");
1190 }
1191
1192 it = lf.lfItalic ? 1 : 0;
1193 bd = lf.lfWeight > 550 ? 1 : 0;
1194
1195 for(face = family->FirstFace; face; face = face->next) {
1196 if(!(face->Italic ^ it) && !(face->Bold ^ bd))
1197 break;
1198 }
1199 if(!face) {
1200 face = family->FirstFace;
1201 if(it && !face->Italic) ret->fake_italic = TRUE;
1202 if(bd && !face->Bold) ret->fake_bold = TRUE;
1203 }
1204
1205 memcpy(&ret->fs, &face->fs, sizeof(FONTSIGNATURE));
1206
1207 if(csi.fs.fsCsb[0])
1208 ret->charset = lf.lfCharSet;
1209 else
1210 ret->charset = get_nearest_charset(face);
1211
1212 TRACE("Chosen: %s %s\n", debugstr_w(family->FamilyName),
1213 debugstr_w(face->StyleName));
1214
1215 ret->ft_face = OpenFontFile(ret, face->file, face->face_index,
1216 lf.lfHeight < 0 ?
1217 -abs(INTERNAL_YWSTODS(dc,lf.lfHeight)) :
1218 abs(INTERNAL_YWSTODS(dc, lf.lfHeight)));
1219 if (!ret->ft_face)
1220 {
1221 free_font( ret );
1222 return 0;
1223 }
1224
1225 if(ret->charset == SYMBOL_CHARSET)
1226 pFT_Select_Charmap(ret->ft_face, ft_encoding_symbol);
1227 ret->orientation = lf.lfOrientation;
1228 ret->name = strdupW(family->FamilyName);
1229
1230 TRACE("caching: gdiFont=%p hfont=%p\n", ret, hfont);
1231 ret->hfont = hfont;
1232 ret->next = GdiFontList;
1233 GdiFontList = ret;
1234
1235 return ret;
1236 }
1237
1238 static void DumpGdiFontList(void)
1239 {
1240 GdiFont gdiFont;
1241
1242 TRACE("---------- gdiFont Cache ----------\n");
1243 for(gdiFont = GdiFontList; gdiFont; gdiFont = gdiFont->next) {
1244 LOGFONTW lf;
1245 GetObjectW( gdiFont->hfont, sizeof(lf), &lf );
1246 TRACE("gdiFont=%p hfont=%p (%s)\n",
1247 gdiFont, gdiFont->hfont, debugstr_w(lf.lfFaceName));
1248 }
1249 }
1250
1251 /*************************************************************
1252 * WineEngDestroyFontInstance
1253 *
1254 * free the gdiFont associated with this handle
1255 *
1256 */
1257 BOOL WineEngDestroyFontInstance(HFONT handle)
1258 {
1259 GdiFont gdiFont;
1260 GdiFont gdiPrev = NULL;
1261 BOOL ret = FALSE;
1262
1263 TRACE("destroying hfont=%p\n", handle);
1264 if(TRACE_ON(font))
1265 DumpGdiFontList();
1266
1267 gdiFont = GdiFontList;
1268 while(gdiFont) {
1269 if(gdiFont->hfont == handle) {
1270 if(gdiPrev) {
1271 gdiPrev->next = gdiFont->next;
1272 free_font(gdiFont);
1273 gdiFont = gdiPrev->next;
1274 } else {
1275 GdiFontList = gdiFont->next;
1276 free_font(gdiFont);
1277 gdiFont = GdiFontList;
1278 }
1279 ret = TRUE;
1280 } else {
1281 gdiPrev = gdiFont;
1282 gdiFont = gdiFont->next;
1283 }
1284 }
1285 return ret;
1286 }
1287
1288 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
1289 NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
1290 {
1291 OUTLINETEXTMETRICW *potm;
1292 UINT size;
1293 GdiFont font = alloc_font();
1294
1295 if (!(font->ft_face = OpenFontFile(font, face->file, face->face_index, 100)))
1296 {
1297 free_font(font);
1298 return;
1299 }
1300
1301 font->name = strdupW(face->family->FamilyName);
1302
1303 memset(&pelf->elfLogFont, 0, sizeof(LOGFONTW));
1304
1305 size = WineEngGetOutlineTextMetrics(font, 0, NULL);
1306 potm = HeapAlloc(GetProcessHeap(), 0, size);
1307 WineEngGetOutlineTextMetrics(font, size, potm);
1308
1309 #define TM potm->otmTextMetrics
1310
1311 pntm->ntmTm.tmHeight = pelf->elfLogFont.lfHeight = TM.tmHeight;
1312 pntm->ntmTm.tmAscent = TM.tmAscent;
1313 pntm->ntmTm.tmDescent = TM.tmDescent;
1314 pntm->ntmTm.tmInternalLeading = TM.tmInternalLeading;
1315 pntm->ntmTm.tmExternalLeading = TM.tmExternalLeading;
1316 pntm->ntmTm.tmAveCharWidth = pelf->elfLogFont.lfWidth = TM.tmAveCharWidth;
1317 pntm->ntmTm.tmMaxCharWidth = TM.tmMaxCharWidth;
1318 pntm->ntmTm.tmWeight = pelf->elfLogFont.lfWeight = TM.tmWeight;
1319 pntm->ntmTm.tmOverhang = TM.tmOverhang;
1320 pntm->ntmTm.tmDigitizedAspectX = TM.tmDigitizedAspectX;
1321 pntm->ntmTm.tmDigitizedAspectY = TM.tmDigitizedAspectY;
1322 pntm->ntmTm.tmFirstChar = TM.tmFirstChar;
1323 pntm->ntmTm.tmLastChar = TM.tmLastChar;
1324 pntm->ntmTm.tmDefaultChar = TM.tmDefaultChar;
1325 pntm->ntmTm.tmBreakChar = TM.tmBreakChar;
1326 pntm->ntmTm.tmItalic = pelf->elfLogFont.lfItalic = TM.tmItalic;
1327 pntm->ntmTm.tmUnderlined = pelf->elfLogFont.lfUnderline = TM.tmUnderlined;
1328 pntm->ntmTm.tmStruckOut = pelf->elfLogFont.lfStrikeOut = TM.tmStruckOut;
1329 pntm->ntmTm.tmPitchAndFamily = TM.tmPitchAndFamily;
1330 pelf->elfLogFont.lfPitchAndFamily = (TM.tmPitchAndFamily & 0xf1) + 1;
1331 pntm->ntmTm.tmCharSet = pelf->elfLogFont.lfCharSet = TM.tmCharSet;
1332 pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
1333 pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
1334 pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
1335
1336 pntm->ntmTm.ntmFlags = TM.tmItalic ? NTM_ITALIC : 0;
1337 if(TM.tmWeight > 550) pntm->ntmTm.ntmFlags |= NTM_BOLD;
1338 if(pntm->ntmTm.ntmFlags == 0) pntm->ntmTm.ntmFlags = NTM_REGULAR;
1339
1340 pntm->ntmTm.ntmSizeEM = potm->otmEMSquare;
1341 pntm->ntmTm.ntmCellHeight = 0;
1342 pntm->ntmTm.ntmAvgWidth = 0;
1343
1344 *ptype = TM.tmPitchAndFamily & TMPF_TRUETYPE ? TRUETYPE_FONTTYPE : 0;
1345 if(!(TM.tmPitchAndFamily & TMPF_VECTOR))
1346 *ptype |= RASTER_FONTTYPE;
1347
1348 #undef TM
1349 memset(&pntm->ntmFontSig, 0, sizeof(FONTSIGNATURE));
1350
1351 strncpyW(pelf->elfLogFont.lfFaceName,
1352 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFamilyName),
1353 LF_FACESIZE);
1354 strncpyW(pelf->elfFullName,
1355 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFaceName),
1356 LF_FULLFACESIZE);
1357 strncpyW(pelf->elfStyle,
1358 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpStyleName),
1359 LF_FACESIZE);
1360 pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
1361
1362 HeapFree(GetProcessHeap(), 0, potm);
1363 free_font(font);
1364 return;
1365 }
1366
1367 /*************************************************************
1368 * WineEngEnumFonts
1369 *
1370 */
1371 DWORD WineEngEnumFonts(LPLOGFONTW plf, DEVICEFONTENUMPROC proc,
1372 LPARAM lparam)
1373 {
1374 Family *family;
1375 Face *face;
1376 ENUMLOGFONTEXW elf;
1377 NEWTEXTMETRICEXW ntm;
1378 DWORD type, ret = 1;
1379 FONTSIGNATURE fs;
1380 CHARSETINFO csi;
1381 LOGFONTW lf;
1382 int i;
1383
1384 TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
1385
1386 if(plf->lfFaceName[0]) {
1387 FontSubst *psub;
1388 for(psub = substlist; psub; psub = psub->next)
1389 if(!strcmpiW(plf->lfFaceName, psub->from.name) &&
1390 (psub->from.charset == -1 ||
1391 psub->from.charset == plf->lfCharSet))
1392 break;
1393 if(psub) {
1394 TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
1395 debugstr_w(psub->to.name));
1396 memcpy(&lf, plf, sizeof(lf));
1397 strcpyW(lf.lfFaceName, psub->to.name);
1398 plf = &lf;
1399 }
1400 for(family = FontList; family; family = family->next) {
1401 if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
1402 for(face = family->FirstFace; face; face = face->next) {
1403 GetEnumStructs(face, &elf, &ntm, &type);
1404 for(i = 0; i < 32; i++) {
1405 if(face->fs.fsCsb[0] & (1L << i)) {
1406 fs.fsCsb[0] = 1L << i;
1407 fs.fsCsb[1] = 0;
1408 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
1409 TCI_SRCFONTSIG))
1410 csi.ciCharset = DEFAULT_CHARSET;
1411 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
1412 if(csi.ciCharset != DEFAULT_CHARSET) {
1413 elf.elfLogFont.lfCharSet =
1414 ntm.ntmTm.tmCharSet = csi.ciCharset;
1415 if(ElfScriptsW[i])
1416 strcpyW(elf.elfScript, ElfScriptsW[i]);
1417 else
1418 FIXME("Unknown elfscript for bit %d\n", i);
1419 TRACE("enuming face %s full %s style %s charset %d type %ld script %s it %d weight %ld ntmflags %08lx\n",
1420 debugstr_w(elf.elfLogFont.lfFaceName),
1421 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
1422 csi.ciCharset, type, debugstr_w(elf.elfScript),
1423 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
1424 ntm.ntmTm.ntmFlags);
1425 ret = proc(&elf, &ntm, type, lparam);
1426 if(!ret) goto end;
1427 }
1428 }
1429 }
1430 }
1431 }
1432 }
1433 } else {
1434 for(family = FontList; family; family = family->next) {
1435 GetEnumStructs(family->FirstFace, &elf, &ntm, &type);
1436 for(i = 0; i < 32; i++) {
1437 if(family->FirstFace->fs.fsCsb[0] & (1L << i)) {
1438 fs.fsCsb[0] = 1L << i;
1439 fs.fsCsb[1] = 0;
1440 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
1441 TCI_SRCFONTSIG))
1442 csi.ciCharset = DEFAULT_CHARSET;
1443 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
1444 if(csi.ciCharset != DEFAULT_CHARSET) {
1445 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet =
1446 csi.ciCharset;
1447 if(ElfScriptsW[i])
1448 strcpyW(elf.elfScript, ElfScriptsW[i]);
1449 else
1450 FIXME("Unknown elfscript for bit %d\n", i);
1451 TRACE("enuming face %s full %s style %s charset = %d type %ld script %s it %d weight %ld ntmflags %08lx\n",
1452 debugstr_w(elf.elfLogFont.lfFaceName),
1453 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
1454 csi.ciCharset, type, debugstr_w(elf.elfScript),
1455 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
1456 ntm.ntmTm.ntmFlags);
1457 ret = proc(&elf, &ntm, type, lparam);
1458 if(!ret) goto end;
1459 }
1460 }
1461 }
1462 }
1463 }
1464 end:
1465 return ret;
1466 }
1467
1468 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
1469 {
1470 pt->x.value = vec->x >> 6;
1471 pt->x.fract = (vec->x & 0x3f) << 10;
1472 pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
1473 pt->y.value = vec->y >> 6;
1474 pt->y.fract = (vec->y & 0x3f) << 10;
1475 pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
1476 return;
1477 }
1478
1479 static FT_UInt get_glyph_index(GdiFont font, UINT glyph)
1480 {
1481 if(font->charset == SYMBOL_CHARSET && glyph < 0x100)
1482 glyph = glyph + 0xf000;
1483 return pFT_Get_Char_Index(font->ft_face, glyph);
1484 }
1485
1486 /*************************************************************
1487 * WineEngGetGlyphIndices
1488 *
1489 * FIXME: add support for GGI_MARK_NONEXISTING_GLYPHS
1490 */
1491 DWORD WineEngGetGlyphIndices(GdiFont font, LPCWSTR lpstr, INT count,
1492 LPWORD pgi, DWORD flags)
1493 {
1494 INT i;
1495
1496 for(i = 0; i < count; i++)
1497 pgi[i] = get_glyph_index(font, lpstr[i]);
1498
1499 return count;
1500 }
1501
1502 /*************************************************************
1503 * WineEngGetGlyphOutline
1504 *
1505 * Behaves in exactly the same way as the win32 api GetGlyphOutline
1506 * except that the first parameter is the HWINEENGFONT of the font in
1507 * question rather than an HDC.
1508 *
1509 */
1510 DWORD WineEngGetGlyphOutline(GdiFont font, UINT glyph, UINT format,
1511 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
1512 const MAT2* lpmat)
1513 {
1514 FT_Face ft_face = font->ft_face;
1515 FT_UInt glyph_index;
1516 DWORD width, height, pitch, needed = 0;
1517 FT_Bitmap ft_bitmap;
1518 FT_Error err;
1519 INT left, right, top = 0, bottom = 0;
1520 FT_Angle angle = 0;
1521 FT_Int load_flags = FT_LOAD_DEFAULT;
1522
1523 TRACE("%p, %04x, %08x, %p, %08lx, %p, %p\n", font, glyph, format, lpgm,
1524 buflen, buf, lpmat);
1525
1526 if(format & GGO_GLYPH_INDEX) {
1527 glyph_index = glyph;
1528 format &= ~GGO_GLYPH_INDEX;
1529 } else
1530 glyph_index = get_glyph_index(font, glyph);
1531
1532 if(glyph_index >= font->gmsize) {
1533 font->gmsize = (glyph_index / INIT_GM_SIZE + 1) * INIT_GM_SIZE;
1534 font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
1535 font->gmsize * sizeof(*font->gm));
1536 } else {
1537 if(format == GGO_METRICS && font->gm[glyph_index].init) {
1538 memcpy(lpgm, &font->gm[glyph_index].gm, sizeof(*lpgm));
1539 return 1; /* FIXME */
1540 }
1541 }
1542
1543 if(font->orientation || (format != GGO_METRICS && format != GGO_BITMAP))
1544 load_flags |= FT_LOAD_NO_BITMAP;
1545
1546 err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
1547
1548 if(err) {
1549 FIXME("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
1550 return GDI_ERROR;
1551 }
1552
1553 left = ft_face->glyph->metrics.horiBearingX & -64;
1554 right = ((ft_face->glyph->metrics.horiBearingX +
1555 ft_face->glyph->metrics.width) + 63) & -64;
1556
1557 font->gm[glyph_index].adv = (ft_face->glyph->metrics.horiAdvance + 63) >> 6;
1558 font->gm[glyph_index].lsb = left >> 6;
1559 font->gm[glyph_index].bbx = (right - left) >> 6;
1560
1561 if(font->orientation == 0) {
1562 top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
1563 bottom = (ft_face->glyph->metrics.horiBearingY -
1564 ft_face->glyph->metrics.height) & -64;
1565 lpgm->gmCellIncX = font->gm[glyph_index].adv;
1566 lpgm->gmCellIncY = 0;
1567 } else {
1568 INT xc, yc;
1569 FT_Vector vec;
1570 angle = font->orientation / 10 << 16;
1571 angle |= ((font->orientation % 10) * (1 << 16)) / 10;
1572 TRACE("angle %ld\n", angle >> 16);
1573 for(xc = 0; xc < 2; xc++) {
1574 for(yc = 0; yc < 2; yc++) {
1575 vec.x = ft_face->glyph->metrics.horiBearingX +
1576 xc * ft_face->glyph->metrics.width;
1577 vec.y = ft_face->glyph->metrics.horiBearingY -
1578 yc * ft_face->glyph->metrics.height;
1579 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
1580 pFT_Vector_Rotate(&vec, angle);
1581 if(xc == 0 && yc == 0) {
1582 left = right = vec.x;
1583 top = bottom = vec.y;
1584 } else {
1585 if(vec.x < left) left = vec.x;
1586 else if(vec.x > right) right = vec.x;
1587 if(vec.y < bottom) bottom = vec.y;
1588 else if(vec.y > top) top = vec.y;
1589 }
1590 }
1591 }
1592 left = left & -64;
1593 right = (right + 63) & -64;
1594 bottom = bottom & -64;
1595 top = (top + 63) & -64;
1596
1597 TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
1598 vec.x = ft_face->glyph->metrics.horiAdvance;
1599 vec.y = 0;
1600 pFT_Vector_Rotate(&vec, angle);
1601 lpgm->gmCellIncX = (vec.x+63) >> 6;
1602 lpgm->gmCellIncY = -(vec.y+63) >> 6;
1603 }
1604 lpgm->gmBlackBoxX = (right - left) >> 6;
1605 lpgm->gmBlackBoxY = (top - bottom) >> 6;
1606 lpgm->gmptGlyphOrigin.x = left >> 6;
1607 lpgm->gmptGlyphOrigin.y = top >> 6;
1608
1609 memcpy(&font->gm[glyph_index].gm, lpgm, sizeof(*lpgm));
1610 font->gm[glyph_index].init = TRUE;
1611
1612 if(format == GGO_METRICS)
1613 return 1; /* FIXME */
1614
1615 if(ft_face->glyph->format != ft_glyph_format_outline && format != GGO_BITMAP) {
1616 FIXME("loaded a bitmap\n");
1617 return GDI_ERROR;
1618 }
1619
1620 switch(format) {
1621 case GGO_BITMAP:
1622 width = lpgm->gmBlackBoxX;
1623 height = lpgm->gmBlackBoxY;
1624 pitch = (width + 31) / 32 * 4;
1625 needed = pitch * height;
1626
1627 if(!buf || !buflen) break;
1628
1629 switch(ft_face->glyph->format) {
1630 case ft_glyph_format_bitmap:
1631 {
1632 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
1633 INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
1634 INT h = ft_face->glyph->bitmap.rows;
1635 while(h--) {
1636 memcpy(dst, src, w);
1637 src += ft_face->glyph->bitmap.pitch;
1638 dst += pitch;
1639 }
1640 break;
1641 }
1642
1643 case ft_glyph_format_outline:
1644 ft_bitmap.width = width;
1645 ft_bitmap.rows = height;
1646 ft_bitmap.pitch = pitch;
1647 ft_bitmap.pixel_mode = ft_pixel_mode_mono;
1648 ft_bitmap.buffer = buf;
1649
1650 if(font->orientation) {
1651 FT_Matrix matrix;
1652 matrix.xx = matrix.yy = pFT_Cos(angle);
1653 matrix.xy = -pFT_Sin(angle);
1654 matrix.yx = -matrix.xy;
1655
1656 pFT_Outline_Transform(&ft_face->glyph->outline, &matrix);
1657 }
1658
1659 if (lpmat) pFT_Outline_Transform(&ft_face->glyph->outline, (FT_Matrix *)lpmat);
1660 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
1661
1662 /* Note: FreeType will only set 'black' bits for us. */
1663 memset(buf, 0, needed);
1664 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
1665 break;
1666
1667 default:
1668 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
1669 return GDI_ERROR;
1670 }
1671 break;
1672
1673 case GGO_GRAY2_BITMAP:
1674 case GGO_GRAY4_BITMAP:
1675 case GGO_GRAY8_BITMAP:
1676 case WINE_GGO_GRAY16_BITMAP:
1677 {
1678 int mult, row, col;
1679 BYTE *start, *ptr;
1680
1681 width = lpgm->gmBlackBoxX;
1682 height = lpgm->gmBlackBoxY;
1683 pitch = (width + 3) / 4 * 4;
1684 needed = pitch * height;
1685
1686 if(!buf || !buflen) break;
1687 ft_bitmap.width = width;
1688 ft_bitmap.rows = height;
1689 ft_bitmap.pitch = pitch;
1690 ft_bitmap.pixel_mode = ft_pixel_mode_grays;
1691 ft_bitmap.buffer = buf;
1692
1693 if(font->orientation) {
1694 FT_Matrix matrix;
1695 matrix.xx = matrix.yy = pFT_Cos(angle);
1696 matrix.xy = -pFT_Sin(angle);
1697 matrix.yx = -matrix.xy;
1698 pFT_Outline_Transform(&ft_face->glyph->outline, &matrix);
1699 }
1700
1701 if (lpmat) pFT_Outline_Transform(&ft_face->glyph->outline, (FT_Matrix *)lpmat);
1702 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
1703
1704 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
1705
1706 if(format == GGO_GRAY2_BITMAP)
1707 mult = 5;
1708 else if(format == GGO_GRAY4_BITMAP)
1709 mult = 17;
1710 else if(format == GGO_GRAY8_BITMAP)
1711 mult = 65;
1712 else if(format == WINE_GGO_GRAY16_BITMAP)
1713 break;
1714 else {
1715 assert(0);
1716 break;
1717 }
1718
1719 start = buf;
1720 for(row = 0; row < height; row++) {
1721 ptr = start;
1722 for(col = 0; col < width; col++, ptr++) {
1723 *ptr = (*(unsigned int*)ptr * mult + 128) / 256;
1724 }
1725 start += pitch;
1726 }
1727 break;
1728 }
1729
1730 case GGO_NATIVE:
1731 {
1732 int contour, point = 0, first_pt;
1733 FT_Outline *outline = &ft_face->glyph->outline;
1734 TTPOLYGONHEADER *pph;
1735 TTPOLYCURVE *ppc;
1736 DWORD pph_start, cpfx, type;
1737
1738 if(buflen == 0) buf = NULL;
1739
1740 if (lpmat) pFT_Outline_Transform(outline, (FT_Matrix *)lpmat);
1741
1742 for(contour = 0; contour < outline->n_contours; contour++) {
1743 pph_start = needed;
1744 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
1745 first_pt = point;
1746 if(buf) {
1747 pph->dwType = TT_POLYGON_TYPE;
1748 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
1749 }
1750 needed += sizeof(*pph);
1751 point++;
1752 while(point <= outline->contours[contour]) {
1753 ppc = (TTPOLYCURVE *)((char *)buf + needed);
1754 type = (outline->tags[point] & FT_Curve_Tag_On) ?
1755 TT_PRIM_LINE : TT_PRIM_QSPLINE;
1756 cpfx = 0;
1757 do {
1758 if(buf)
1759 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
1760 cpfx++;
1761 point++;
1762 } while(point <= outline->contours[contour] &&
1763 (outline->tags[point] & FT_Curve_Tag_On) ==
1764 (outline->tags[point-1] & FT_Curve_Tag_On));
1765 /* At the end of a contour Windows adds the start point, but
1766 only for Beziers */
1767 if(point > outline->contours[contour] &&
1768 !(outline->tags[point-1] & FT_Curve_Tag_On)) {
1769 if(buf)
1770 FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
1771 cpfx++;
1772 } else if(point <= outline->contours[contour] &&
1773 outline->tags[point] & FT_Curve_Tag_On) {
1774 /* add closing pt for bezier */
1775 if(buf)
1776 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
1777 cpfx++;
1778 point++;
1779 }
1780 if(buf) {
1781 ppc->wType = type;
1782 ppc->cpfx = cpfx;
1783 }
1784 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
1785 }
1786 if(buf)
1787 pph->cb = needed - pph_start;
1788 }
1789 break;
1790 }
1791 case GGO_BEZIER:
1792 {
1793 /* Convert the quadratic Beziers to cubic Beziers.
1794 The parametric eqn for a cubic Bezier is, from PLRM:
1795 r(t) = at^3 + bt^2 + ct + r0
1796 with the control points:
1797 r1 = r0 + c/3
1798 r2 = r1 + (c + b)/3
1799 r3 = r0 + c + b + a
1800
1801 A quadratic Beizer has the form:
1802 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
1803
1804 So equating powers of t leads to:
1805 r1 = 2/3 p1 + 1/3 p0
1806 r2 = 2/3 p1 + 1/3 p2
1807 and of course r0 = p0, r3 = p2
1808 */
1809
1810 int contour, point = 0, first_pt;
1811 FT_Outline *outline = &ft_face->glyph->outline;
1812 TTPOLYGONHEADER *pph;
1813 TTPOLYCURVE *ppc;
1814 DWORD pph_start, cpfx, type;
1815 FT_Vector cubic_control[4];
1816 if(buflen == 0) buf = NULL;
1817
1818 if (lpmat) pFT_Outline_Transform(outline, (FT_Matrix *)lpmat);
1819
1820 for(contour = 0; contour < outline->n_contours; contour++) {
1821 pph_start = needed;
1822 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
1823 first_pt = point;
1824 if(buf) {
1825 pph->dwType = TT_POLYGON_TYPE;
1826 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
1827 }
1828 needed += sizeof(*pph);
1829 point++;
1830 while(point <= outline->contours[contour]) {
1831 ppc = (TTPOLYCURVE *)((char *)buf + needed);
1832 type = (outline->tags[point] & FT_Curve_Tag_On) ?
1833 TT_PRIM_LINE : TT_PRIM_CSPLINE;
1834 cpfx = 0;
1835 do {
1836 if(type == TT_PRIM_LINE) {
1837 if(buf)
1838 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
1839 cpfx++;
1840 point++;
1841 } else {
1842 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
1843 so cpfx = 3n */
1844
1845 /* FIXME: Possible optimization in endpoint calculation
1846 if there are two consecutive curves */
1847 cubic_control[0] = outline->points[point-1];
1848 if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
1849 cubic_control[0].x += outline->points[point].x + 1;
1850 cubic_control[0].y += outline->points[point].y + 1;
1851 cubic_control[0].x >>= 1;
1852 cubic_control[0].y >>= 1;
1853 }
1854 if(point+1 > outline->contours[contour])
1855 cubic_control[3] = outline->points[first_pt];
1856 else {
1857 cubic_control[3] = outline->points[point+1];
1858 if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
1859 cubic_control[3].x += outline->points[point].x + 1;
1860 cubic_control[3].y += outline->points[point].y + 1;
1861 cubic_control[3].x >>= 1;
1862 cubic_control[3].y >>= 1;
1863 }
1864 }
1865 /* r1 = 1/3 p0 + 2/3 p1
1866 r2 = 1/3 p2 + 2/3 p1 */
1867 cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
1868 cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
1869 cubic_control[2] = cubic_control[1];
1870 cubic_control[1].x += (cubic_control[0].x + 1) / 3;
1871 cubic_control[1].y += (cubic_control[0].y + 1) / 3;
1872 cubic_control[2].x += (cubic_control[3].x + 1) / 3;
1873 cubic_control[2].y += (cubic_control[3].y + 1) / 3;
1874 if(buf) {
1875 FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
1876 FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
1877 FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
1878 }
1879 cpfx += 3;
1880 point++;
1881 }
1882 } while(point <= outline->contours[contour] &&
1883 (outline->tags[point] & FT_Curve_Tag_On) ==
1884 (outline->tags[point-1] & FT_Curve_Tag_On));
1885 /* At the end of a contour Windows adds the start point,
1886 but only for Beziers and we've already done that.
1887 */
1888 if(point <= outline->contours[contour] &&
1889 outline->tags[point] & FT_Curve_Tag_On) {
1890 /* This is the closing pt of a bezier, but we've already
1891 added it, so just inc point and carry on */
1892 point++;
1893 }
1894 if(buf) {
1895 ppc->wType = type;
1896 ppc->cpfx = cpfx;
1897 }
1898 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
1899 }
1900 if(buf)
1901 pph->cb = needed - pph_start;
1902 }
1903 break;
1904 }
1905
1906 default:
1907 FIXME("Unsupported format %d\n", format);
1908 return GDI_ERROR;
1909 }
1910 return needed;
1911 }
1912
1913 /*************************************************************
1914 * WineEngGetTextMetrics
1915 *
1916 */
1917 BOOL WineEngGetTextMetrics(GdiFont font, LPTEXTMETRICW ptm)
1918 {
1919 if(!font->potm) {
1920 if(!WineEngGetOutlineTextMetrics(font, 0, NULL))
1921 return FALSE;
1922 }
1923 if(!font->potm) return FALSE;
1924 memcpy(ptm, &font->potm->otmTextMetrics, sizeof(*ptm));
1925 return TRUE;
1926 }
1927
1928
1929 /*************************************************************
1930 * WineEngGetOutlineTextMetrics
1931 *
1932 */
1933 UINT WineEngGetOutlineTextMetrics(GdiFont font, UINT cbSize,
1934 OUTLINETEXTMETRICW *potm)
1935 {
1936 FT_Face ft_face = font->ft_face;
1937 UINT needed, lenfam, lensty, ret;
1938 TT_OS2 *pOS2;
1939 TT_HoriHeader *pHori;
1940 TT_Postscript *pPost;
1941 FT_Fixed x_scale, y_scale;
1942 WCHAR *family_nameW, *style_nameW;
1943 WCHAR spaceW[] = {' ', '\0'};
1944 char *cp;
1945
1946 TRACE("font=%p\n", font);
1947
1948 if(font->potm) {
1949 if(cbSize >= font->potm->otmSize)
1950 memcpy(potm, font->potm, font->potm->otmSize);
1951 return font->potm->otmSize;
1952 }
1953
1954 needed = sizeof(*potm);
1955
1956 lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
1957 family_nameW = strdupW(font->name);
1958
1959 lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
1960 * sizeof(WCHAR);
1961 style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
1962 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
1963 style_nameW, lensty);
1964
1965 /* These names should be read from the TT name table */
1966
1967 /* length of otmpFamilyName */
1968 needed += lenfam;
1969
1970 /* length of otmpFaceName */
1971 if(!strcasecmp(ft_face->style_name, "regular")) {
1972 needed += lenfam; /* just the family name */
1973 } else {
1974 needed += lenfam + lensty; /* family + " " + style */
1975 }
1976
1977 /* length of otmpStyleName */
1978 needed += lensty;
1979
1980 /* length of otmpFullName */
1981 needed += lenfam + lensty;
1982
1983
1984 x_scale = ft_face->size->metrics.x_scale;
1985 y_scale = ft_face->size->metrics.y_scale;
1986
1987 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
1988 if(!pOS2) {
1989 FIXME("Can't find OS/2 table - not TT font?\n");
1990 ret = 0;
1991 goto end;
1992 }
1993
1994 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
1995 if(!pHori) {
1996 FIXME("Can't find HHEA table - not TT font?\n");
1997 ret = 0;
1998 goto end;
1999 }
2000
2001 pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
2002
2003 TRACE("OS/2 winA = %d winD = %d typoA = %d typoD = %d typoLG = %d FT_Face a = %d, d = %d, h = %d: HORZ a = %d, d = %d lg = %d maxY = %ld minY = %ld\n",
2004 pOS2->usWinAscent, pOS2->usWinDescent,
2005 pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
2006 ft_face->ascender, ft_face->descender, ft_face->height,
2007 pHori->Ascender, pHori->Descender, pHori->Line_Gap,
2008 ft_face->bbox.yMax, ft_face->bbox.yMin);
2009
2010 font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
2011 font->potm->otmSize = needed;
2012
2013 #define TM font->potm->otmTextMetrics
2014
2015 if(font->yMax) {
2016 TM.tmAscent = font->yMax;
2017 TM.tmDescent = -font->yMin;
2018 TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
2019 } else {
2020 TM.tmAscent = (pFT_MulFix(pOS2->usWinAscent, y_scale) + 32) >> 6;
2021 TM.tmDescent = (pFT_MulFix(pOS2->usWinDescent, y_scale) + 32) >> 6;
2022 TM.tmInternalLeading = (pFT_MulFix(pOS2->usWinAscent + pOS2->usWinDescent
2023 - ft_face->units_per_EM, y_scale) + 32) >> 6;
2024 }
2025
2026 TM.tmHeight = TM.tmAscent + TM.tmDescent;
2027
2028 /* MSDN says:
2029 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
2030 */
2031 TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
2032 ((pOS2->usWinAscent + pOS2->usWinDescent) -
2033 (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
2034
2035 TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
2036 TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
2037 TM.tmWeight = font->fake_bold ? FW_BOLD : pOS2->usWeightClass;
2038 TM.tmOverhang = 0;
2039 TM.tmDigitizedAspectX = 300;
2040 TM.tmDigitizedAspectY = 300;
2041 TM.tmFirstChar = pOS2->usFirstCharIndex;
2042 TM.tmLastChar = pOS2->usLastCharIndex;
2043 TM.tmDefaultChar = pOS2->usDefaultChar;
2044 TM.tmBreakChar = pOS2->usBreakChar ? pOS2->usBreakChar : ' ';
2045 TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
2046 TM.tmUnderlined = 0; /* entry in OS2 table */
2047 TM.tmStruckOut = 0; /* entry in OS2 table */
2048
2049 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
2050 if(!FT_IS_FIXED_WIDTH(ft_face))
2051 TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
2052 else
2053 TM.tmPitchAndFamily = 0;
2054
2055 switch(pOS2->panose[PAN_FAMILYTYPE_INDEX]) {
2056 case PAN_FAMILY_SCRIPT:
2057 TM.tmPitchAndFamily |= FF_SCRIPT;
2058 break;
2059 case PAN_FAMILY_DECORATIVE:
2060 case PAN_FAMILY_PICTORIAL:
2061 TM.tmPitchAndFamily |= FF_DECORATIVE;
2062 break;
2063 case PAN_FAMILY_TEXT_DISPLAY:
2064 if(TM.tmPitchAndFamily == 0) /* fixed */
2065 TM.tmPitchAndFamily = FF_MODERN;
2066 else {
2067 switch(pOS2->panose[PAN_SERIFSTYLE_INDEX]) {
2068 case PAN_SERIF_NORMAL_SANS:
2069 case PAN_SERIF_OBTUSE_SANS:
2070 case PAN_SERIF_PERP_SANS:
2071 TM.tmPitchAndFamily |= FF_SWISS;
2072 break;
2073 default:
2074 TM.tmPitchAndFamily |= FF_ROMAN;
2075 }
2076 }
2077 break;
2078 default:
2079 TM.tmPitchAndFamily |= FF_DONTCARE;
2080 }
2081
2082 if(FT_IS_SCALABLE(ft_face))
2083 TM.tmPitchAndFamily |= TMPF_VECTOR;
2084 if(FT_IS_SFNT(ft_face))
2085 TM.tmPitchAndFamily |= TMPF_TRUETYPE;
2086
2087 TM.tmCharSet = font->charset;
2088 #undef TM
2089
2090 font->potm->otmFiller = 0;
2091 memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
2092 font->potm->otmfsSelection = pOS2->fsSelection;
2093 font->potm->otmfsType = pOS2->fsType;
2094 font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
2095 font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
2096 font->potm->otmItalicAngle = 0; /* POST table */
2097 font->potm->otmEMSquare = ft_face->units_per_EM;
2098 font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
2099 font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
2100 font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
2101 font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
2102 font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
2103 font->potm->otmrcFontBox.left = ft_face->bbox.xMin;
2104 font->potm->otmrcFontBox.right = ft_face->bbox.xMax;
2105 font->potm->otmrcFontBox.top = ft_face->bbox.yMin;
2106 font->potm->otmrcFontBox.bottom = ft_face->bbox.yMax;
2107 font->potm->otmMacAscent = 0; /* where do these come from ? */
2108 font->potm->otmMacDescent = 0;
2109 font->potm->otmMacLineGap = 0;
2110 font->potm->otmusMinimumPPEM = 0; /* TT Header */
2111 font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
2112 font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
2113 font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
2114 font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
2115 font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
2116 font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
2117 font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
2118 font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
2119 font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
2120 font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
2121 if(!pPost) {
2122 font->potm->otmsUnderscoreSize = 0;
2123 font->potm->otmsUnderscorePosition = 0;
2124 } else {
2125 font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
2126 font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
2127 }
2128
2129 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
2130 cp = (char*)font->potm + sizeof(*font->potm);
2131 font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
2132 strcpyW((WCHAR*)cp, family_nameW);
2133 cp += lenfam;
2134 font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
2135 strcpyW((WCHAR*)cp, style_nameW);
2136 cp += lensty;
2137 font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
2138 strcpyW((WCHAR*)cp, family_nameW);
2139 if(strcasecmp(ft_face->style_name, "regular")) {
2140 strcatW((WCHAR*)cp, spaceW);
2141 strcatW((WCHAR*)cp, style_nameW);
2142 cp += lenfam + lensty;
2143 } else
2144 cp += lenfam;
2145 font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
2146 strcpyW((WCHAR*)cp, family_nameW);
2147 strcatW((WCHAR*)cp, spaceW);
2148 strcatW((WCHAR*)cp, style_nameW);
2149 ret = needed;
2150
2151 if(needed <= cbSize)
2152 memcpy(potm, font->potm, font->potm->otmSize);
2153
2154 end:
2155 HeapFree(GetProcessHeap(), 0, style_nameW);
2156 HeapFree(GetProcessHeap(), 0, family_nameW);
2157
2158 return ret;
2159 }
2160
2161
2162 /*************************************************************
2163 * WineEngGetCharWidth
2164 *
2165 */
2166 BOOL WineEngGetCharWidth(GdiFont font, UINT firstChar, UINT lastChar,
2167 LPINT buffer)
2168 {
2169 UINT c;
2170 GLYPHMETRICS gm;
2171 FT_UInt glyph_index;
2172
2173 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
2174
2175 for(c = firstChar; c <= lastChar; c++) {
2176 glyph_index = get_glyph_index(font, c);
2177 WineEngGetGlyphOutline(font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
2178 &gm, 0, NULL, NULL);
2179 buffer[c - firstChar] = font->gm[glyph_index].adv;
2180 }
2181 return TRUE;
2182 }
2183
2184 /*************************************************************
2185 * WineEngGetTextExtentPoint
2186 *
2187 */
2188 BOOL WineEngGetTextExtentPoint(GdiFont font, LPCWSTR wstr, INT count,
2189 LPSIZE size)
2190 {
2191 INT idx;
2192 GLYPHMETRICS gm;
2193 TEXTMETRICW tm;
2194 FT_UInt glyph_index;
2195
2196 TRACE("%p, %s, %d, %p\n", font, debugstr_wn(wstr, count), count,
2197 size);
2198
2199 size->cx = 0;
2200 WineEngGetTextMetrics(font, &tm);
2201 size->cy = tm.tmHeight;
2202
2203 for(idx = 0; idx < count; idx++) {
2204 glyph_index = get_glyph_index(font, wstr[idx]);
2205 WineEngGetGlyphOutline(font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
2206 &gm, 0, NULL, NULL);
2207 size->cx += font->gm[glyph_index].adv;
2208 }
2209 TRACE("return %ld,%ld\n", size->cx, size->cy);
2210 return TRUE;
2211 }
2212
2213 /*************************************************************
2214 * WineEngGetTextExtentPointI
2215 *
2216 */
2217 BOOL WineEngGetTextExtentPointI(GdiFont font, const WORD *indices, INT count,
2218 LPSIZE size)
2219 {
2220 INT idx;
2221 GLYPHMETRICS gm;
2222 TEXTMETRICW tm;
2223
2224 TRACE("%p, %p, %d, %p\n", font, indices, count, size);
2225
2226 size->cx = 0;
2227 WineEngGetTextMetrics(font, &tm);
2228 size->cy = tm.tmHeight;
2229
2230 for(idx = 0; idx < count; idx++) {
2231 WineEngGetGlyphOutline(font, indices[idx],
2232 GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL,
2233 NULL);
2234 size->cx += font->gm[indices[idx]].adv;
2235 }
2236 TRACE("return %ld,%ld\n", size->cx, size->cy);
2237 return TRUE;
2238 }
2239
2240 /*************************************************************
2241 * WineEngGetFontData
2242 *
2243 */
2244 DWORD WineEngGetFontData(GdiFont font, DWORD table, DWORD offset, LPVOID buf,
2245 DWORD cbData)
2246 {
2247 FT_Face ft_face = font->ft_face;
2248 DWORD len;
2249 FT_Error err;
2250
2251 TRACE("font=%p, table=%08lx, offset=%08lx, buf=%p, cbData=%lx\n",
2252 font, table, offset, buf, cbData);
2253
2254 if(!FT_IS_SFNT(ft_face))
2255 return GDI_ERROR;
2256
2257 if(!buf || !cbData)
2258 len = 0;
2259 else
2260 len = cbData;
2261
2262 if(table) { /* MS tags differ in endidness from FT ones */
2263 table = table >> 24 | table << 24 |
2264 (table >> 8 & 0xff00) | (table << 8 & 0xff0000);
2265 }
2266
2267 /* If the FT_Load_Sfnt_Table function is there we'll use it */
2268 if(pFT_Load_Sfnt_Table)
2269 err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, &len);
2270 else { /* Do it the hard way */
2271 TT_Face tt_face = (TT_Face) ft_face;
2272 SFNT_Interface *sfnt;
2273 if (FT_Version.major==2 && FT_Version.minor==0)
2274 {
2275 /* 2.0.x */
2276 sfnt = *(SFNT_Interface**)((char*)tt_face + 528);
2277 }
2278 else
2279 {
2280 /* A field was added in the middle of the structure in 2.1.x */
2281 sfnt = *(SFNT_Interface**)((char*)tt_face + 532);
2282 }
2283 err = sfnt->load_any(tt_face, table, offset, buf, &len);
2284 }
2285 if(err) {
2286 TRACE("Can't find table %08lx.\n", table);
2287 return GDI_ERROR;
2288 }
2289 return len;
2290 }
2291
2292 /*************************************************************
2293 * WineEngGetTextFace
2294 *
2295 */
2296 INT WineEngGetTextFace(GdiFont font, INT count, LPWSTR str)
2297 {
2298 if(str) {
2299 lstrcpynW(str, font->name, count);
2300 return strlenW(font->name);
2301 } else
2302 return strlenW(font->name) + 1;
2303 }
2304
2305 UINT WineEngGetTextCharsetInfo(GdiFont font, LPFONTSIGNATURE fs, DWORD flags)
2306 {
2307 if (fs) memcpy(fs, &font->fs, sizeof(FONTSIGNATURE));
2308 return font->charset;
2309 }
2310
2311 #else /* HAVE_FREETYPE */
2312
2313 BOOL WineEngInit(void)
2314 {
2315 return FALSE;
2316 }
2317 GdiFont WineEngCreateFontInstance(DC *dc, HFONT hfont)
2318 {
2319 return NULL;
2320 }
2321 BOOL WineEngDestroyFontInstance(HFONT hfont)
2322 {
2323 return FALSE;
2324 }
2325
2326 DWORD WineEngEnumFonts(LPLOGFONTW plf, DEVICEFONTENUMPROC proc, LPARAM lparam)
2327 {
2328 return 1;
2329 }
2330
2331 DWORD WineEngGetGlyphIndices(GdiFont font, LPCWSTR lpstr, INT count,
2332 LPWORD pgi, DWORD flags)
2333 {
2334 return GDI_ERROR;
2335 }
2336
2337 DWORD WineEngGetGlyphOutline(GdiFont font, UINT glyph, UINT format,
2338 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
2339 const MAT2* lpmat)
2340 {
2341 ERR("called but we don't have FreeType\n");
2342 return GDI_ERROR;
2343 }
2344
2345 BOOL WineEngGetTextMetrics(GdiFont font, LPTEXTMETRICW ptm)
2346 {
2347 ERR("called but we don't have FreeType\n");
2348 return FALSE;
2349 }
2350
2351 UINT WineEngGetOutlineTextMetrics(GdiFont font, UINT cbSize,
2352 OUTLINETEXTMETRICW *potm)
2353 {
2354 ERR("called but we don't have FreeType\n");
2355 return 0;
2356 }
2357
2358 BOOL WineEngGetCharWidth(GdiFont font, UINT firstChar, UINT lastChar,
2359 LPINT buffer)
2360 {
2361 ERR("called but we don't have FreeType\n");
2362 return FALSE;
2363 }
2364
2365 BOOL WineEngGetTextExtentPoint(GdiFont font, LPCWSTR wstr, INT count,
2366 LPSIZE size)
2367 {
2368 ERR("called but we don't have FreeType\n");
2369 return FALSE;
2370 }
2371
2372 BOOL WineEngGetTextExtentPointI(GdiFont font, const WORD *indices, INT count,
2373 LPSIZE size)
2374 {
2375 ERR("called but we don't have FreeType\n");
2376 return FALSE;
2377 }
2378
2379 DWORD WineEngGetFontData(GdiFont font, DWORD table, DWORD offset, LPVOID buf,
2380 DWORD cbData)
2381 {
2382 ERR("called but we don't have FreeType\n");
2383 return GDI_ERROR;
2384 }
2385
2386 INT WineEngGetTextFace(GdiFont font, INT count, LPWSTR str)
2387 {
2388 ERR("called but we don't have FreeType\n");
2389 return 0;
2390 }
2391
2392 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2393 {
2394 FIXME(":stub\n");
2395 return 1;
2396 }
2397
2398 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2399 {
2400 FIXME(":stub\n");
2401 return TRUE;
2402 }
2403
2404 UINT WineEngGetTextCharsetInfo(GdiFont font, LPFONTSIGNATURE fs, DWORD flags)
2405 {
2406 FIXME(":stub\n");
2407 return DEFAULT_CHARSET;
2408 }
2409
2410 #endif /* HAVE_FREETYPE */