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