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