?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 0.9.25.
[wine/dibdrv.git] / dlls / gdi32 / freetype.c
blobf7bc28f0b418220aabbf92f1360d11b12b7f2ed3
1 /*
2 * FreeType font engine interface
3 *
4 * Copyright 2001 Huw D M Davies for CodeWeavers.
5 * Copyright 2006 Dmitry Timoshkov for CodeWeavers.
6 *
7 * This file contains the WineEng* functions.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdarg.h>
28 #include <stdlib.h>
29 #ifdef HAVE_SYS_STAT_H
30 # include <sys/stat.h>
31 #endif
32 #include <string.h>
33 #include <dirent.h>
34 #include <stdio.h>
35 #include <assert.h>
36
37 #include "windef.h"
38 #include "winbase.h"
39 #include "winternl.h"
40 #include "winerror.h"
41 #include "winreg.h"
42 #include "wingdi.h"
43 #include "gdi.h"
44 #include "gdi_private.h"
45 #include "wine/unicode.h"
46 #include "wine/debug.h"
47 #include "wine/list.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(font);
50
51 #ifdef HAVE_FREETYPE
52
53 #ifdef HAVE_FT2BUILD_H
54 #include <ft2build.h>
55 #endif
56 #ifdef HAVE_FREETYPE_FREETYPE_H
57 #include <freetype/freetype.h>
58 #endif
59 #ifdef HAVE_FREETYPE_FTGLYPH_H
60 #include <freetype/ftglyph.h>
61 #endif
62 #ifdef HAVE_FREETYPE_TTTABLES_H
63 #include <freetype/tttables.h>
64 #endif
65 #ifdef HAVE_FREETYPE_FTSNAMES_H
66 #include <freetype/ftsnames.h>
67 #else
68 # ifdef HAVE_FREETYPE_FTNAMES_H
69 # include <freetype/ftnames.h>
70 # endif
71 #endif
72 #ifdef HAVE_FREETYPE_TTNAMEID_H
73 #include <freetype/ttnameid.h>
74 #endif
75 #ifdef HAVE_FREETYPE_FTOUTLN_H
76 #include <freetype/ftoutln.h>
77 #endif
78 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
79 #include <freetype/internal/sfnt.h>
80 #endif
81 #ifdef HAVE_FREETYPE_FTTRIGON_H
82 #include <freetype/fttrigon.h>
83 #endif
84 #ifdef HAVE_FREETYPE_FTWINFNT_H
85 #include <freetype/ftwinfnt.h>
86 #endif
87 #ifdef HAVE_FREETYPE_FTMODAPI_H
88 #include <freetype/ftmodapi.h>
89 #endif
90
91 #ifndef SONAME_LIBFREETYPE
92 #define SONAME_LIBFREETYPE "libfreetype.so"
93 #endif
94
95 #ifndef HAVE_FT_TRUETYPEENGINETYPE
96 typedef enum
97 {
98 FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
99 FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
100 FT_TRUETYPE_ENGINE_TYPE_PATENTED
101 } FT_TrueTypeEngineType;
102 #endif
103
104 static FT_Library library = 0;
105 typedef struct
106 {
107 FT_Int major;
108 FT_Int minor;
109 FT_Int patch;
110 } FT_Version_t;
111 static FT_Version_t FT_Version;
112 static DWORD FT_SimpleVersion;
113
114 static void *ft_handle = NULL;
115
116 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
117 MAKE_FUNCPTR(FT_Vector_Unit);
118 MAKE_FUNCPTR(FT_Done_Face);
119 MAKE_FUNCPTR(FT_Get_Char_Index);
120 MAKE_FUNCPTR(FT_Get_Module);
121 MAKE_FUNCPTR(FT_Get_Sfnt_Name);
122 MAKE_FUNCPTR(FT_Get_Sfnt_Name_Count);
123 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
124 MAKE_FUNCPTR(FT_Init_FreeType);
125 MAKE_FUNCPTR(FT_Load_Glyph);
126 MAKE_FUNCPTR(FT_Matrix_Multiply);
127 MAKE_FUNCPTR(FT_MulFix);
128 MAKE_FUNCPTR(FT_New_Face);
129 MAKE_FUNCPTR(FT_Outline_Get_Bitmap);
130 MAKE_FUNCPTR(FT_Outline_Transform);
131 MAKE_FUNCPTR(FT_Outline_Translate);
132 MAKE_FUNCPTR(FT_Select_Charmap);
133 MAKE_FUNCPTR(FT_Set_Pixel_Sizes);
134 MAKE_FUNCPTR(FT_Vector_Transform);
135 static void (*pFT_Library_Version)(FT_Library,FT_Int*,FT_Int*,FT_Int*);
136 static FT_Error (*pFT_Load_Sfnt_Table)(FT_Face,FT_ULong,FT_Long,FT_Byte*,FT_ULong*);
137 static FT_ULong (*pFT_Get_First_Char)(FT_Face,FT_UInt*);
138 static FT_ULong (*pFT_Get_Next_Char)(FT_Face,FT_ULong,FT_UInt*);
139 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type)(FT_Library);
140 #ifdef HAVE_FREETYPE_FTWINFNT_H
141 MAKE_FUNCPTR(FT_Get_WinFNT_Header);
142 #endif
143
144 #ifdef HAVE_FONTCONFIG_FONTCONFIG_H
145 #include <fontconfig/fontconfig.h>
146 MAKE_FUNCPTR(FcConfigGetCurrent);
147 MAKE_FUNCPTR(FcFontList);
148 MAKE_FUNCPTR(FcFontSetDestroy);
149 MAKE_FUNCPTR(FcInit);
150 MAKE_FUNCPTR(FcObjectSetAdd);
151 MAKE_FUNCPTR(FcObjectSetCreate);
152 MAKE_FUNCPTR(FcObjectSetDestroy);
153 MAKE_FUNCPTR(FcPatternCreate);
154 MAKE_FUNCPTR(FcPatternDestroy);
155 MAKE_FUNCPTR(FcPatternGetString);
156 #ifndef SONAME_LIBFONTCONFIG
157 #define SONAME_LIBFONTCONFIG "libfontconfig.so"
158 #endif
159 #endif
160
161 #undef MAKE_FUNCPTR
162
163 #ifndef ft_encoding_none
164 #define FT_ENCODING_NONE ft_encoding_none
165 #endif
166 #ifndef ft_encoding_ms_symbol
167 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
168 #endif
169 #ifndef ft_encoding_unicode
170 #define FT_ENCODING_UNICODE ft_encoding_unicode
171 #endif
172 #ifndef ft_encoding_apple_roman
173 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
174 #endif
175
176 #ifdef WORDS_BIGENDIAN
177 #define GET_BE_WORD(x) (x)
178 #else
179 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
180 #endif
181
182 /* This is bascially a copy of FT_Bitmap_Size with an extra element added */
183 typedef struct {
184 FT_Short height;
185 FT_Short width;
186 FT_Pos size;
187 FT_Pos x_ppem;
188 FT_Pos y_ppem;
189 FT_Short internal_leading;
190 } Bitmap_Size;
191
192 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
193 So to let this compile on older versions of FreeType we'll define the
194 new structure here. */
195 typedef struct {
196 FT_Short height, width;
197 FT_Pos size, x_ppem, y_ppem;
198 } My_FT_Bitmap_Size;
199
200 typedef struct tagFace {
201 struct list entry;
202 WCHAR *StyleName;
203 char *file;
204 FT_Long face_index;
205 BOOL Italic;
206 BOOL Bold;
207 FONTSIGNATURE fs;
208 FONTSIGNATURE fs_links;
209 FT_Fixed font_version;
210 BOOL scalable;
211 Bitmap_Size size; /* set if face is a bitmap */
212 BOOL external; /* TRUE if we should manually add this font to the registry */
213 struct tagFamily *family;
214 } Face;
215
216 typedef struct tagFamily {
217 struct list entry;
218 const WCHAR *FamilyName;
219 struct list faces;
220 } Family;
221
222 typedef struct {
223 GLYPHMETRICS gm;
224 INT adv; /* These three hold to widths of the unrotated chars */
225 INT lsb;
226 INT bbx;
227 BOOL init;
228 } GM;
229
230 typedef struct {
231 FLOAT eM11, eM12;
232 FLOAT eM21, eM22;
233 } FMAT2;
234
235 typedef struct {
236 DWORD hash;
237 LOGFONTW lf;
238 FMAT2 matrix;
239 BOOL can_use_bitmap;
240 } FONT_DESC;
241
242 typedef struct tagHFONTLIST {
243 struct list entry;
244 HFONT hfont;
245 } HFONTLIST;
246
247 typedef struct {
248 struct list entry;
249 char *file_name;
250 INT index;
251 GdiFont *font;
252 } CHILD_FONT;
253
254 struct tagGdiFont {
255 struct list entry;
256 FT_Face ft_face;
257 LPWSTR name;
258 int charset;
259 int codepage;
260 BOOL fake_italic;
261 BOOL fake_bold;
262 BYTE underline;
263 BYTE strikeout;
264 INT orientation;
265 GM *gm;
266 DWORD gmsize;
267 struct list hfontlist;
268 FONT_DESC font_desc;
269 LONG aveWidth;
270 SHORT yMax;
271 SHORT yMin;
272 OUTLINETEXTMETRICW *potm;
273 DWORD total_kern_pairs;
274 KERNINGPAIR *kern_pairs;
275 FONTSIGNATURE fs;
276 GdiFont *base_font;
277 struct list child_fonts;
278 LONG ppem;
279 };
280
281 typedef struct {
282 struct list entry;
283 const WCHAR *font_name;
284 struct list links;
285 } SYSTEM_LINKS;
286
287 #define INIT_GM_SIZE 128
288
289 static struct list gdi_font_list = LIST_INIT(gdi_font_list);
290 static struct list unused_gdi_font_list = LIST_INIT(unused_gdi_font_list);
291 #define UNUSED_CACHE_SIZE 10
292 static struct list child_font_list = LIST_INIT(child_font_list);
293 static struct list system_links = LIST_INIT(system_links);
294
295 static struct list font_subst_list = LIST_INIT(font_subst_list);
296
297 static struct list font_list = LIST_INIT(font_list);
298
299 static const WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ',
300 'R','o','m','a','n','\0'};
301 static const WCHAR defSans[] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
302 static const WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
303
304 static const WCHAR defSystem[] = {'S','y','s','t','e','m','\0'};
305 static const WCHAR SystemW[] = {'S','y','s','t','e','m','\0'};
306 static const WCHAR MSSansSerifW[] = {'M','S',' ','S','a','n','s',' ',
307 'S','e','r','i','f','\0'};
308 static const WCHAR HelvW[] = {'H','e','l','v','\0'};
309 static const WCHAR RegularW[] = {'R','e','g','u','l','a','r','\0'};
310
311 static const WCHAR fontsW[] = {'\\','F','o','n','t','s','\0'};
312 static const WCHAR win9x_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
313 'W','i','n','d','o','w','s','\\',
314 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
315 'F','o','n','t','s','\0'};
316
317 static const WCHAR winnt_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
318 'W','i','n','d','o','w','s',' ','N','T','\\',
319 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
320 'F','o','n','t','s','\0'};
321
322 static const WCHAR system_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
323 static const WCHAR FixedSys_Value[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
324 static const WCHAR System_Value[] = {'F','O','N','T','S','.','F','O','N','\0'};
325 static const WCHAR OEMFont_Value[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
326
327 static const WCHAR * const SystemFontValues[4] = {
328 System_Value,
329 OEMFont_Value,
330 FixedSys_Value,
331 NULL
332 };
333
334 static const WCHAR external_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
335 'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
336
337 static const WCHAR ArabicW[] = {'A','r','a','b','i','c','\0'};
338 static const WCHAR BalticW[] = {'B','a','l','t','i','c','\0'};
339 static const WCHAR CHINESE_BIG5W[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
340 static const WCHAR CHINESE_GB2312W[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
341 static const WCHAR Central_EuropeanW[] = {'C','e','n','t','r','a','l',' ',
342 'E','u','r','o','p','e','a','n','\0'};
343 static const WCHAR CyrillicW[] = {'C','y','r','i','l','l','i','c','\0'};
344 static const WCHAR GreekW[] = {'G','r','e','e','k','\0'};
345 static const WCHAR HangulW[] = {'H','a','n','g','u','l','\0'};
346 static const WCHAR Hangul_Johab_W[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
347 static const WCHAR HebrewW[] = {'H','e','b','r','e','w','\0'};
348 static const WCHAR JapaneseW[] = {'J','a','p','a','n','e','s','e','\0'};
349 static const WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
350 static const WCHAR ThaiW[] = {'T','h','a','i','\0'};
351 static const WCHAR TurkishW[] = {'T','u','r','k','i','s','h','\0'};
352 static const WCHAR VietnameseW[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
353 static const WCHAR WesternW[] = {'W','e','s','t','e','r','n','\0'};
354 static const WCHAR OEM_DOSW[] = {'O','E','M','/','D','O','S','\0'};
355
356 static const WCHAR * const ElfScriptsW[32] = { /* these are in the order of the fsCsb[0] bits */
357 WesternW, /*00*/
358 Central_EuropeanW,
359 CyrillicW,
360 GreekW,
361 TurkishW,
362 HebrewW,
363 ArabicW,
364 BalticW,
365 VietnameseW, /*08*/
366 NULL, NULL, NULL, NULL, NULL, NULL, NULL, /*15*/
367 ThaiW,
368 JapaneseW,
369 CHINESE_GB2312W,
370 HangulW,
371 CHINESE_BIG5W,
372 Hangul_Johab_W,
373 NULL, NULL, /*23*/
374 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
375 SymbolW /*31*/
376 };
377
378 typedef struct {
379 WCHAR *name;
380 INT charset;
381 } NameCs;
382
383 typedef struct tagFontSubst {
384 struct list entry;
385 NameCs from;
386 NameCs to;
387 } FontSubst;
388
389 static BOOL have_installed_roman_font = FALSE; /* CreateFontInstance will fail if this is still FALSE */
390
391 static const WCHAR font_mutex_nameW[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
392
393
394 /****************************************
395 * Notes on .fon files
396 *
397 * The fonts System, FixedSys and Terminal are special. There are typically multiple
398 * versions installed for different resolutions and codepages. Windows stores which one to use
399 * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
400 * Key Meaning
401 * FIXEDFON.FON FixedSys
402 * FONTS.FON System
403 * OEMFONT.FON Terminal
404 * LogPixels Current dpi set by the display control panel applet
405 * (HKLM\\Software\\Microsft\\Windows NT\\CurrentVersion\\FontDPI
406 * also has a LogPixels value that appears to mirror this)
407 *
408 * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
409 * (vgaoem.fon would be your oemfont.fon if you have a US setup).
410 * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
411 * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
412 * so that makes sense.
413 *
414 * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
415 * to be mapped into the registry on Windows 2000 at least).
416 * I have
417 * woafont=app850.fon
418 * ega80woa.fon=ega80850.fon
419 * ega40woa.fon=ega40850.fon
420 * cga80woa.fon=cga80850.fon
421 * cga40woa.fon=cga40850.fon
422 */
423
424
425 static inline BOOL is_win9x(void)
426 {
427 return GetVersion() & 0x80000000;
428 }
429 /*
430 This function builds an FT_Fixed from a float. It puts the integer part
431 in the highest 16 bits and the decimal part in the lowest 16 bits of the FT_Fixed.
432 It fails if the integer part of the float number is greater than SHORT_MAX.
433 */
434 static inline FT_Fixed FT_FixedFromFloat(float f)
435 {
436 short value = f;
437 unsigned short fract = (f - value) * 0xFFFF;
438 return (FT_Fixed)((long)value << 16 | (unsigned long)fract);
439 }
440
441 /*
442 This function builds an FT_Fixed from a FIXED. It simply put f.value
443 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
444 */
445 static inline FT_Fixed FT_FixedFromFIXED(FIXED f)
446 {
447 return (FT_Fixed)((long)f.value << 16 | (unsigned long)f.fract);
448 }
449
450
451 static Face *find_face_from_filename(const WCHAR *file_name, const WCHAR *face_name)
452 {
453 Family *family;
454 Face *face;
455 const char *file;
456 DWORD len = WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, NULL, 0, NULL, NULL);
457 char *file_nameA = HeapAlloc(GetProcessHeap(), 0, len);
458
459 WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, file_nameA, len, NULL, NULL);
460 TRACE("looking for file %s name %s\n", debugstr_a(file_nameA), debugstr_w(face_name));
461
462 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
463 {
464 if(face_name && strcmpiW(face_name, family->FamilyName))
465 continue;
466 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
467 {
468 file = strrchr(face->file, '/');
469 if(!file)
470 file = face->file;
471 else
472 file++;
473 if(!strcasecmp(file, file_nameA))
474 {
475 HeapFree(GetProcessHeap(), 0, file_nameA);
476 return face;
477 }
478 }
479 }
480 HeapFree(GetProcessHeap(), 0, file_nameA);
481 return NULL;
482 }
483
484 static Family *find_family_from_name(const WCHAR *name)
485 {
486 Family *family;
487
488 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
489 {
490 if(!strcmpiW(family->FamilyName, name))
491 return family;
492 }
493
494 return NULL;
495 }
496
497 static void DumpSubstList(void)
498 {
499 FontSubst *psub;
500
501 LIST_FOR_EACH_ENTRY(psub, &font_subst_list, FontSubst, entry)
502 {
503 if(psub->from.charset != -1 || psub->to.charset != -1)
504 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
505 psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
506 else
507 TRACE("%s -> %s\n", debugstr_w(psub->from.name),
508 debugstr_w(psub->to.name));
509 }
510 return;
511 }
512
513 static LPWSTR strdupW(LPCWSTR p)
514 {
515 LPWSTR ret;
516 DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
517 ret = HeapAlloc(GetProcessHeap(), 0, len);
518 memcpy(ret, p, len);
519 return ret;
520 }
521
522 static LPSTR strdupA(LPCSTR p)
523 {
524 LPSTR ret;
525 DWORD len = (strlen(p) + 1);
526 ret = HeapAlloc(GetProcessHeap(), 0, len);
527 memcpy(ret, p, len);
528 return ret;
529 }
530
531 static FontSubst *get_font_subst(const struct list *subst_list, const WCHAR *from_name,
532 INT from_charset)
533 {
534 FontSubst *element;
535
536 LIST_FOR_EACH_ENTRY(element, subst_list, FontSubst, entry)
537 {
538 if(!strcmpiW(element->from.name, from_name) &&
539 (element->from.charset == from_charset ||
540 element->from.charset == -1))
541 return element;
542 }
543
544 return NULL;
545 }
546
547 #define ADD_FONT_SUBST_FORCE 1
548
549 static BOOL add_font_subst(struct list *subst_list, FontSubst *subst, INT flags)
550 {
551 FontSubst *from_exist, *to_exist;
552
553 from_exist = get_font_subst(subst_list, subst->from.name, subst->from.charset);
554
555 if(from_exist && (flags & ADD_FONT_SUBST_FORCE))
556 {
557 list_remove(&from_exist->entry);
558 HeapFree(GetProcessHeap(), 0, &from_exist->from.name);
559 HeapFree(GetProcessHeap(), 0, &from_exist->to.name);
560 HeapFree(GetProcessHeap(), 0, from_exist);
561 from_exist = NULL;
562 }
563
564 if(!from_exist)
565 {
566 to_exist = get_font_subst(subst_list, subst->to.name, subst->to.charset);
567
568 if(to_exist)
569 {
570 HeapFree(GetProcessHeap(), 0, subst->to.name);
571 subst->to.name = strdupW(to_exist->to.name);
572 }
573
574 list_add_tail(subst_list, &subst->entry);
575
576 return TRUE;
577 }
578
579 HeapFree(GetProcessHeap(), 0, subst->from.name);
580 HeapFree(GetProcessHeap(), 0, subst->to.name);
581 HeapFree(GetProcessHeap(), 0, subst);
582 return FALSE;
583 }
584
585 static void split_subst_info(NameCs *nc, LPSTR str)
586 {
587 CHAR *p = strrchr(str, ',');
588 DWORD len;
589
590 nc->charset = -1;
591 if(p && *(p+1)) {
592 nc->charset = strtol(p+1, NULL, 10);
593 *p = '\0';
594 }
595 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
596 nc->name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
597 MultiByteToWideChar(CP_ACP, 0, str, -1, nc->name, len);
598 }
599
600 static void LoadSubstList(void)
601 {
602 FontSubst *psub;
603 HKEY hkey;
604 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
605 LPSTR value;
606 LPVOID data;
607
608 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
609 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
610 &hkey) == ERROR_SUCCESS) {
611
612 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
613 &valuelen, &datalen, NULL, NULL);
614
615 valuelen++; /* returned value doesn't include room for '\0' */
616 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
617 data = HeapAlloc(GetProcessHeap(), 0, datalen);
618
619 dlen = datalen;
620 vlen = valuelen;
621 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
622 &dlen) == ERROR_SUCCESS) {
623 TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
624
625 psub = HeapAlloc(GetProcessHeap(), 0, sizeof(*psub));
626 split_subst_info(&psub->from, value);
627 split_subst_info(&psub->to, data);
628
629 /* Win 2000 doesn't allow mapping between different charsets
630 or mapping of DEFAULT_CHARSET */
631 if((psub->to.charset != psub->from.charset) ||
632 psub->to.charset == DEFAULT_CHARSET) {
633 HeapFree(GetProcessHeap(), 0, psub->to.name);
634 HeapFree(GetProcessHeap(), 0, psub->from.name);
635 HeapFree(GetProcessHeap(), 0, psub);
636 } else {
637 add_font_subst(&font_subst_list, psub, 0);
638 }
639 /* reset dlen and vlen */
640 dlen = datalen;
641 vlen = valuelen;
642 }
643 HeapFree(GetProcessHeap(), 0, data);
644 HeapFree(GetProcessHeap(), 0, value);
645 RegCloseKey(hkey);
646 }
647 }
648
649 static WCHAR *get_familyname(FT_Face ft_face)
650 {
651 WCHAR *family = NULL;
652 FT_SfntName name;
653 FT_UInt num_names, name_index, i;
654
655 if(FT_IS_SFNT(ft_face))
656 {
657 num_names = pFT_Get_Sfnt_Name_Count(ft_face);
658
659 for(name_index = 0; name_index < num_names; name_index++)
660 {
661 if(!pFT_Get_Sfnt_Name(ft_face, name_index, &name))
662 {
663 if((name.name_id == TT_NAME_ID_FONT_FAMILY) &&
664 (name.language_id == GetUserDefaultLCID()) &&
665 (name.platform_id == TT_PLATFORM_MICROSOFT) &&
666 (name.encoding_id == TT_MS_ID_UNICODE_CS))
667 {
668 /* String is not nul terminated and string_len is a byte length. */
669 family = HeapAlloc(GetProcessHeap(), 0, name.string_len + 2);
670 for(i = 0; i < name.string_len / 2; i++)
671 {
672 WORD *tmp = (WORD *)&name.string[i * 2];
673 family[i] = GET_BE_WORD(*tmp);
674 }
675 family[i] = 0;
676
677 TRACE("Got localised name %s\n", debugstr_w(family));
678 return family;
679 }
680 }
681 }
682 }
683
684 return NULL;
685 }
686
687
688 #define ADDFONT_EXTERNAL_FONT 0x01
689 #define ADDFONT_FORCE_BITMAP 0x02
690 static BOOL AddFontFileToList(const char *file, char *fake_family, DWORD flags)
691 {
692 FT_Face ft_face;
693 TT_OS2 *pOS2;
694 TT_Header *pHeader = NULL;
695 WCHAR *english_family, *localised_family, *StyleW;
696 DWORD len;
697 Family *family;
698 Face *face;
699 struct list *family_elem_ptr, *face_elem_ptr;
700 FT_Error err;
701 FT_Long face_index = 0, num_faces;
702 #ifdef HAVE_FREETYPE_FTWINFNT_H
703 FT_WinFNT_HeaderRec winfnt_header;
704 #endif
705 int i, bitmap_num, internal_leading;
706 FONTSIGNATURE fs;
707
708 do {
709 char *family_name = fake_family;
710
711 TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
712 if((err = pFT_New_Face(library, file, face_index, &ft_face)) != 0) {
713 WARN("Unable to load font file %s err = %x\n", debugstr_a(file), err);
714 return FALSE;
715 }
716
717 if(!FT_IS_SFNT(ft_face) && (FT_IS_SCALABLE(ft_face) || !(flags & ADDFONT_FORCE_BITMAP))) { /* for now we'll accept TT/OT or bitmap fonts*/
718 WARN("Ignoring font %s\n", debugstr_a(file));
719 pFT_Done_Face(ft_face);
720 return FALSE;
721 }
722
723 /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
724 if(!FT_IS_SCALABLE(ft_face) && FT_SimpleVersion < ((2 << 16) | (1 << 8) | (9 << 0))) {
725 WARN("FreeType version < 2.1.9, skipping bitmap font %s\n", debugstr_a(file));
726 pFT_Done_Face(ft_face);
727 return FALSE;
728 }
729
730 if(FT_IS_SFNT(ft_face) && (!pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2) ||
731 !pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea) ||
732 !(pHeader = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_head)))) {
733 TRACE("Font file %s lacks either an OS2, HHEA or HEAD table.\n"
734 "Skipping this font.\n", debugstr_a(file));
735 pFT_Done_Face(ft_face);
736 return FALSE;
737 }
738
739 if(!ft_face->family_name || !ft_face->style_name) {
740 TRACE("Font file %s lacks either a family or style name\n", debugstr_a(file));
741 pFT_Done_Face(ft_face);
742 return FALSE;
743 }
744
745 if(!family_name)
746 family_name = ft_face->family_name;
747
748 bitmap_num = 0;
749 do {
750 My_FT_Bitmap_Size *size = NULL;
751
752 if(!FT_IS_SCALABLE(ft_face))
753 size = (My_FT_Bitmap_Size *)ft_face->available_sizes + bitmap_num;
754
755 len = MultiByteToWideChar(CP_ACP, 0, family_name, -1, NULL, 0);
756 english_family = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
757 MultiByteToWideChar(CP_ACP, 0, family_name, -1, english_family, len);
758
759 localised_family = NULL;
760 if(!fake_family) {
761 localised_family = get_familyname(ft_face);
762 if(localised_family && !strcmpW(localised_family, english_family)) {
763 HeapFree(GetProcessHeap(), 0, localised_family);
764 localised_family = NULL;
765 }
766 }
767
768 family = NULL;
769 LIST_FOR_EACH(family_elem_ptr, &font_list) {
770 family = LIST_ENTRY(family_elem_ptr, Family, entry);
771 if(!strcmpW(family->FamilyName, localised_family ? localised_family : english_family))
772 break;
773 family = NULL;
774 }
775 if(!family) {
776 family = HeapAlloc(GetProcessHeap(), 0, sizeof(*family));
777 family->FamilyName = strdupW(localised_family ? localised_family : english_family);
778 list_init(&family->faces);
779 list_add_tail(&font_list, &family->entry);
780
781 if(localised_family) {
782 FontSubst *subst = HeapAlloc(GetProcessHeap(), 0, sizeof(*subst));
783 subst->from.name = strdupW(english_family);
784 subst->from.charset = -1;
785 subst->to.name = strdupW(localised_family);
786 subst->to.charset = -1;
787 add_font_subst(&font_subst_list, subst, 0);
788 }
789 }
790 HeapFree(GetProcessHeap(), 0, localised_family);
791 HeapFree(GetProcessHeap(), 0, english_family);
792
793 len = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0);
794 StyleW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
795 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, StyleW, len);
796
797 internal_leading = 0;
798 memset(&fs, 0, sizeof(fs));
799
800 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
801 if(pOS2) {
802 fs.fsCsb[0] = pOS2->ulCodePageRange1;
803 fs.fsCsb[1] = pOS2->ulCodePageRange2;
804 fs.fsUsb[0] = pOS2->ulUnicodeRange1;
805 fs.fsUsb[1] = pOS2->ulUnicodeRange2;
806 fs.fsUsb[2] = pOS2->ulUnicodeRange3;
807 fs.fsUsb[3] = pOS2->ulUnicodeRange4;
808 if(pOS2->version == 0) {
809 FT_UInt dummy;
810
811 if(!pFT_Get_First_Char || (pFT_Get_First_Char( ft_face, &dummy ) < 0x100))
812 fs.fsCsb[0] |= 1;
813 else
814 fs.fsCsb[0] |= 1L << 31;
815 }
816 }
817 #ifdef HAVE_FREETYPE_FTWINFNT_H
818 else if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header)) {
819 CHARSETINFO csi;
820 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header.pixel_height, winfnt_header.charset,
821 winfnt_header.vertical_resolution,winfnt_header.horizontal_resolution, winfnt_header.nominal_point_size);
822 if(TranslateCharsetInfo((DWORD*)(UINT_PTR)winfnt_header.charset, &csi, TCI_SRCCHARSET))
823 memcpy(&fs, &csi.fs, sizeof(csi.fs));
824 internal_leading = winfnt_header.internal_leading;
825 }
826 #endif
827
828 face_elem_ptr = list_head(&family->faces);
829 while(face_elem_ptr) {
830 face = LIST_ENTRY(face_elem_ptr, Face, entry);
831 face_elem_ptr = list_next(&family->faces, face_elem_ptr);
832 if(!strcmpW(face->StyleName, StyleW) &&
833 (FT_IS_SCALABLE(ft_face) || ((size->y_ppem == face->size.y_ppem) && !memcmp(&fs, &face->fs, sizeof(fs)) ))) {
834 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
835 debugstr_w(family->FamilyName), debugstr_w(StyleW),
836 face->font_version, pHeader ? pHeader->Font_Revision : 0);
837
838 if(fake_family) {
839 TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
840 HeapFree(GetProcessHeap(), 0, StyleW);
841 pFT_Done_Face(ft_face);
842 return FALSE;
843 }
844 if(!pHeader || pHeader->Font_Revision <= face->font_version) {
845 TRACE("Original font is newer so skipping this one\n");
846 HeapFree(GetProcessHeap(), 0, StyleW);
847 pFT_Done_Face(ft_face);
848 return FALSE;
849 } else {
850 TRACE("Replacing original with this one\n");
851 list_remove(&face->entry);
852 HeapFree(GetProcessHeap(), 0, face->file);
853 HeapFree(GetProcessHeap(), 0, face->StyleName);
854 HeapFree(GetProcessHeap(), 0, face);
855 break;
856 }
857 }
858 }
859 face = HeapAlloc(GetProcessHeap(), 0, sizeof(*face));
860 list_add_tail(&family->faces, &face->entry);
861 face->StyleName = StyleW;
862 face->file = HeapAlloc(GetProcessHeap(),0,strlen(file)+1);
863 strcpy(face->file, file);
864 face->face_index = face_index;
865 face->Italic = (ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 1 : 0;
866 face->Bold = (ft_face->style_flags & FT_STYLE_FLAG_BOLD) ? 1 : 0;
867 face->font_version = pHeader ? pHeader->Font_Revision : 0;
868 face->family = family;
869 face->external = (flags & ADDFONT_EXTERNAL_FONT) ? TRUE : FALSE;
870 memcpy(&face->fs, &fs, sizeof(face->fs));
871 memset(&face->fs_links, 0, sizeof(face->fs_links));
872
873 if(FT_IS_SCALABLE(ft_face)) {
874 memset(&face->size, 0, sizeof(face->size));
875 face->scalable = TRUE;
876 } else {
877 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
878 size->height, size->width, size->size >> 6,
879 size->x_ppem >> 6, size->y_ppem >> 6);
880 face->size.height = size->height;
881 face->size.width = size->width;
882 face->size.size = size->size;
883 face->size.x_ppem = size->x_ppem;
884 face->size.y_ppem = size->y_ppem;
885 face->size.internal_leading = internal_leading;
886 face->scalable = FALSE;
887 }
888
889 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
890 face->fs.fsCsb[0], face->fs.fsCsb[1],
891 face->fs.fsUsb[0], face->fs.fsUsb[1],
892 face->fs.fsUsb[2], face->fs.fsUsb[3]);
893
894
895 if(face->fs.fsCsb[0] == 0) { /* let's see if we can find any interesting cmaps */
896 for(i = 0; i < ft_face->num_charmaps; i++) {
897 switch(ft_face->charmaps[i]->encoding) {
898 case FT_ENCODING_UNICODE:
899 case FT_ENCODING_APPLE_ROMAN:
900 face->fs.fsCsb[0] |= 1;
901 break;
902 case FT_ENCODING_MS_SYMBOL:
903 face->fs.fsCsb[0] |= 1L << 31;
904 break;
905 default:
906 break;
907 }
908 }
909 }
910
911 if(face->fs.fsCsb[0] & ~(1L << 31))
912 have_installed_roman_font = TRUE;
913 } while(!FT_IS_SCALABLE(ft_face) && ++bitmap_num < ft_face->num_fixed_sizes);
914
915 num_faces = ft_face->num_faces;
916 pFT_Done_Face(ft_face);
917 TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
918 debugstr_w(StyleW));
919 } while(num_faces > ++face_index);
920 return TRUE;
921 }
922
923 static void DumpFontList(void)
924 {
925 Family *family;
926 Face *face;
927 struct list *family_elem_ptr, *face_elem_ptr;
928
929 LIST_FOR_EACH(family_elem_ptr, &font_list) {
930 family = LIST_ENTRY(family_elem_ptr, Family, entry);
931 TRACE("Family: %s\n", debugstr_w(family->FamilyName));
932 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
933 face = LIST_ENTRY(face_elem_ptr, Face, entry);
934 TRACE("\t%s\t%08x", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
935 if(!face->scalable)
936 TRACE(" %d", face->size.height);
937 TRACE("\n");
938 }
939 }
940 return;
941 }
942
943 /***********************************************************
944 * The replacement list is a way to map an entire font
945 * family onto another family. For example adding
946 *
947 * [HKCU\Software\Wine\Fonts\Replacements]
948 * "Wingdings"="Winedings"
949 *
950 * would enumerate the Winedings font both as Winedings and
951 * Wingdings. However if a real Wingdings font is present the
952 * replacement does not take place.
953 *
954 */
955 static void LoadReplaceList(void)
956 {
957 HKEY hkey;
958 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
959 LPSTR value;
960 LPVOID data;
961 Family *family;
962 Face *face;
963 struct list *family_elem_ptr, *face_elem_ptr;
964 WCHAR old_nameW[200];
965
966 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
967 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
968 {
969 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
970 &valuelen, &datalen, NULL, NULL);
971
972 valuelen++; /* returned value doesn't include room for '\0' */
973 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
974 data = HeapAlloc(GetProcessHeap(), 0, datalen);
975
976 dlen = datalen;
977 vlen = valuelen;
978 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
979 &dlen) == ERROR_SUCCESS) {
980 TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
981 /* "NewName"="Oldname" */
982 if(!MultiByteToWideChar(CP_ACP, 0, data, -1, old_nameW, sizeof(old_nameW)/sizeof(WCHAR)))
983 break;
984
985 /* Find the old family and hence all of the font files
986 in that family */
987 LIST_FOR_EACH(family_elem_ptr, &font_list) {
988 family = LIST_ENTRY(family_elem_ptr, Family, entry);
989 if(!strcmpiW(family->FamilyName, old_nameW)) {
990 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
991 face = LIST_ENTRY(face_elem_ptr, Face, entry);
992 TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
993 debugstr_w(face->StyleName), value);
994 /* Now add a new entry with the new family name */
995 AddFontFileToList(face->file, value, ADDFONT_FORCE_BITMAP | (face->external ? ADDFONT_EXTERNAL_FONT : 0));
996 }
997 break;
998 }
999 }
1000 /* reset dlen and vlen */
1001 dlen = datalen;
1002 vlen = valuelen;
1003 }
1004 HeapFree(GetProcessHeap(), 0, data);
1005 HeapFree(GetProcessHeap(), 0, value);
1006 RegCloseKey(hkey);
1007 }
1008 }
1009
1010 /*************************************************************
1011 * init_system_links
1012 */
1013 static BOOL init_system_links(void)
1014 {
1015 static const WCHAR system_link[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1016 'W','i','n','d','o','w','s',' ','N','T','\\',
1017 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
1018 'S','y','s','t','e','m','L','i','n','k',0};
1019 HKEY hkey;
1020 BOOL ret = FALSE;
1021 DWORD type, max_val, max_data, val_len, data_len, index;
1022 WCHAR *value, *data;
1023 WCHAR *entry, *next;
1024 SYSTEM_LINKS *font_link, *system_font_link;
1025 CHILD_FONT *child_font;
1026 static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
1027 static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
1028 static const WCHAR System[] = {'S','y','s','t','e','m',0};
1029 FONTSIGNATURE fs;
1030 Family *family;
1031 Face *face;
1032 FontSubst *psub;
1033
1034 if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
1035 {
1036 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
1037 value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
1038 data = HeapAlloc(GetProcessHeap(), 0, max_data);
1039 val_len = max_val + 1;
1040 data_len = max_data;
1041 index = 0;
1042 while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
1043 {
1044 TRACE("%s:\n", debugstr_w(value));
1045
1046 memset(&fs, 0, sizeof(fs));
1047 font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
1048 psub = get_font_subst(&font_subst_list, value, -1);
1049 font_link->font_name = (psub)? strdupW(psub->to.name) : strdupW(value);
1050 list_init(&font_link->links);
1051 for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
1052 {
1053 WCHAR *face_name;
1054 CHILD_FONT *child_font;
1055
1056 TRACE("\t%s\n", debugstr_w(entry));
1057
1058 next = entry + strlenW(entry) + 1;
1059
1060 face_name = strchrW(entry, ',');
1061 if(face_name)
1062 {
1063 *face_name++ = 0;
1064 while(isspaceW(*face_name))
1065 face_name++;
1066
1067 psub = get_font_subst(&font_subst_list, face_name, -1);
1068 if(psub)
1069 face_name = psub->to.name;
1070 }
1071 face = find_face_from_filename(entry, face_name);
1072 if(!face)
1073 {
1074 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
1075 continue;
1076 }
1077
1078 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1079 child_font->file_name = strdupA(face->file);
1080 child_font->index = face->face_index;
1081 child_font->font = NULL;
1082 fs.fsCsb[0] |= face->fs.fsCsb[0];
1083 fs.fsCsb[1] |= face->fs.fsCsb[1];
1084 TRACE("Adding file %s index %d\n", child_font->file_name, child_font->index);
1085 list_add_tail(&font_link->links, &child_font->entry);
1086 }
1087 family = find_family_from_name(font_link->font_name);
1088 if(family)
1089 {
1090 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
1091 {
1092 memcpy(&face->fs_links, &fs, sizeof(fs));
1093 }
1094 }
1095 list_add_tail(&system_links, &font_link->entry);
1096 val_len = max_val + 1;
1097 data_len = max_data;
1098 }
1099
1100 HeapFree(GetProcessHeap(), 0, value);
1101 HeapFree(GetProcessHeap(), 0, data);
1102 RegCloseKey(hkey);
1103 }
1104
1105 /* Explicitly add an entry for the system font, this links to Tahoma and any links
1106 that Tahoma has */
1107
1108 system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
1109 system_font_link->font_name = strdupW(System);
1110 list_init(&system_font_link->links);
1111
1112 face = find_face_from_filename(tahoma_ttf, Tahoma);
1113 if(face)
1114 {
1115 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1116 child_font->file_name = strdupA(face->file);
1117 child_font->index = face->face_index;
1118 child_font->font = NULL;
1119 TRACE("Found Tahoma in %s index %d\n", child_font->file_name, child_font->index);
1120 list_add_tail(&system_font_link->links, &child_font->entry);
1121 }
1122 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
1123 {
1124 if(!strcmpiW(font_link->font_name, Tahoma))
1125 {
1126 CHILD_FONT *font_link_entry;
1127 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
1128 {
1129 CHILD_FONT *new_child;
1130 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
1131 new_child->file_name = strdupA(font_link_entry->file_name);
1132 new_child->index = font_link_entry->index;
1133 new_child->font = NULL;
1134 list_add_tail(&system_font_link->links, &new_child->entry);
1135 }
1136 break;
1137 }
1138 }
1139 list_add_tail(&system_links, &system_font_link->entry);
1140 return ret;
1141 }
1142
1143 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
1144 {
1145 DIR *dir;
1146 struct dirent *dent;
1147 char path[MAX_PATH];
1148
1149 TRACE("Loading fonts from %s\n", debugstr_a(dirname));
1150
1151 dir = opendir(dirname);
1152 if(!dir) {
1153 WARN("Can't open directory %s\n", debugstr_a(dirname));
1154 return FALSE;
1155 }
1156 while((dent = readdir(dir)) != NULL) {
1157 struct stat statbuf;
1158
1159 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
1160 continue;
1161
1162 TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
1163
1164 sprintf(path, "%s/%s", dirname, dent->d_name);
1165
1166 if(stat(path, &statbuf) == -1)
1167 {
1168 WARN("Can't stat %s\n", debugstr_a(path));
1169 continue;
1170 }
1171 if(S_ISDIR(statbuf.st_mode))
1172 ReadFontDir(path, external_fonts);
1173 else
1174 AddFontFileToList(path, NULL, external_fonts ? ADDFONT_EXTERNAL_FONT : 0);
1175 }
1176 closedir(dir);
1177 return TRUE;
1178 }
1179
1180 static void load_fontconfig_fonts(void)
1181 {
1182 #ifdef HAVE_FONTCONFIG_FONTCONFIG_H
1183 void *fc_handle = NULL;
1184 FcConfig *config;
1185 FcPattern *pat;
1186 FcObjectSet *os;
1187 FcFontSet *fontset;
1188 int i, len;
1189 char *file;
1190 const char *ext;
1191
1192 fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
1193 if(!fc_handle) {
1194 TRACE("Wine cannot find the fontconfig library (%s).\n",
1195 SONAME_LIBFONTCONFIG);
1196 return;
1197 }
1198 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(fc_handle, #f, NULL, 0)) == NULL){WARN("Can't find symbol %s\n", #f); goto sym_not_found;}
1199 LOAD_FUNCPTR(FcConfigGetCurrent);
1200 LOAD_FUNCPTR(FcFontList);
1201 LOAD_FUNCPTR(FcFontSetDestroy);
1202 LOAD_FUNCPTR(FcInit);
1203 LOAD_FUNCPTR(FcObjectSetAdd);
1204 LOAD_FUNCPTR(FcObjectSetCreate);
1205 LOAD_FUNCPTR(FcObjectSetDestroy);
1206 LOAD_FUNCPTR(FcPatternCreate);
1207 LOAD_FUNCPTR(FcPatternDestroy);
1208 LOAD_FUNCPTR(FcPatternGetString);
1209 #undef LOAD_FUNCPTR
1210
1211 if(!pFcInit()) return;
1212
1213 config = pFcConfigGetCurrent();
1214 pat = pFcPatternCreate();
1215 os = pFcObjectSetCreate();
1216 pFcObjectSetAdd(os, FC_FILE);
1217 fontset = pFcFontList(config, pat, os);
1218 if(!fontset) return;
1219 for(i = 0; i < fontset->nfont; i++) {
1220 if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
1221 continue;
1222 TRACE("fontconfig: %s\n", file);
1223
1224 /* We're just interested in OT/TT fonts for now, so this hack just
1225 picks up the standard extensions to save time loading every other
1226 font */
1227 len = strlen( file );
1228 if(len < 4) continue;
1229 ext = &file[ len - 3 ];
1230 if(!strcasecmp(ext, "ttf") || !strcasecmp(ext, "ttc") || !strcasecmp(ext, "otf"))
1231 AddFontFileToList(file, NULL, ADDFONT_EXTERNAL_FONT);
1232 }
1233 pFcFontSetDestroy(fontset);
1234 pFcObjectSetDestroy(os);
1235 pFcPatternDestroy(pat);
1236 sym_not_found:
1237 #endif
1238 return;
1239 }
1240
1241 static BOOL load_font_from_data_dir(LPCWSTR file)
1242 {
1243 BOOL ret = FALSE;
1244 const char *data_dir = wine_get_data_dir();
1245
1246 if (!data_dir) data_dir = wine_get_build_dir();
1247
1248 if (data_dir)
1249 {
1250 INT len;
1251 char *unix_name;
1252
1253 len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
1254
1255 unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
1256
1257 strcpy(unix_name, data_dir);
1258 strcat(unix_name, "/fonts/");
1259
1260 WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
1261
1262 ret = AddFontFileToList(unix_name, NULL, ADDFONT_FORCE_BITMAP);
1263 HeapFree(GetProcessHeap(), 0, unix_name);
1264 }
1265 return ret;
1266 }
1267
1268 static void load_system_fonts(void)
1269 {
1270 HKEY hkey;
1271 WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
1272 const WCHAR * const *value;
1273 DWORD dlen, type;
1274 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
1275 char *unixname;
1276
1277 if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
1278 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1279 strcatW(windowsdir, fontsW);
1280 for(value = SystemFontValues; *value; value++) {
1281 dlen = sizeof(data);
1282 if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
1283 type == REG_SZ) {
1284 BOOL added = FALSE;
1285
1286 sprintfW(pathW, fmtW, windowsdir, data);
1287 if((unixname = wine_get_unix_file_name(pathW))) {
1288 added = AddFontFileToList(unixname, NULL, ADDFONT_FORCE_BITMAP);
1289 HeapFree(GetProcessHeap(), 0, unixname);
1290 }
1291 if (!added)
1292 load_font_from_data_dir(data);
1293 }
1294 }
1295 RegCloseKey(hkey);
1296 }
1297 }
1298
1299 /*************************************************************
1300 *
1301 * This adds registry entries for any externally loaded fonts
1302 * (fonts from fontconfig or FontDirs). It also deletes entries
1303 * of no longer existing fonts.
1304 *
1305 */
1306 static void update_reg_entries(void)
1307 {
1308 HKEY winkey = 0, externalkey = 0;
1309 LPWSTR valueW;
1310 LPVOID data;
1311 DWORD dlen, vlen, datalen, valuelen, i, type, len, len_fam;
1312 Family *family;
1313 Face *face;
1314 struct list *family_elem_ptr, *face_elem_ptr;
1315 WCHAR *file;
1316 static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
1317 static const WCHAR spaceW[] = {' ', '\0'};
1318 char *path;
1319
1320 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
1321 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winkey, NULL) != ERROR_SUCCESS) {
1322 ERR("Can't create Windows font reg key\n");
1323 goto end;
1324 }
1325 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\ExternalFonts */
1326 if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &externalkey) != ERROR_SUCCESS) {
1327 ERR("Can't create external font reg key\n");
1328 goto end;
1329 }
1330
1331 /* Delete all external fonts added last time */
1332
1333 RegQueryInfoKeyW(externalkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1334 &valuelen, &datalen, NULL, NULL);
1335 valuelen++; /* returned value doesn't include room for '\0' */
1336 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1337 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
1338
1339 dlen = datalen * sizeof(WCHAR);
1340 vlen = valuelen;
1341 i = 0;
1342 while(RegEnumValueW(externalkey, i++, valueW, &vlen, NULL, &type, data,
1343 &dlen) == ERROR_SUCCESS) {
1344
1345 RegDeleteValueW(winkey, valueW);
1346 /* reset dlen and vlen */
1347 dlen = datalen;
1348 vlen = valuelen;
1349 }
1350 HeapFree(GetProcessHeap(), 0, data);
1351 HeapFree(GetProcessHeap(), 0, valueW);
1352
1353 /* Delete the old external fonts key */
1354 RegCloseKey(externalkey);
1355 externalkey = 0;
1356 RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
1357
1358 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\ExternalFonts */
1359 if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
1360 0, NULL, 0, KEY_ALL_ACCESS, NULL, &externalkey, NULL) != ERROR_SUCCESS) {
1361 ERR("Can't create external font reg key\n");
1362 goto end;
1363 }
1364
1365 /* enumerate the fonts and add external ones to the two keys */
1366
1367 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1368 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1369 len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
1370 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1371 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1372 if(!face->external) continue;
1373 len = len_fam;
1374 if(strcmpiW(face->StyleName, RegularW))
1375 len = len_fam + strlenW(face->StyleName) + 1;
1376 valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1377 strcpyW(valueW, family->FamilyName);
1378 if(len != len_fam) {
1379 strcatW(valueW, spaceW);
1380 strcatW(valueW, face->StyleName);
1381 }
1382 strcatW(valueW, TrueType);
1383 if((path = strrchr(face->file, '/')) == NULL)
1384 path = face->file;
1385 else
1386 path++;
1387 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
1388
1389 file = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1390 MultiByteToWideChar(CP_ACP, 0, path, -1, file, len);
1391 RegSetValueExW(winkey, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1392 RegSetValueExW(externalkey, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1393
1394 HeapFree(GetProcessHeap(), 0, file);
1395 HeapFree(GetProcessHeap(), 0, valueW);
1396 }
1397 }
1398 end:
1399 if(externalkey)
1400 RegCloseKey(externalkey);
1401 if(winkey)
1402 RegCloseKey(winkey);
1403 return;
1404 }
1405
1406
1407 /*************************************************************
1408 * WineEngAddFontResourceEx
1409 *
1410 */
1411 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
1412 {
1413 if (ft_handle) /* do it only if we have freetype up and running */
1414 {
1415 char *unixname;
1416
1417 if(flags)
1418 FIXME("Ignoring flags %x\n", flags);
1419
1420 if((unixname = wine_get_unix_file_name(file)))
1421 {
1422 AddFontFileToList(unixname, NULL, ADDFONT_FORCE_BITMAP);
1423 HeapFree(GetProcessHeap(), 0, unixname);
1424 }
1425 }
1426 return 1;
1427 }
1428
1429 /*************************************************************
1430 * WineEngRemoveFontResourceEx
1431 *
1432 */
1433 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
1434 {
1435 FIXME(":stub\n");
1436 return TRUE;
1437 }
1438
1439 static const struct nls_update_font_list
1440 {
1441 UINT ansi_cp, oem_cp;
1442 const char *oem, *fixed, *system;
1443 const char *courier, *serif, *small, *sserif;
1444 } nls_update_font_list[] =
1445 {
1446 /* Latin 1 (United States) */
1447 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
1448 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1449 },
1450 /* Latin 1 (Multilingual) */
1451 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
1452 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1453 },
1454 /* Eastern Europe */
1455 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
1456 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
1457 },
1458 /* Cyrillic */
1459 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
1460 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
1461 },
1462 /* Greek */
1463 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
1464 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
1465 },
1466 /* Turkish */
1467 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
1468 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
1469 },
1470 /* Hebrew */
1471 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
1472 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
1473 },
1474 /* Arabic */
1475 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
1476 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
1477 },
1478 /* Baltic */
1479 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
1480 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
1481 },
1482 /* Vietnamese */
1483 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
1484 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1485 },
1486 /* Thai */
1487 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
1488 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
1489 },
1490 /* Japanese */
1491 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
1492 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
1493 },
1494 /* Chinese Simplified */
1495 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
1496 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1497 },
1498 /* Korean */
1499 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
1500 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1501 },
1502 /* Chinese Traditional */
1503 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
1504 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1505 }
1506 };
1507
1508 inline static HKEY create_fonts_NT_registry_key(void)
1509 {
1510 HKEY hkey = 0;
1511
1512 RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
1513 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1514 return hkey;
1515 }
1516
1517 inline static HKEY create_fonts_9x_registry_key(void)
1518 {
1519 HKEY hkey = 0;
1520
1521 RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
1522 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1523 return hkey;
1524 }
1525
1526 inline static HKEY create_config_fonts_registry_key(void)
1527 {
1528 HKEY hkey = 0;
1529
1530 RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
1531 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1532 return hkey;
1533 }
1534
1535 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl)
1536 {
1537 RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
1538 RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
1539 RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)fl->sserif, strlen(fl->sserif)+1);
1540 RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
1541 }
1542
1543 static void update_font_info(void)
1544 {
1545 char buf[80];
1546 DWORD len, type;
1547 HKEY hkey = 0;
1548 UINT i, ansi_cp = 0, oem_cp = 0;
1549 LCID lcid = GetUserDefaultLCID();
1550
1551 if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) != ERROR_SUCCESS)
1552 return;
1553
1554 len = sizeof(buf);
1555 if (RegQueryValueExA(hkey, "Locale", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
1556 {
1557 if (strtoul(buf, NULL, 16 ) == lcid) /* already set correctly */
1558 {
1559 RegCloseKey(hkey);
1560 return;
1561 }
1562 TRACE("updating registry, locale changed %s -> %08x\n", debugstr_a(buf), lcid);
1563 }
1564 else TRACE("updating registry, locale changed none -> %08x\n", lcid);
1565
1566 sprintf(buf, "%08x", lcid);
1567 RegSetValueExA(hkey, "Locale", 0, REG_SZ, (const BYTE *)buf, strlen(buf)+1);
1568 RegCloseKey(hkey);
1569
1570 GetLocaleInfoW(lcid, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
1571 (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
1572 GetLocaleInfoW(lcid, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
1573 (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
1574
1575 for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
1576 {
1577 if (nls_update_font_list[i].ansi_cp == ansi_cp &&
1578 nls_update_font_list[i].oem_cp == oem_cp)
1579 {
1580 HKEY hkey;
1581
1582 hkey = create_config_fonts_registry_key();
1583 RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
1584 RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
1585 RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
1586 RegCloseKey(hkey);
1587
1588 hkey = create_fonts_NT_registry_key();
1589 add_font_list(hkey, &nls_update_font_list[i]);
1590 RegCloseKey(hkey);
1591
1592 hkey = create_fonts_9x_registry_key();
1593 add_font_list(hkey, &nls_update_font_list[i]);
1594 RegCloseKey(hkey);
1595
1596 return;
1597 }
1598 }
1599 FIXME("there is no font defaults for lcid %04x/ansi_cp %u\n", lcid, ansi_cp);
1600 }
1601
1602 /*************************************************************
1603 * WineEngInit
1604 *
1605 * Initialize FreeType library and create a list of available faces
1606 */
1607 BOOL WineEngInit(void)
1608 {
1609 static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
1610 static const WCHAR pathW[] = {'P','a','t','h',0};
1611 HKEY hkey;
1612 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1613 LPVOID data;
1614 WCHAR windowsdir[MAX_PATH];
1615 char *unixname;
1616 HANDLE font_mutex;
1617 const char *data_dir;
1618
1619 TRACE("\n");
1620
1621 /* update locale dependent font info in registry */
1622 update_font_info();
1623
1624 ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
1625 if(!ft_handle) {
1626 WINE_MESSAGE(
1627 "Wine cannot find the FreeType font library. To enable Wine to\n"
1628 "use TrueType fonts please install a version of FreeType greater than\n"
1629 "or equal to 2.0.5.\n"
1630 "http://www.freetype.org\n");
1631 return FALSE;
1632 }
1633
1634 #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;}
1635
1636 LOAD_FUNCPTR(FT_Vector_Unit)
1637 LOAD_FUNCPTR(FT_Done_Face)
1638 LOAD_FUNCPTR(FT_Get_Char_Index)
1639 LOAD_FUNCPTR(FT_Get_Module)
1640 LOAD_FUNCPTR(FT_Get_Sfnt_Name)
1641 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
1642 LOAD_FUNCPTR(FT_Get_Sfnt_Table)
1643 LOAD_FUNCPTR(FT_Init_FreeType)
1644 LOAD_FUNCPTR(FT_Load_Glyph)
1645 LOAD_FUNCPTR(FT_Matrix_Multiply)
1646 LOAD_FUNCPTR(FT_MulFix)
1647 LOAD_FUNCPTR(FT_New_Face)
1648 LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
1649 LOAD_FUNCPTR(FT_Outline_Transform)
1650 LOAD_FUNCPTR(FT_Outline_Translate)
1651 LOAD_FUNCPTR(FT_Select_Charmap)
1652 LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
1653 LOAD_FUNCPTR(FT_Vector_Transform)
1654
1655 #undef LOAD_FUNCPTR
1656 /* Don't warn if this one is missing */
1657 pFT_Library_Version = wine_dlsym(ft_handle, "FT_Library_Version", NULL, 0);
1658 pFT_Load_Sfnt_Table = wine_dlsym(ft_handle, "FT_Load_Sfnt_Table", NULL, 0);
1659 pFT_Get_First_Char = wine_dlsym(ft_handle, "FT_Get_First_Char", NULL, 0);
1660 pFT_Get_Next_Char = wine_dlsym(ft_handle, "FT_Get_Next_Char", NULL, 0);
1661 pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
1662 #ifdef HAVE_FREETYPE_FTWINFNT_H
1663 pFT_Get_WinFNT_Header = wine_dlsym(ft_handle, "FT_Get_WinFNT_Header", NULL, 0);
1664 #endif
1665 if(!wine_dlsym(ft_handle, "FT_Get_Postscript_Name", NULL, 0) &&
1666 !wine_dlsym(ft_handle, "FT_Sqrt64", NULL, 0)) {
1667 /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
1668 <= 2.0.3 has FT_Sqrt64 */
1669 goto sym_not_found;
1670 }
1671
1672 if(pFT_Init_FreeType(&library) != 0) {
1673 ERR("Can't init FreeType library\n");
1674 wine_dlclose(ft_handle, NULL, 0);
1675 ft_handle = NULL;
1676 return FALSE;
1677 }
1678 FT_Version.major=FT_Version.minor=FT_Version.patch=-1;
1679 if (pFT_Library_Version)
1680 {
1681 pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
1682 }
1683 if (FT_Version.major<=0)
1684 {
1685 FT_Version.major=2;
1686 FT_Version.minor=0;
1687 FT_Version.patch=5;
1688 }
1689 TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
1690 FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
1691 ((FT_Version.minor << 8) & 0x00ff00) |
1692 ((FT_Version.patch ) & 0x0000ff);
1693
1694 if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL) {
1695 ERR("Failed to create font mutex\n");
1696 return FALSE;
1697 }
1698 WaitForSingleObject(font_mutex, INFINITE);
1699
1700 /* load the system bitmap fonts */
1701 load_system_fonts();
1702
1703 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
1704 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1705 strcatW(windowsdir, fontsW);
1706 if((unixname = wine_get_unix_file_name(windowsdir)))
1707 {
1708 ReadFontDir(unixname, FALSE);
1709 HeapFree(GetProcessHeap(), 0, unixname);
1710 }
1711
1712 /* load the system truetype fonts */
1713 data_dir = wine_get_data_dir();
1714 if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/")))) {
1715 strcpy(unixname, data_dir);
1716 strcat(unixname, "/fonts/");
1717 ReadFontDir(unixname, FALSE);
1718 HeapFree(GetProcessHeap(), 0, unixname);
1719 }
1720
1721 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
1722 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
1723 full path as the entry. Also look for any .fon fonts, since ReadFontDir
1724 will skip these. */
1725 if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
1726 is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
1727 &hkey) == ERROR_SUCCESS) {
1728 LPWSTR valueW;
1729 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1730 &valuelen, &datalen, NULL, NULL);
1731
1732 valuelen++; /* returned value doesn't include room for '\0' */
1733 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1734 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
1735 if (valueW && data)
1736 {
1737 dlen = datalen * sizeof(WCHAR);
1738 vlen = valuelen;
1739 while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, data,
1740 &dlen) == ERROR_SUCCESS) {
1741 if(((LPWSTR)data)[0] && ((LPWSTR)data)[1] == ':')
1742 {
1743 if((unixname = wine_get_unix_file_name((LPWSTR)data)))
1744 {
1745 AddFontFileToList(unixname, NULL, ADDFONT_FORCE_BITMAP);
1746 HeapFree(GetProcessHeap(), 0, unixname);
1747 }
1748 }
1749 else if(dlen / 2 >= 6 && !strcmpiW(((LPWSTR)data) + dlen / 2 - 5, dot_fonW))
1750 {
1751 WCHAR pathW[MAX_PATH];
1752 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
1753 BOOL added = FALSE;
1754
1755 sprintfW(pathW, fmtW, windowsdir, data);
1756 if((unixname = wine_get_unix_file_name(pathW)))
1757 {
1758 added = AddFontFileToList(unixname, NULL, ADDFONT_FORCE_BITMAP);
1759 HeapFree(GetProcessHeap(), 0, unixname);
1760 }
1761 if (!added)
1762 load_font_from_data_dir(data);
1763 }
1764 /* reset dlen and vlen */
1765 dlen = datalen;
1766 vlen = valuelen;
1767 }
1768 }
1769 HeapFree(GetProcessHeap(), 0, data);
1770 HeapFree(GetProcessHeap(), 0, valueW);
1771 RegCloseKey(hkey);
1772 }
1773
1774 load_fontconfig_fonts();
1775
1776 /* then look in any directories that we've specified in the config file */
1777 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
1778 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
1779 {
1780 DWORD len;
1781 LPWSTR valueW;
1782 LPSTR valueA, ptr;
1783
1784 if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
1785 {
1786 len += sizeof(WCHAR);
1787 valueW = HeapAlloc( GetProcessHeap(), 0, len );
1788 if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
1789 {
1790 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
1791 valueA = HeapAlloc( GetProcessHeap(), 0, len );
1792 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
1793 TRACE( "got font path %s\n", debugstr_a(valueA) );
1794 ptr = valueA;
1795 while (ptr)
1796 {
1797 LPSTR next = strchr( ptr, ':' );
1798 if (next) *next++ = 0;
1799 ReadFontDir( ptr, TRUE );
1800 ptr = next;
1801 }
1802 HeapFree( GetProcessHeap(), 0, valueA );
1803 }
1804 HeapFree( GetProcessHeap(), 0, valueW );
1805 }
1806 RegCloseKey(hkey);
1807 }
1808
1809 DumpFontList();
1810 LoadSubstList();
1811 DumpSubstList();
1812 LoadReplaceList();
1813 update_reg_entries();
1814
1815 init_system_links();
1816
1817 ReleaseMutex(font_mutex);
1818 return TRUE;
1819 sym_not_found:
1820 WINE_MESSAGE(
1821 "Wine cannot find certain functions that it needs inside the FreeType\n"
1822 "font library. To enable Wine to use TrueType fonts please upgrade\n"
1823 "FreeType to at least version 2.0.5.\n"
1824 "http://www.freetype.org\n");
1825 wine_dlclose(ft_handle, NULL, 0);
1826 ft_handle = NULL;
1827 return FALSE;
1828 }
1829
1830
1831 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
1832 {
1833 TT_OS2 *pOS2;
1834 TT_HoriHeader *pHori;
1835
1836 LONG ppem;
1837
1838 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
1839 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
1840
1841 if(height == 0) height = 16;
1842
1843 /* Calc. height of EM square:
1844 *
1845 * For +ve lfHeight we have
1846 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
1847 * Re-arranging gives:
1848 * ppem = units_per_em * lfheight / (winAscent + winDescent)
1849 *
1850 * For -ve lfHeight we have
1851 * |lfHeight| = ppem
1852 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
1853 * with il = winAscent + winDescent - units_per_em]
1854 *
1855 */
1856
1857 if(height > 0) {
1858 if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
1859 ppem = ft_face->units_per_EM * height /
1860 (pHori->Ascender - pHori->Descender);
1861 else
1862 ppem = ft_face->units_per_EM * height /
1863 (pOS2->usWinAscent + pOS2->usWinDescent);
1864 }
1865 else
1866 ppem = -height;
1867
1868 return ppem;
1869 }
1870
1871 static LONG load_VDMX(GdiFont*, LONG);
1872
1873 static FT_Face OpenFontFile(GdiFont *font, char *file, FT_Long face_index, LONG width, LONG height)
1874 {
1875 FT_Error err;
1876 FT_Face ft_face;
1877
1878 TRACE("%s, %ld, %d x %d\n", debugstr_a(file), face_index, width, height);
1879 err = pFT_New_Face(library, file, face_index, &ft_face);
1880 if(err) {
1881 ERR("FT_New_Face rets %d\n", err);
1882 return 0;
1883 }
1884
1885 /* set it here, as load_VDMX needs it */
1886 font->ft_face = ft_face;
1887
1888 if(FT_IS_SCALABLE(ft_face)) {
1889 /* load the VDMX table if we have one */
1890 font->ppem = load_VDMX(font, height);
1891 if(font->ppem == 0)
1892 font->ppem = calc_ppem_for_height(ft_face, height);
1893
1894 if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
1895 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font->ppem, err);
1896 } else {
1897 font->ppem = height;
1898 if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
1899 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width, height, err);
1900 }
1901 return ft_face;
1902 }
1903
1904
1905 static int get_nearest_charset(Face *face, int *cp)
1906 {
1907 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
1908 a single face with the requested charset. The idea is to check if
1909 the selected font supports the current ANSI codepage, if it does
1910 return the corresponding charset, else return the first charset */
1911
1912 CHARSETINFO csi;
1913 int acp = GetACP(), i;
1914 DWORD fs0;
1915
1916 *cp = acp;
1917 if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
1918 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
1919 return csi.ciCharset;
1920
1921 for(i = 0; i < 32; i++) {
1922 fs0 = 1L << i;
1923 if(face->fs.fsCsb[0] & fs0) {
1924 if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
1925 *cp = csi.ciACP;
1926 return csi.ciCharset;
1927 }
1928 else
1929 FIXME("TCI failing on %x\n", fs0);
1930 }
1931 }
1932
1933 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
1934 face->fs.fsCsb[0], face->file);
1935 *cp = acp;
1936 return DEFAULT_CHARSET;
1937 }
1938
1939 static GdiFont *alloc_font(void)
1940 {
1941 GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
1942 ret->gmsize = INIT_GM_SIZE;
1943 ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1944 ret->gmsize * sizeof(*ret->gm));
1945 ret->potm = NULL;
1946 ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
1947 ret->total_kern_pairs = (DWORD)-1;
1948 ret->kern_pairs = NULL;
1949 list_init(&ret->hfontlist);
1950 list_init(&ret->child_fonts);
1951 return ret;
1952 }
1953
1954 static void free_font(GdiFont *font)
1955 {
1956 struct list *cursor, *cursor2;
1957
1958 LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
1959 {
1960 CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
1961 struct list *first_hfont;
1962 HFONTLIST *hfontlist;
1963 list_remove(cursor);
1964 if(child->font)
1965 {
1966 first_hfont = list_head(&child->font->hfontlist);
1967 hfontlist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
1968 DeleteObject(hfontlist->hfont);
1969 HeapFree(GetProcessHeap(), 0, hfontlist);
1970 free_font(child->font);
1971 }
1972 HeapFree(GetProcessHeap(), 0, child->file_name);
1973 HeapFree(GetProcessHeap(), 0, child);
1974 }
1975
1976 if (font->ft_face) pFT_Done_Face(font->ft_face);
1977 HeapFree(GetProcessHeap(), 0, font->kern_pairs);
1978 HeapFree(GetProcessHeap(), 0, font->potm);
1979 HeapFree(GetProcessHeap(), 0, font->name);
1980 HeapFree(GetProcessHeap(), 0, font->gm);
1981 HeapFree(GetProcessHeap(), 0, font);
1982 }
1983
1984
1985 /*************************************************************
1986 * load_VDMX
1987 *
1988 * load the vdmx entry for the specified height
1989 */
1990
1991 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
1992 ( ( (FT_ULong)_x4 << 24 ) | \
1993 ( (FT_ULong)_x3 << 16 ) | \
1994 ( (FT_ULong)_x2 << 8 ) | \
1995 (FT_ULong)_x1 )
1996
1997 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
1998
1999 typedef struct {
2000 BYTE bCharSet;
2001 BYTE xRatio;
2002 BYTE yStartRatio;
2003 BYTE yEndRatio;
2004 } Ratios;
2005
2006 typedef struct {
2007 WORD recs;
2008 BYTE startsz;
2009 BYTE endsz;
2010 } VDMX_group;
2011
2012 static LONG load_VDMX(GdiFont *font, LONG height)
2013 {
2014 WORD hdr[3], tmp;
2015 VDMX_group group;
2016 BYTE devXRatio, devYRatio;
2017 USHORT numRecs, numRatios;
2018 DWORD result, offset = -1;
2019 LONG ppem = 0;
2020 int i;
2021
2022 /* For documentation on VDMX records, see
2023 * http://www.microsoft.com/OpenType/OTSpec/vdmx.htm
2024 */
2025
2026 result = WineEngGetFontData(font, MS_VDMX_TAG, 0, hdr, 6);
2027
2028 if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
2029 return ppem;
2030
2031 /* FIXME: need the real device aspect ratio */
2032 devXRatio = 1;
2033 devYRatio = 1;
2034
2035 numRecs = GET_BE_WORD(hdr[1]);
2036 numRatios = GET_BE_WORD(hdr[2]);
2037
2038 TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
2039 for(i = 0; i < numRatios; i++) {
2040 Ratios ratio;
2041
2042 offset = (3 * 2) + (i * sizeof(Ratios));
2043 WineEngGetFontData(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
2044 offset = -1;
2045
2046 TRACE("Ratios[%d] %d %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
2047
2048 if((ratio.xRatio == 0 &&
2049 ratio.yStartRatio == 0 &&
2050 ratio.yEndRatio == 0) ||
2051 (devXRatio == ratio.xRatio &&
2052 devYRatio >= ratio.yStartRatio &&
2053 devYRatio <= ratio.yEndRatio))
2054 {
2055 offset = (3 * 2) + (numRatios * 4) + (i * 2);
2056 WineEngGetFontData(font, MS_VDMX_TAG, offset, &tmp, 2);
2057 offset = GET_BE_WORD(tmp);
2058 break;
2059 }
2060 }
2061
2062 if(offset == -1) {
2063 FIXME("No suitable ratio found\n");
2064 return ppem;
2065 }
2066
2067 if(WineEngGetFontData(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
2068 USHORT recs;
2069 BYTE startsz, endsz;
2070 WORD *vTable;
2071
2072 recs = GET_BE_WORD(group.recs);
2073 startsz = group.startsz;
2074 endsz = group.endsz;
2075
2076 TRACE("recs=%d startsz=%d endsz=%d\n", recs, startsz, endsz);
2077
2078 vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
2079 result = WineEngGetFontData(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
2080 if(result == GDI_ERROR) {
2081 FIXME("Failed to retrieve vTable\n");
2082 goto end;
2083 }
2084
2085 if(height > 0) {
2086 for(i = 0; i < recs; i++) {
2087 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2088 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2089 ppem = GET_BE_WORD(vTable[i * 3]);
2090
2091 if(yMax + -yMin == height) {
2092 font->yMax = yMax;
2093 font->yMin = yMin;
2094 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
2095 break;
2096 }
2097 if(yMax + -yMin > height) {
2098 if(--i < 0) {
2099 ppem = 0;
2100 goto end; /* failed */
2101 }
2102 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2103 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2104 ppem = GET_BE_WORD(vTable[i * 3]);
2105 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
2106 break;
2107 }
2108 }
2109 if(!font->yMax) {
2110 ppem = 0;
2111 TRACE("ppem not found for height %d\n", height);
2112 }
2113 } else {
2114 ppem = -height;
2115 if(ppem < startsz || ppem > endsz)
2116 goto end;
2117
2118 for(i = 0; i < recs; i++) {
2119 USHORT yPelHeight;
2120 yPelHeight = GET_BE_WORD(vTable[i * 3]);
2121
2122 if(yPelHeight > ppem)
2123 break; /* failed */
2124
2125 if(yPelHeight == ppem) {
2126 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2127 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2128 TRACE("ppem %d found; yMax=%d yMin=%d\n", ppem, font->yMax, font->yMin);
2129 break;
2130 }
2131 }
2132 }
2133 end:
2134 HeapFree(GetProcessHeap(), 0, vTable);
2135 }
2136
2137 return ppem;
2138 }
2139
2140 static BOOL fontcmp(GdiFont *font, FONT_DESC *fd)
2141 {
2142 if(font->font_desc.hash != fd->hash) return TRUE;
2143 if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
2144 if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
2145 if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
2146 return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
2147 }
2148
2149 static void calc_hash(FONT_DESC *pfd)
2150 {
2151 DWORD hash = 0, *ptr, two_chars;
2152 WORD *pwc;
2153 unsigned int i;
2154
2155 for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
2156 hash ^= *ptr;
2157 for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
2158 hash ^= *ptr;
2159 for(i = 0, ptr = (DWORD*)&pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
2160 two_chars = *ptr;
2161 pwc = (WCHAR *)&two_chars;
2162 if(!*pwc) break;
2163 *pwc = toupperW(*pwc);
2164 pwc++;
2165 *pwc = toupperW(*pwc);
2166 hash ^= two_chars;
2167 if(!*pwc) break;
2168 }
2169 hash ^= !pfd->can_use_bitmap;
2170 pfd->hash = hash;
2171 return;
2172 }
2173
2174 static GdiFont *find_in_cache(HFONT hfont, LOGFONTW *plf, XFORM *pxf, BOOL can_use_bitmap)
2175 {
2176 GdiFont *ret;
2177 FONT_DESC fd;
2178 HFONTLIST *hflist;
2179 struct list *font_elem_ptr, *hfontlist_elem_ptr;
2180
2181 memcpy(&fd.lf, plf, sizeof(LOGFONTW));
2182 memcpy(&fd.matrix, pxf, sizeof(FMAT2));
2183 fd.can_use_bitmap = can_use_bitmap;
2184 calc_hash(&fd);
2185
2186 /* try the in-use list */
2187 LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
2188 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2189 if(!fontcmp(ret, &fd)) {
2190 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2191 LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
2192 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
2193 if(hflist->hfont == hfont)
2194 return ret;
2195 }
2196 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2197 hflist->hfont = hfont;
2198 list_add_head(&ret->hfontlist, &hflist->entry);
2199 return ret;
2200 }
2201 }
2202
2203 /* then the unused list */
2204 font_elem_ptr = list_head(&unused_gdi_font_list);
2205 while(font_elem_ptr) {
2206 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2207 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2208 if(!fontcmp(ret, &fd)) {
2209 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2210 assert(list_empty(&ret->hfontlist));
2211 TRACE("Found %p in unused list\n", ret);
2212 list_remove(&ret->entry);
2213 list_add_head(&gdi_font_list, &ret->entry);
2214 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2215 hflist->hfont = hfont;
2216 list_add_head(&ret->hfontlist, &hflist->entry);
2217 return ret;
2218 }
2219 }
2220 return NULL;
2221 }
2222
2223
2224 /*************************************************************
2225 * create_child_font_list
2226 */
2227 static BOOL create_child_font_list(GdiFont *font)
2228 {
2229 BOOL ret = FALSE;
2230 SYSTEM_LINKS *font_link;
2231 CHILD_FONT *font_link_entry, *new_child;
2232
2233 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2234 {
2235 if(!strcmpW(font_link->font_name, font->name))
2236 {
2237 TRACE("found entry in system list\n");
2238 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2239 {
2240 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
2241 new_child->file_name = strdupA(font_link_entry->file_name);
2242 new_child->index = font_link_entry->index;
2243 new_child->font = NULL;
2244 list_add_tail(&font->child_fonts, &new_child->entry);
2245 TRACE("font %s %d\n", debugstr_a(new_child->file_name), new_child->index);
2246 }
2247 ret = TRUE;
2248 break;
2249 }
2250 }
2251
2252 return ret;
2253 }
2254
2255 /*************************************************************
2256 * WineEngCreateFontInstance
2257 *
2258 */
2259 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
2260 {
2261 GdiFont *ret;
2262 Face *face, *best, *best_bitmap;
2263 Family *family, *last_resort_family;
2264 struct list *family_elem_ptr, *face_elem_ptr;
2265 INT height, width = 0;
2266 unsigned int score = 0, new_score;
2267 signed int diff = 0, newdiff;
2268 BOOL bd, it, can_use_bitmap;
2269 LOGFONTW lf;
2270 CHARSETINFO csi;
2271 HFONTLIST *hflist;
2272
2273 LIST_FOR_EACH_ENTRY(ret, &child_font_list, struct tagGdiFont, entry)
2274 {
2275 struct list *first_hfont = list_head(&ret->hfontlist);
2276 hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2277 if(hflist->hfont == hfont)
2278 return ret;
2279 }
2280
2281 if (!GetObjectW( hfont, sizeof(lf), &lf )) return NULL;
2282 can_use_bitmap = GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_RA_ABLE;
2283
2284 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
2285 debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
2286 lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
2287 lf.lfEscapement);
2288
2289 /* check the cache first */
2290 if((ret = find_in_cache(hfont, &lf, &dc->xformWorld2Vport, can_use_bitmap)) != NULL) {
2291 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
2292 return ret;
2293 }
2294
2295 TRACE("not in cache\n");
2296 if(list_empty(&font_list)) /* No fonts installed */
2297 {
2298 TRACE("No fonts installed\n");
2299 return NULL;
2300 }
2301 if(!have_installed_roman_font)
2302 {
2303 TRACE("No roman font installed\n");
2304 return NULL;
2305 }
2306
2307 ret = alloc_font();
2308
2309 memcpy(&ret->font_desc.matrix, &dc->xformWorld2Vport, sizeof(FMAT2));
2310 memcpy(&ret->font_desc.lf, &lf, sizeof(LOGFONTW));
2311 ret->font_desc.can_use_bitmap = can_use_bitmap;
2312 calc_hash(&ret->font_desc);
2313 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2314 hflist->hfont = hfont;
2315 list_add_head(&ret->hfontlist, &hflist->entry);
2316
2317
2318 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
2319 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
2320 original value lfCharSet. Note this is a special case for
2321 Symbol and doesn't happen at least for "Wingdings*" */
2322
2323 if(!strcmpiW(lf.lfFaceName, SymbolW))
2324 lf.lfCharSet = SYMBOL_CHARSET;
2325
2326 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
2327 switch(lf.lfCharSet) {
2328 case DEFAULT_CHARSET:
2329 csi.fs.fsCsb[0] = 0;
2330 break;
2331 default:
2332 FIXME("Untranslated charset %d\n", lf.lfCharSet);
2333 csi.fs.fsCsb[0] = 0;
2334 break;
2335 }
2336 }
2337
2338 family = NULL;
2339 if(lf.lfFaceName[0] != '\0') {
2340 FontSubst *psub;
2341 psub = get_font_subst(&font_subst_list, lf.lfFaceName, lf.lfCharSet);
2342
2343 if(psub) {
2344 TRACE("substituting %s -> %s\n", debugstr_w(lf.lfFaceName),
2345 debugstr_w(psub->to.name));
2346 strcpyW(lf.lfFaceName, psub->to.name);
2347 }
2348
2349 /* We want a match on name and charset or just name if
2350 charset was DEFAULT_CHARSET. If the latter then
2351 we fixup the returned charset later in get_nearest_charset
2352 where we'll either use the charset of the current ansi codepage
2353 or if that's unavailable the first charset that the font supports.
2354 */
2355 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2356 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2357 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
2358 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2359 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2360 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
2361 if(face->scalable || can_use_bitmap)
2362 goto found;
2363 }
2364 }
2365 }
2366 }
2367
2368 /* If requested charset was DEFAULT_CHARSET then try using charset
2369 corresponding to the current ansi codepage */
2370 if(!csi.fs.fsCsb[0]) {
2371 INT acp = GetACP();
2372 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
2373 FIXME("TCI failed on codepage %d\n", acp);
2374 csi.fs.fsCsb[0] = 0;
2375 } else
2376 lf.lfCharSet = csi.ciCharset;
2377 }
2378
2379 /* Face families are in the top 4 bits of lfPitchAndFamily,
2380 so mask with 0xF0 before testing */
2381
2382 if((lf.lfPitchAndFamily & FIXED_PITCH) ||
2383 (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
2384 strcpyW(lf.lfFaceName, defFixed);
2385 else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
2386 strcpyW(lf.lfFaceName, defSerif);
2387 else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
2388 strcpyW(lf.lfFaceName, defSans);
2389 else
2390 strcpyW(lf.lfFaceName, defSans);
2391 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2392 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2393 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
2394 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2395 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2396 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
2397 if(face->scalable || can_use_bitmap)
2398 goto found;
2399 }
2400 }
2401 }
2402
2403 last_resort_family = NULL;
2404 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2405 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2406 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2407 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2408 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) {
2409 if(face->scalable)
2410 goto found;
2411 if(can_use_bitmap && !last_resort_family)
2412 last_resort_family = family;
2413 }
2414 }
2415 }
2416
2417 if(last_resort_family) {
2418 family = last_resort_family;
2419 csi.fs.fsCsb[0] = 0;
2420 goto found;
2421 }
2422
2423 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2424 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2425 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2426 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2427 if(face->scalable) {
2428 csi.fs.fsCsb[0] = 0;
2429 WARN("just using first face for now\n");
2430 goto found;
2431 }
2432 if(can_use_bitmap && !last_resort_family)
2433 last_resort_family = family;
2434 }
2435 }
2436 if(!last_resort_family) {
2437 FIXME("can't find a single appropriate font - bailing\n");
2438 free_font(ret);
2439 return NULL;
2440 }
2441
2442 WARN("could only find a bitmap font - this will probably look awful!\n");
2443 family = last_resort_family;
2444 csi.fs.fsCsb[0] = 0;
2445
2446 found:
2447 it = lf.lfItalic ? 1 : 0;
2448 bd = lf.lfWeight > 550 ? 1 : 0;
2449
2450 height = GDI_ROUND( (FLOAT)lf.lfHeight * dc->xformWorld2Vport.eM22 );
2451 height = lf.lfHeight < 0 ? -abs(height) : abs(height);
2452
2453 face = best = best_bitmap = NULL;
2454 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
2455 {
2456 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
2457 {
2458 new_score = (face->Italic ^ it) + (face->Bold ^ bd);
2459 if(!best || new_score <= score)
2460 {
2461 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
2462 face->Italic, face->Bold, it, bd);
2463 score = new_score;
2464 best = face;
2465 if(best->scalable && score == 0) break;
2466 if(!best->scalable)
2467 {
2468 if(height > 0)
2469 newdiff = height - (signed int)(best->size.height);
2470 else
2471 newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
2472 if(!best_bitmap || new_score < score ||
2473 (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
2474 {
2475 TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
2476 diff = newdiff;
2477 best_bitmap = best;
2478 if(score == 0 && diff == 0) break;
2479 }
2480 }
2481 }
2482 }
2483 }
2484 if(best)
2485 face = best->scalable ? best : best_bitmap;
2486 ret->fake_italic = (it && !face->Italic);
2487 ret->fake_bold = (bd && !face->Bold);
2488
2489 memcpy(&ret->fs, &face->fs, sizeof(FONTSIGNATURE));
2490
2491 if(csi.fs.fsCsb[0]) {
2492 ret->charset = lf.lfCharSet;
2493 ret->codepage = csi.ciACP;
2494 }
2495 else
2496 ret->charset = get_nearest_charset(face, &ret->codepage);
2497
2498 TRACE("Chosen: %s %s (%s:%ld)\n", debugstr_w(family->FamilyName),
2499 debugstr_w(face->StyleName), face->file, face->face_index);
2500
2501 if(!face->scalable) {
2502 width = face->size.x_ppem >> 6;
2503 height = face->size.y_ppem >> 6;
2504 }
2505 ret->ft_face = OpenFontFile(ret, face->file, face->face_index, width, height);
2506
2507 if (!ret->ft_face)
2508 {
2509 free_font( ret );
2510 return 0;
2511 }
2512
2513 if (ret->charset == SYMBOL_CHARSET &&
2514 !pFT_Select_Charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
2515 /* No ops */
2516 }
2517 else if (!pFT_Select_Charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
2518 /* No ops */
2519 }
2520 else {
2521 pFT_Select_Charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
2522 }
2523
2524 ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
2525 ret->name = strdupW(family->FamilyName);
2526 ret->underline = lf.lfUnderline ? 0xff : 0;
2527 ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
2528 create_child_font_list(ret);
2529
2530 TRACE("caching: gdiFont=%p hfont=%p\n", ret, hfont);
2531
2532 ret->aveWidth = FT_IS_SCALABLE(ret->ft_face) ? lf.lfWidth : 0;
2533 list_add_head(&gdi_font_list, &ret->entry);
2534 return ret;
2535 }
2536
2537 static void dump_gdi_font_list(void)
2538 {
2539 GdiFont *gdiFont;
2540 struct list *elem_ptr;
2541
2542 TRACE("---------- gdiFont Cache ----------\n");
2543 LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
2544 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
2545 TRACE("gdiFont=%p %s %d\n",
2546 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
2547 }
2548
2549 TRACE("---------- Unused gdiFont Cache ----------\n");
2550 LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
2551 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
2552 TRACE("gdiFont=%p %s %d\n",
2553 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
2554 }
2555 }
2556
2557 /*************************************************************
2558 * WineEngDestroyFontInstance
2559 *
2560 * free the gdiFont associated with this handle
2561 *
2562 */
2563 BOOL WineEngDestroyFontInstance(HFONT handle)
2564 {
2565 GdiFont *gdiFont;
2566 HFONTLIST *hflist;
2567 BOOL ret = FALSE;
2568 struct list *font_elem_ptr, *hfontlist_elem_ptr;
2569 int i = 0;
2570
2571 LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
2572 {
2573 struct list *first_hfont = list_head(&gdiFont->hfontlist);
2574 hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2575 if(hflist->hfont == handle)
2576 {
2577 TRACE("removing child font %p from child list\n", gdiFont);
2578 list_remove(&gdiFont->entry);
2579 return TRUE;
2580 }
2581 }
2582
2583 TRACE("destroying hfont=%p\n", handle);
2584 if(TRACE_ON(font))
2585 dump_gdi_font_list();
2586
2587 font_elem_ptr = list_head(&gdi_font_list);
2588 while(font_elem_ptr) {
2589 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2590 font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
2591
2592 hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
2593 while(hfontlist_elem_ptr) {
2594 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
2595 hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
2596 if(hflist->hfont == handle) {
2597 list_remove(&hflist->entry);
2598 HeapFree(GetProcessHeap(), 0, hflist);
2599 ret = TRUE;
2600 }
2601 }
2602 if(list_empty(&gdiFont->hfontlist)) {
2603 TRACE("Moving to Unused list\n");
2604 list_remove(&gdiFont->entry);
2605 list_add_head(&unused_gdi_font_list, &gdiFont->entry);
2606 }
2607 }
2608
2609
2610 font_elem_ptr = list_head(&unused_gdi_font_list);
2611 while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
2612 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2613 while(font_elem_ptr) {
2614 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2615 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2616 TRACE("freeing %p\n", gdiFont);
2617 list_remove(&gdiFont->entry);
2618 free_font(gdiFont);
2619 }
2620 return ret;
2621 }
2622
2623 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
2624 NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
2625 {
2626 OUTLINETEXTMETRICW *potm = NULL;
2627 UINT size;
2628 TEXTMETRICW tm, *ptm;
2629 GdiFont *font = alloc_font();
2630 LONG width, height;
2631
2632 if(face->scalable) {
2633 height = 100;
2634 width = 0;
2635 } else {
2636 height = face->size.y_ppem >> 6;
2637 width = face->size.x_ppem >> 6;
2638 }
2639
2640 if (!(font->ft_face = OpenFontFile(font, face->file, face->face_index, width, height)))
2641 {
2642 free_font(font);
2643 return;
2644 }
2645
2646 font->name = strdupW(face->family->FamilyName);
2647
2648 memset(&pelf->elfLogFont, 0, sizeof(LOGFONTW));
2649
2650 size = WineEngGetOutlineTextMetrics(font, 0, NULL);
2651 if(size) {
2652 potm = HeapAlloc(GetProcessHeap(), 0, size);
2653 WineEngGetOutlineTextMetrics(font, size, potm);
2654 ptm = (TEXTMETRICW*)&potm->otmTextMetrics;
2655 } else {
2656 WineEngGetTextMetrics(font, &tm);
2657 ptm = &tm;
2658 }
2659
2660 pntm->ntmTm.tmHeight = pelf->elfLogFont.lfHeight = ptm->tmHeight;
2661 pntm->ntmTm.tmAscent = ptm->tmAscent;
2662 pntm->ntmTm.tmDescent = ptm->tmDescent;
2663 pntm->ntmTm.tmInternalLeading = ptm->tmInternalLeading;
2664 pntm->ntmTm.tmExternalLeading = ptm->tmExternalLeading;
2665 pntm->ntmTm.tmAveCharWidth = pelf->elfLogFont.lfWidth = ptm->tmAveCharWidth;
2666 pntm->ntmTm.tmMaxCharWidth = ptm->tmMaxCharWidth;
2667 pntm->ntmTm.tmWeight = pelf->elfLogFont.lfWeight = ptm->tmWeight;
2668 pntm->ntmTm.tmOverhang = ptm->tmOverhang;
2669 pntm->ntmTm.tmDigitizedAspectX = ptm->tmDigitizedAspectX;
2670 pntm->ntmTm.tmDigitizedAspectY = ptm->tmDigitizedAspectY;
2671 pntm->ntmTm.tmFirstChar = ptm->tmFirstChar;
2672 pntm->ntmTm.tmLastChar = ptm->tmLastChar;
2673 pntm->ntmTm.tmDefaultChar = ptm->tmDefaultChar;
2674 pntm->ntmTm.tmBreakChar = ptm->tmBreakChar;
2675 pntm->ntmTm.tmItalic = pelf->elfLogFont.lfItalic = ptm->tmItalic;
2676 pntm->ntmTm.tmUnderlined = pelf->elfLogFont.lfUnderline = ptm->tmUnderlined;
2677 pntm->ntmTm.tmStruckOut = pelf->elfLogFont.lfStrikeOut = ptm->tmStruckOut;
2678 pntm->ntmTm.tmPitchAndFamily = ptm->tmPitchAndFamily;
2679 pelf->elfLogFont.lfPitchAndFamily = (ptm->tmPitchAndFamily & 0xf1) + 1;
2680 pntm->ntmTm.tmCharSet = pelf->elfLogFont.lfCharSet = ptm->tmCharSet;
2681 pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
2682 pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
2683 pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
2684
2685 *ptype = ptm->tmPitchAndFamily & TMPF_TRUETYPE ? TRUETYPE_FONTTYPE : 0;
2686 if(!(ptm->tmPitchAndFamily & TMPF_VECTOR))
2687 *ptype |= RASTER_FONTTYPE;
2688
2689 pntm->ntmTm.ntmFlags = ptm->tmItalic ? NTM_ITALIC : 0;
2690 if(ptm->tmWeight > 550) pntm->ntmTm.ntmFlags |= NTM_BOLD;
2691 if(pntm->ntmTm.ntmFlags == 0) pntm->ntmTm.ntmFlags = NTM_REGULAR;
2692
2693 pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
2694 pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
2695 memset(&pntm->ntmFontSig, 0, sizeof(FONTSIGNATURE));
2696
2697 if(potm) {
2698 pntm->ntmTm.ntmSizeEM = potm->otmEMSquare;
2699
2700 lstrcpynW(pelf->elfLogFont.lfFaceName,
2701 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFamilyName),
2702 LF_FACESIZE);
2703 lstrcpynW(pelf->elfFullName,
2704 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFaceName),
2705 LF_FULLFACESIZE);
2706 lstrcpynW(pelf->elfStyle,
2707 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpStyleName),
2708 LF_FACESIZE);
2709
2710 HeapFree(GetProcessHeap(), 0, potm);
2711 } else {
2712 pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
2713
2714 lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
2715 lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FACESIZE);
2716 pelf->elfStyle[0] = '\0';
2717 }
2718
2719 pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
2720
2721 free_font(font);
2722 }
2723
2724 /*************************************************************
2725 * WineEngEnumFonts
2726 *
2727 */
2728 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
2729 {
2730 Family *family;
2731 Face *face;
2732 struct list *family_elem_ptr, *face_elem_ptr;
2733 ENUMLOGFONTEXW elf;
2734 NEWTEXTMETRICEXW ntm;
2735 DWORD type, ret = 1;
2736 FONTSIGNATURE fs;
2737 CHARSETINFO csi;
2738 LOGFONTW lf;
2739 int i;
2740
2741 TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
2742
2743 if(plf->lfFaceName[0]) {
2744 FontSubst *psub;
2745 psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
2746
2747 if(psub) {
2748 TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
2749 debugstr_w(psub->to.name));
2750 memcpy(&lf, plf, sizeof(lf));
2751 strcpyW(lf.lfFaceName, psub->to.name);
2752 plf = &lf;
2753 }
2754
2755 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2756 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2757 if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
2758 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2759 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2760 GetEnumStructs(face, &elf, &ntm, &type);
2761 for(i = 0; i < 32; i++) {
2762 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
2763 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
2764 strcpyW(elf.elfScript, OEM_DOSW);
2765 i = 32; /* break out of loop */
2766 } else if(!(face->fs.fsCsb[0] & (1L << i)))
2767 continue;
2768 else {
2769 fs.fsCsb[0] = 1L << i;
2770 fs.fsCsb[1] = 0;
2771 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
2772 TCI_SRCFONTSIG))
2773 csi.ciCharset = DEFAULT_CHARSET;
2774 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
2775 if(csi.ciCharset != DEFAULT_CHARSET) {
2776 elf.elfLogFont.lfCharSet =
2777 ntm.ntmTm.tmCharSet = csi.ciCharset;
2778 if(ElfScriptsW[i])
2779 strcpyW(elf.elfScript, ElfScriptsW[i]);
2780 else
2781 FIXME("Unknown elfscript for bit %d\n", i);
2782 }
2783 }
2784 TRACE("enuming face %s full %s style %s charset %d type %d script %s it %d weight %d ntmflags %08x\n",
2785 debugstr_w(elf.elfLogFont.lfFaceName),
2786 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
2787 csi.ciCharset, type, debugstr_w(elf.elfScript),
2788 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
2789 ntm.ntmTm.ntmFlags);
2790 ret = proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam);
2791 if(!ret) goto end;
2792 }
2793 }
2794 }
2795 }
2796 } else {
2797 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2798 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2799 face_elem_ptr = list_head(&family->faces);
2800 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2801 GetEnumStructs(face, &elf, &ntm, &type);
2802 for(i = 0; i < 32; i++) {
2803 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
2804 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
2805 strcpyW(elf.elfScript, OEM_DOSW);
2806 i = 32; /* break out of loop */
2807 } else if(!(face->fs.fsCsb[0] & (1L << i)))
2808 continue;
2809 else {
2810 fs.fsCsb[0] = 1L << i;
2811 fs.fsCsb[1] = 0;
2812 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
2813 TCI_SRCFONTSIG))
2814 csi.ciCharset = DEFAULT_CHARSET;
2815 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
2816 if(csi.ciCharset != DEFAULT_CHARSET) {
2817 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet =
2818 csi.ciCharset;
2819 if(ElfScriptsW[i])
2820 strcpyW(elf.elfScript, ElfScriptsW[i]);
2821 else
2822 FIXME("Unknown elfscript for bit %d\n", i);
2823 }
2824 }
2825 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
2826 debugstr_w(elf.elfLogFont.lfFaceName),
2827 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
2828 csi.ciCharset, type, debugstr_w(elf.elfScript),
2829 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
2830 ntm.ntmTm.ntmFlags);
2831 ret = proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam);
2832 if(!ret) goto end;
2833 }
2834 }
2835 }
2836 end:
2837 return ret;
2838 }
2839
2840 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
2841 {
2842 pt->x.value = vec->x >> 6;
2843 pt->x.fract = (vec->x & 0x3f) << 10;
2844 pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
2845 pt->y.value = vec->y >> 6;
2846 pt->y.fract = (vec->y & 0x3f) << 10;
2847 pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
2848 return;
2849 }
2850
2851 /***************************************************
2852 * According to the MSDN documentation on WideCharToMultiByte,
2853 * certain codepages cannot set the default_used parameter.
2854 * This returns TRUE if the codepage can set that parameter, false else
2855 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
2856 */
2857 static BOOL codepage_sets_default_used(UINT codepage)
2858 {
2859 switch (codepage)
2860 {
2861 case CP_UTF7:
2862 case CP_UTF8:
2863 case CP_SYMBOL:
2864 return FALSE;
2865 default:
2866 return TRUE;
2867 }
2868 }
2869
2870 static FT_UInt get_glyph_index(GdiFont *font, UINT glyph)
2871 {
2872 if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
2873 WCHAR wc = (WCHAR)glyph;
2874 BOOL default_used;
2875 BOOL *default_used_pointer;
2876 FT_UInt ret;
2877 char buf;
2878 default_used_pointer = NULL;
2879 default_used = FALSE;
2880 if (codepage_sets_default_used(font->codepage))
2881 default_used_pointer = &default_used;
2882 if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
2883 ret = 0;
2884 else
2885 ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
2886 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
2887 return ret;
2888 }
2889
2890 if(font->charset == SYMBOL_CHARSET && glyph < 0x100)
2891 glyph = glyph + 0xf000;
2892 return pFT_Get_Char_Index(font->ft_face, glyph);
2893 }
2894
2895 /*************************************************************
2896 * WineEngGetGlyphIndices
2897 *
2898 * FIXME: add support for GGI_MARK_NONEXISTING_GLYPHS
2899 */
2900 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
2901 LPWORD pgi, DWORD flags)
2902 {
2903 int i;
2904 WCHAR default_char = 0;
2905 TEXTMETRICW textm;
2906
2907 if (flags & GGI_MARK_NONEXISTING_GLYPHS) default_char = 0x001f; /* Indicate non existence */
2908
2909 for(i = 0; i < count; i++)
2910 {
2911 pgi[i] = get_glyph_index(font, lpstr[i]);
2912 if (pgi[i] == 0)
2913 {
2914 if (!default_char)
2915 {
2916 WineEngGetTextMetrics(font, &textm);
2917 default_char = textm.tmDefaultChar;
2918 }
2919 pgi[i] = default_char;
2920 }
2921 }
2922 return count;
2923 }
2924
2925 /*************************************************************
2926 * WineEngGetGlyphOutline
2927 *
2928 * Behaves in exactly the same way as the win32 api GetGlyphOutline
2929 * except that the first parameter is the HWINEENGFONT of the font in
2930 * question rather than an HDC.
2931 *
2932 */
2933 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
2934 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
2935 const MAT2* lpmat)
2936 {
2937 static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
2938 FT_Face ft_face = font->ft_face;
2939 FT_UInt glyph_index;
2940 DWORD width, height, pitch, needed = 0;
2941 FT_Bitmap ft_bitmap;
2942 FT_Error err;
2943 INT left, right, top = 0, bottom = 0;
2944 FT_Angle angle = 0;
2945 FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
2946 float widthRatio = 1.0;
2947 FT_Matrix transMat = identityMat;
2948 BOOL needsTransform = FALSE;
2949
2950
2951 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
2952 buflen, buf, lpmat);
2953
2954 if(format & GGO_GLYPH_INDEX) {
2955 glyph_index = glyph;
2956 format &= ~GGO_GLYPH_INDEX;
2957 } else
2958 glyph_index = get_glyph_index(font, glyph);
2959
2960 if(glyph_index >= font->gmsize) {
2961 font->gmsize = (glyph_index / INIT_GM_SIZE + 1) * INIT_GM_SIZE;
2962 font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
2963 font->gmsize * sizeof(*font->gm));
2964 } else {
2965 if(format == GGO_METRICS && font->gm[glyph_index].init) {
2966 memcpy(lpgm, &font->gm[glyph_index].gm, sizeof(*lpgm));
2967 return 1; /* FIXME */
2968 }
2969 }
2970
2971 if(font->orientation || (format != GGO_METRICS && format != GGO_BITMAP) || font->aveWidth || lpmat)
2972 load_flags |= FT_LOAD_NO_BITMAP;
2973
2974 err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
2975
2976 if(err) {
2977 FIXME("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
2978 return GDI_ERROR;
2979 }
2980
2981 /* Scaling factor */
2982 if (font->aveWidth && font->potm) {
2983 widthRatio = (float)font->aveWidth * font->font_desc.matrix.eM11 / (float) font->potm->otmTextMetrics.tmAveCharWidth;
2984 }
2985
2986 left = (INT)(ft_face->glyph->metrics.horiBearingX * widthRatio) & -64;
2987 right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) * widthRatio + 63) & -64;
2988
2989 font->gm[glyph_index].adv = (INT)((ft_face->glyph->metrics.horiAdvance * widthRatio) + 63) >> 6;
2990 font->gm[glyph_index].lsb = left >> 6;
2991 font->gm[glyph_index].bbx = (right - left) >> 6;
2992
2993 /* Scaling transform */
2994 if(font->aveWidth) {
2995 FT_Matrix scaleMat;
2996 scaleMat.xx = FT_FixedFromFloat(widthRatio);
2997 scaleMat.xy = 0;
2998 scaleMat.yx = 0;
2999 scaleMat.yy = (1 << 16);
3000
3001 pFT_Matrix_Multiply(&scaleMat, &transMat);
3002 needsTransform = TRUE;
3003 }
3004
3005 /* Slant transform */
3006 if (font->fake_italic) {
3007 FT_Matrix slantMat;
3008
3009 slantMat.xx = (1 << 16);
3010 slantMat.xy = ((1 << 16) >> 2);
3011 slantMat.yx = 0;
3012 slantMat.yy = (1 << 16);
3013 pFT_Matrix_Multiply(&slantMat, &transMat);
3014 needsTransform = TRUE;
3015 }
3016
3017 /* Rotation transform */
3018 if(font->orientation) {
3019 FT_Matrix rotationMat;
3020 FT_Vector vecAngle;
3021 angle = FT_FixedFromFloat((float)font->orientation / 10.0);
3022 pFT_Vector_Unit(&vecAngle, angle);
3023 rotationMat.xx = vecAngle.x;
3024 rotationMat.xy = -vecAngle.y;
3025 rotationMat.yx = -rotationMat.xy;
3026 rotationMat.yy = rotationMat.xx;
3027
3028 pFT_Matrix_Multiply(&rotationMat, &transMat);
3029 needsTransform = TRUE;
3030 }
3031
3032 /* Extra transformation specified by caller */
3033 if (lpmat) {
3034 FT_Matrix extraMat;
3035 extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
3036 extraMat.xy = FT_FixedFromFIXED(lpmat->eM21);
3037 extraMat.yx = FT_FixedFromFIXED(lpmat->eM12);
3038 extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
3039 pFT_Matrix_Multiply(&extraMat, &transMat);
3040 needsTransform = TRUE;
3041 }
3042
3043 if(!needsTransform) {
3044 top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
3045 bottom = (ft_face->glyph->metrics.horiBearingY -
3046 ft_face->glyph->metrics.height) & -64;
3047 lpgm->gmCellIncX = font->gm[glyph_index].adv;
3048 lpgm->gmCellIncY = 0;
3049 } else {
3050 INT xc, yc;
3051 FT_Vector vec;
3052 for(xc = 0; xc < 2; xc++) {
3053 for(yc = 0; yc < 2; yc++) {
3054 vec.x = (ft_face->glyph->metrics.horiBearingX +
3055 xc * ft_face->glyph->metrics.width);
3056 vec.y = ft_face->glyph->metrics.horiBearingY -
3057 yc * ft_face->glyph->metrics.height;
3058 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
3059 pFT_Vector_Transform(&vec, &transMat);
3060 if(xc == 0 && yc == 0) {
3061 left = right = vec.x;
3062 top = bottom = vec.y;
3063 } else {
3064 if(vec.x < left) left = vec.x;
3065 else if(vec.x > right) right = vec.x;
3066 if(vec.y < bottom) bottom = vec.y;
3067 else if(vec.y > top) top = vec.y;
3068 }
3069 }
3070 }
3071 left = left & -64;
3072 right = (right + 63) & -64;
3073 bottom = bottom & -64;
3074 top = (top + 63) & -64;
3075
3076 TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
3077 vec.x = ft_face->glyph->metrics.horiAdvance;
3078 vec.y = 0;
3079 pFT_Vector_Transform(&vec, &transMat);
3080 lpgm->gmCellIncX = (vec.x+63) >> 6;
3081 lpgm->gmCellIncY = -((vec.y+63) >> 6);
3082 }
3083 lpgm->gmBlackBoxX = (right - left) >> 6;
3084 lpgm->gmBlackBoxY = (top - bottom) >> 6;
3085 lpgm->gmptGlyphOrigin.x = left >> 6;
3086 lpgm->gmptGlyphOrigin.y = top >> 6;
3087
3088 memcpy(&font->gm[glyph_index].gm, lpgm, sizeof(*lpgm));
3089 font->gm[glyph_index].init = TRUE;
3090
3091 if(format == GGO_METRICS)
3092 return 1; /* FIXME */
3093
3094 if(ft_face->glyph->format != ft_glyph_format_outline && format != GGO_BITMAP) {
3095 TRACE("loaded a bitmap\n");
3096 return GDI_ERROR;
3097 }
3098
3099 switch(format) {
3100 case GGO_BITMAP:
3101 width = lpgm->gmBlackBoxX;
3102 height = lpgm->gmBlackBoxY;
3103 pitch = ((width + 31) >> 5) << 2;
3104 needed = pitch * height;
3105
3106 if(!buf || !buflen) break;
3107
3108 switch(ft_face->glyph->format) {
3109 case ft_glyph_format_bitmap:
3110 {
3111 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
3112 INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
3113 INT h = ft_face->glyph->bitmap.rows;
3114 while(h--) {
3115 memcpy(dst, src, w);
3116 src += ft_face->glyph->bitmap.pitch;
3117 dst += pitch;
3118 }
3119 break;
3120 }
3121
3122 case ft_glyph_format_outline:
3123 ft_bitmap.width = width;
3124 ft_bitmap.rows = height;
3125 ft_bitmap.pitch = pitch;
3126 ft_bitmap.pixel_mode = ft_pixel_mode_mono;
3127 ft_bitmap.buffer = buf;
3128
3129 if(needsTransform) {
3130 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
3131 }
3132
3133 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
3134
3135 /* Note: FreeType will only set 'black' bits for us. */
3136 memset(buf, 0, needed);
3137 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
3138 break;
3139
3140 default:
3141 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
3142 return GDI_ERROR;
3143 }
3144 break;
3145
3146 case GGO_GRAY2_BITMAP:
3147 case GGO_GRAY4_BITMAP:
3148 case GGO_GRAY8_BITMAP:
3149 case WINE_GGO_GRAY16_BITMAP:
3150 {
3151 unsigned int mult, row, col;
3152 BYTE *start, *ptr;
3153
3154 width = lpgm->gmBlackBoxX;
3155 height = lpgm->gmBlackBoxY;
3156 pitch = (width + 3) / 4 * 4;
3157 needed = pitch * height;
3158
3159 if(!buf || !buflen) break;
3160 ft_bitmap.width = width;
3161 ft_bitmap.rows = height;
3162 ft_bitmap.pitch = pitch;
3163 ft_bitmap.pixel_mode = ft_pixel_mode_grays;
3164 ft_bitmap.buffer = buf;
3165
3166 if(needsTransform) {
3167 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
3168 }
3169
3170 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
3171
3172 memset(ft_bitmap.buffer, 0, buflen);
3173
3174 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
3175
3176 if(format == GGO_GRAY2_BITMAP)
3177 mult = 4;
3178 else if(format == GGO_GRAY4_BITMAP)
3179 mult = 16;
3180 else if(format == GGO_GRAY8_BITMAP)
3181 mult = 64;
3182 else if(format == WINE_GGO_GRAY16_BITMAP)
3183 break;
3184 else {
3185 assert(0);
3186 break;
3187 }
3188
3189 start = buf;
3190 for(row = 0; row < height; row++) {
3191 ptr = start;
3192 for(col = 0; col < width; col++, ptr++) {
3193 *ptr = (((int)*ptr) * mult + 128) / 256;
3194 }
3195 start += pitch;
3196 }
3197 break;
3198 }
3199
3200 case GGO_NATIVE:
3201 {
3202 int contour, point = 0, first_pt;
3203 FT_Outline *outline = &ft_face->glyph->outline;
3204 TTPOLYGONHEADER *pph;
3205 TTPOLYCURVE *ppc;
3206 DWORD pph_start, cpfx, type;
3207
3208 if(buflen == 0) buf = NULL;
3209
3210 if (needsTransform && buf) {
3211 pFT_Outline_Transform(outline, &transMat);
3212 }
3213
3214 for(contour = 0; contour < outline->n_contours; contour++) {
3215 pph_start = needed;
3216 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
3217 first_pt = point;
3218 if(buf) {
3219 pph->dwType = TT_POLYGON_TYPE;
3220 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
3221 }
3222 needed += sizeof(*pph);
3223 point++;
3224 while(point <= outline->contours[contour]) {
3225 ppc = (TTPOLYCURVE *)((char *)buf + needed);
3226 type = (outline->tags[point] & FT_Curve_Tag_On) ?
3227 TT_PRIM_LINE : TT_PRIM_QSPLINE;
3228 cpfx = 0;
3229 do {
3230 if(buf)
3231 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3232 cpfx++;
3233 point++;
3234 } while(point <= outline->contours[contour] &&
3235 (outline->tags[point] & FT_Curve_Tag_On) ==
3236 (outline->tags[point-1] & FT_Curve_Tag_On));
3237 /* At the end of a contour Windows adds the start point, but
3238 only for Beziers */
3239 if(point > outline->contours[contour] &&
3240 !(outline->tags[point-1] & FT_Curve_Tag_On)) {
3241 if(buf)
3242 FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
3243 cpfx++;
3244 } else if(point <= outline->contours[contour] &&
3245 outline->tags[point] & FT_Curve_Tag_On) {
3246 /* add closing pt for bezier */
3247 if(buf)
3248 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3249 cpfx++;
3250 point++;
3251 }
3252 if(buf) {
3253 ppc->wType = type;
3254 ppc->cpfx = cpfx;
3255 }
3256 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
3257 }
3258 if(buf)
3259 pph->cb = needed - pph_start;
3260 }
3261 break;
3262 }
3263 case GGO_BEZIER:
3264 {
3265 /* Convert the quadratic Beziers to cubic Beziers.
3266 The parametric eqn for a cubic Bezier is, from PLRM:
3267 r(t) = at^3 + bt^2 + ct + r0
3268 with the control points:
3269 r1 = r0 + c/3
3270 r2 = r1 + (c + b)/3
3271 r3 = r0 + c + b + a
3272
3273 A quadratic Beizer has the form:
3274 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
3275
3276 So equating powers of t leads to:
3277 r1 = 2/3 p1 + 1/3 p0
3278 r2 = 2/3 p1 + 1/3 p2
3279 and of course r0 = p0, r3 = p2
3280 */
3281
3282 int contour, point = 0, first_pt;
3283 FT_Outline *outline = &ft_face->glyph->outline;
3284 TTPOLYGONHEADER *pph;
3285 TTPOLYCURVE *ppc;
3286 DWORD pph_start, cpfx, type;
3287 FT_Vector cubic_control[4];
3288 if(buflen == 0) buf = NULL;
3289
3290 if (needsTransform && buf) {
3291 pFT_Outline_Transform(outline, &transMat);
3292 }
3293
3294 for(contour = 0; contour < outline->n_contours; contour++) {
3295 pph_start = needed;
3296 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
3297 first_pt = point;
3298 if(buf) {
3299 pph->dwType = TT_POLYGON_TYPE;
3300 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
3301 }
3302 needed += sizeof(*pph);
3303 point++;
3304 while(point <= outline->contours[contour]) {
3305 ppc = (TTPOLYCURVE *)((char *)buf + needed);
3306 type = (outline->tags[point] & FT_Curve_Tag_On) ?
3307 TT_PRIM_LINE : TT_PRIM_CSPLINE;
3308 cpfx = 0;
3309 do {
3310 if(type == TT_PRIM_LINE) {
3311 if(buf)
3312 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3313 cpfx++;
3314 point++;
3315 } else {
3316 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
3317 so cpfx = 3n */
3318
3319 /* FIXME: Possible optimization in endpoint calculation
3320 if there are two consecutive curves */
3321 cubic_control[0] = outline->points[point-1];
3322 if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
3323 cubic_control[0].x += outline->points[point].x + 1;
3324 cubic_control[0].y += outline->points[point].y + 1;
3325 cubic_control[0].x >>= 1;
3326 cubic_control[0].y >>= 1;
3327 }
3328 if(point+1 > outline->contours[contour])
3329 cubic_control[3] = outline->points[first_pt];
3330 else {
3331 cubic_control[3] = outline->points[point+1];
3332 if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
3333 cubic_control[3].x += outline->points[point].x + 1;
3334 cubic_control[3].y += outline->points[point].y + 1;
3335 cubic_control[3].x >>= 1;
3336 cubic_control[3].y >>= 1;
3337 }
3338 }
3339 /* r1 = 1/3 p0 + 2/3 p1
3340 r2 = 1/3 p2 + 2/3 p1 */
3341 cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
3342 cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
3343 cubic_control[2] = cubic_control[1];
3344 cubic_control[1].x += (cubic_control[0].x + 1) / 3;
3345 cubic_control[1].y += (cubic_control[0].y + 1) / 3;
3346 cubic_control[2].x += (cubic_control[3].x + 1) / 3;
3347 cubic_control[2].y += (cubic_control[3].y + 1) / 3;
3348 if(buf) {
3349 FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
3350 FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
3351 FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
3352 }
3353 cpfx += 3;
3354 point++;
3355 }
3356 } while(point <= outline->contours[contour] &&
3357 (outline->tags[point] & FT_Curve_Tag_On) ==
3358 (outline->tags[point-1] & FT_Curve_Tag_On));
3359 /* At the end of a contour Windows adds the start point,
3360 but only for Beziers and we've already done that.
3361 */
3362 if(point <= outline->contours[contour] &&
3363 outline->tags[point] & FT_Curve_Tag_On) {
3364 /* This is the closing pt of a bezier, but we've already
3365 added it, so just inc point and carry on */
3366 point++;
3367 }
3368 if(buf) {
3369 ppc->wType = type;
3370 ppc->cpfx = cpfx;
3371 }
3372 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
3373 }
3374 if(buf)
3375 pph->cb = needed - pph_start;
3376 }
3377 break;
3378 }
3379
3380 default:
3381 FIXME("Unsupported format %d\n", format);
3382 return GDI_ERROR;
3383 }
3384 return needed;
3385 }
3386
3387 static BOOL get_bitmap_text_metrics(GdiFont *font)
3388 {
3389 FT_Face ft_face = font->ft_face;
3390 #ifdef HAVE_FREETYPE_FTWINFNT_H
3391 FT_WinFNT_HeaderRec winfnt_header;
3392 #endif
3393 const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
3394 font->potm = HeapAlloc(GetProcessHeap(), 0, size);
3395 font->potm->otmSize = size;
3396
3397 #define TM font->potm->otmTextMetrics
3398 #ifdef HAVE_FREETYPE_FTWINFNT_H
3399 if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
3400 {
3401 TM.tmHeight = winfnt_header.pixel_height;
3402 TM.tmAscent = winfnt_header.ascent;
3403 TM.tmDescent = TM.tmHeight - TM.tmAscent;
3404 TM.tmInternalLeading = winfnt_header.internal_leading;
3405 TM.tmExternalLeading = winfnt_header.external_leading;
3406 TM.tmAveCharWidth = winfnt_header.avg_width;
3407 TM.tmMaxCharWidth = winfnt_header.max_width;
3408 TM.tmWeight = winfnt_header.weight;
3409 TM.tmOverhang = 0;
3410 TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
3411 TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
3412 TM.tmFirstChar = winfnt_header.first_char;
3413 TM.tmLastChar = winfnt_header.last_char;
3414 TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
3415 TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
3416 TM.tmItalic = winfnt_header.italic;
3417 TM.tmUnderlined = font->underline;
3418 TM.tmStruckOut = font->strikeout;
3419 TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
3420 TM.tmCharSet = winfnt_header.charset;
3421 }
3422 else
3423 #endif
3424 {
3425 TM.tmAscent = ft_face->size->metrics.ascender >> 6;
3426 TM.tmDescent = -ft_face->size->metrics.descender >> 6;
3427 TM.tmHeight = TM.tmAscent + TM.tmDescent;
3428 TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
3429 TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
3430 TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
3431 TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
3432 TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
3433 TM.tmOverhang = 0;
3434 TM.tmDigitizedAspectX = 96; /* FIXME */
3435 TM.tmDigitizedAspectY = 96; /* FIXME */
3436 TM.tmFirstChar = 1;
3437 TM.tmLastChar = 255;
3438 TM.tmDefaultChar = 32;
3439 TM.tmBreakChar = 32;
3440 TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
3441 TM.tmUnderlined = font->underline;
3442 TM.tmStruckOut = font->strikeout;
3443 /* NB inverted meaning of TMPF_FIXED_PITCH */
3444 TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
3445 TM.tmCharSet = font->charset;
3446 }
3447 #undef TM
3448
3449 return TRUE;
3450 }
3451
3452 /*************************************************************
3453 * WineEngGetTextMetrics
3454 *
3455 */
3456 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
3457 {
3458 if(!font->potm) {
3459 if(!WineEngGetOutlineTextMetrics(font, 0, NULL))
3460 if(!get_bitmap_text_metrics(font))
3461 return FALSE;
3462 }
3463 if(!font->potm) return FALSE;
3464 memcpy(ptm, &font->potm->otmTextMetrics, sizeof(*ptm));
3465
3466 if (font->aveWidth) {
3467 ptm->tmAveCharWidth = font->aveWidth * font->font_desc.matrix.eM11;
3468 }
3469 return TRUE;
3470 }
3471
3472
3473 /*************************************************************
3474 * WineEngGetOutlineTextMetrics
3475 *
3476 */
3477 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
3478 OUTLINETEXTMETRICW *potm)
3479 {
3480 FT_Face ft_face = font->ft_face;
3481 UINT needed, lenfam, lensty, ret;
3482 TT_OS2 *pOS2;
3483 TT_HoriHeader *pHori;
3484 TT_Postscript *pPost;
3485 FT_Fixed x_scale, y_scale;
3486 WCHAR *family_nameW, *style_nameW;
3487 static const WCHAR spaceW[] = {' ', '\0'};
3488 char *cp;
3489 INT ascent, descent;
3490
3491 TRACE("font=%p\n", font);
3492
3493 if(!FT_IS_SCALABLE(ft_face))
3494 return 0;
3495
3496 if(font->potm) {
3497 if(cbSize >= font->potm->otmSize)
3498 memcpy(potm, font->potm, font->potm->otmSize);
3499 return font->potm->otmSize;
3500 }
3501
3502
3503 needed = sizeof(*potm);
3504
3505 lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
3506 family_nameW = strdupW(font->name);
3507
3508 lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
3509 * sizeof(WCHAR);
3510 style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
3511 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
3512 style_nameW, lensty/sizeof(WCHAR));
3513
3514 /* These names should be read from the TT name table */
3515
3516 /* length of otmpFamilyName */
3517 needed += lenfam;
3518
3519 /* length of otmpFaceName */
3520 if(!strcasecmp(ft_face->style_name, "regular")) {
3521 needed += lenfam; /* just the family name */
3522 } else {
3523 needed += lenfam + lensty; /* family + " " + style */
3524 }
3525
3526 /* length of otmpStyleName */
3527 needed += lensty;
3528
3529 /* length of otmpFullName */
3530 needed += lenfam + lensty;
3531
3532
3533 x_scale = ft_face->size->metrics.x_scale;
3534 y_scale = ft_face->size->metrics.y_scale;
3535
3536 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
3537 if(!pOS2) {
3538 FIXME("Can't find OS/2 table - not TT font?\n");
3539 ret = 0;
3540 goto end;
3541 }
3542
3543 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
3544 if(!pHori) {
3545 FIXME("Can't find HHEA table - not TT font?\n");
3546 ret = 0;
3547 goto end;
3548 }
3549
3550 pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
3551
3552 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",
3553 pOS2->usWinAscent, pOS2->usWinDescent,
3554 pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
3555 ft_face->ascender, ft_face->descender, ft_face->height,
3556 pHori->Ascender, pHori->Descender, pHori->Line_Gap,
3557 ft_face->bbox.yMax, ft_face->bbox.yMin);
3558
3559 font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
3560 font->potm->otmSize = needed;
3561
3562 #define TM font->potm->otmTextMetrics
3563
3564 if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
3565 ascent = pHori->Ascender;
3566 descent = -pHori->Descender;
3567 } else {
3568 ascent = pOS2->usWinAscent;
3569 descent = pOS2->usWinDescent;
3570 }
3571
3572 if(font->yMax) {
3573 TM.tmAscent = font->yMax;
3574 TM.tmDescent = -font->yMin;
3575 TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
3576 } else {
3577 TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
3578 TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
3579 TM.tmInternalLeading = (pFT_MulFix(ascent + descent
3580 - ft_face->units_per_EM, y_scale) + 32) >> 6;
3581 }
3582
3583 TM.tmHeight = TM.tmAscent + TM.tmDescent;
3584
3585 /* MSDN says:
3586 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
3587 */
3588 TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
3589 ((ascent + descent) -
3590 (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
3591
3592 TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
3593 if (TM.tmAveCharWidth == 0) {
3594 TM.tmAveCharWidth = 1;
3595 }
3596 TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
3597 TM.tmWeight = font->fake_bold ? FW_BOLD : pOS2->usWeightClass;
3598 TM.tmOverhang = 0;
3599 TM.tmDigitizedAspectX = 300;
3600 TM.tmDigitizedAspectY = 300;
3601 TM.tmFirstChar = pOS2->usFirstCharIndex;
3602 TM.tmLastChar = pOS2->usLastCharIndex;
3603 TM.tmDefaultChar = pOS2->usDefaultChar;
3604 TM.tmBreakChar = pOS2->usBreakChar ? pOS2->usBreakChar : ' ';
3605 TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
3606 TM.tmUnderlined = font->underline;
3607 TM.tmStruckOut = font->strikeout;
3608
3609 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
3610 if(!FT_IS_FIXED_WIDTH(ft_face) &&
3611 (pOS2->version == 0xFFFFU ||
3612 pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
3613 TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
3614 else
3615 TM.tmPitchAndFamily = 0;
3616
3617 switch(pOS2->panose[PAN_FAMILYTYPE_INDEX]) {
3618 case PAN_FAMILY_SCRIPT:
3619 TM.tmPitchAndFamily |= FF_SCRIPT;
3620 break;
3621 case PAN_FAMILY_DECORATIVE:
3622 case PAN_FAMILY_PICTORIAL:
3623 TM.tmPitchAndFamily |= FF_DECORATIVE;
3624 break;
3625 case PAN_FAMILY_TEXT_DISPLAY:
3626 if(TM.tmPitchAndFamily == 0) /* fixed */
3627 TM.tmPitchAndFamily = FF_MODERN;
3628 else {
3629 switch(pOS2->panose[PAN_SERIFSTYLE_INDEX]) {
3630 case PAN_SERIF_NORMAL_SANS:
3631 case PAN_SERIF_OBTUSE_SANS:
3632 case PAN_SERIF_PERP_SANS:
3633 TM.tmPitchAndFamily |= FF_SWISS;
3634 break;
3635 default:
3636 TM.tmPitchAndFamily |= FF_ROMAN;
3637 }
3638 }
3639 break;
3640 default:
3641 TM.tmPitchAndFamily |= FF_DONTCARE;
3642 }
3643
3644 if(FT_IS_SCALABLE(ft_face))
3645 TM.tmPitchAndFamily |= TMPF_VECTOR;
3646 if(FT_IS_SFNT(ft_face))
3647 TM.tmPitchAndFamily |= TMPF_TRUETYPE;
3648
3649 TM.tmCharSet = font->charset;
3650 #undef TM
3651
3652 font->potm->otmFiller = 0;
3653 memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
3654 font->potm->otmfsSelection = pOS2->fsSelection;
3655 font->potm->otmfsType = pOS2->fsType;
3656 font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
3657 font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
3658 font->potm->otmItalicAngle = 0; /* POST table */
3659 font->potm->otmEMSquare = ft_face->units_per_EM;
3660 font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
3661 font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
3662 font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
3663 font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
3664 font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
3665 font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
3666 font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
3667 font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
3668 font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
3669 font->potm->otmMacAscent = 0; /* where do these come from ? */
3670 font->potm->otmMacDescent = 0;
3671 font->potm->otmMacLineGap = 0;
3672 font->potm->otmusMinimumPPEM = 0; /* TT Header */
3673 font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
3674 font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
3675 font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
3676 font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
3677 font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
3678 font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
3679 font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
3680 font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
3681 font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
3682 font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
3683 if(!pPost) {
3684 font->potm->otmsUnderscoreSize = 0;
3685 font->potm->otmsUnderscorePosition = 0;
3686 } else {
3687 font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
3688 font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
3689 }
3690
3691 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
3692 cp = (char*)font->potm + sizeof(*font->potm);
3693 font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
3694 strcpyW((WCHAR*)cp, family_nameW);
3695 cp += lenfam;
3696 font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
3697 strcpyW((WCHAR*)cp, style_nameW);
3698 cp += lensty;
3699 font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
3700 strcpyW((WCHAR*)cp, family_nameW);
3701 if(strcasecmp(ft_face->style_name, "regular")) {
3702 strcatW((WCHAR*)cp, spaceW);
3703 strcatW((WCHAR*)cp, style_nameW);
3704 cp += lenfam + lensty;
3705 } else
3706 cp += lenfam;
3707 font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
3708 strcpyW((WCHAR*)cp, family_nameW);
3709 strcatW((WCHAR*)cp, spaceW);
3710 strcatW((WCHAR*)cp, style_nameW);
3711 ret = needed;
3712
3713 if(potm && needed <= cbSize)
3714 memcpy(potm, font->potm, font->potm->otmSize);
3715
3716 end:
3717 HeapFree(GetProcessHeap(), 0, style_nameW);
3718 HeapFree(GetProcessHeap(), 0, family_nameW);
3719
3720 return ret;
3721 }
3722
3723 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
3724 {
3725 HFONTLIST *hfontlist;
3726 child->font = alloc_font();
3727 child->font->ft_face = OpenFontFile(child->font, child->file_name, child->index, 0, -font->ppem);
3728 if(!child->font->ft_face)
3729 {
3730 free_font(child->font);
3731 child->font = NULL;
3732 return FALSE;
3733 }
3734
3735 child->font->orientation = font->orientation;
3736 hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
3737 hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
3738 list_add_head(&child->font->hfontlist, &hfontlist->entry);
3739 child->font->base_font = font;
3740 list_add_head(&child_font_list, &child->font->entry);
3741 TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
3742 return TRUE;
3743 }
3744
3745 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
3746 {
3747 FT_UInt g;
3748 CHILD_FONT *child_font;
3749
3750 if(font->base_font)
3751 font = font->base_font;
3752
3753 *linked_font = font;
3754
3755 if((*glyph = get_glyph_index(font, c)))
3756 return TRUE;
3757
3758 LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
3759 {
3760 if(!child_font->font)
3761 if(!load_child_font(font, child_font))
3762 continue;
3763
3764 if(!child_font->font->ft_face)
3765 continue;
3766 g = get_glyph_index(child_font->font, c);
3767 if(g)
3768 {
3769 *glyph = g;
3770 *linked_font = child_font->font;
3771 return TRUE;
3772 }
3773 }
3774 return FALSE;
3775 }
3776
3777 /*************************************************************
3778 * WineEngGetCharWidth
3779 *
3780 */
3781 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
3782 LPINT buffer)
3783 {
3784 UINT c;
3785 GLYPHMETRICS gm;
3786 FT_UInt glyph_index;
3787 GdiFont *linked_font;
3788
3789 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
3790
3791 for(c = firstChar; c <= lastChar; c++) {
3792 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
3793 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
3794 &gm, 0, NULL, NULL);
3795 buffer[c - firstChar] = linked_font->gm[glyph_index].adv;
3796 }
3797 return TRUE;
3798 }
3799
3800 /*************************************************************
3801 * WineEngGetCharABCWidths
3802 *
3803 */
3804 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
3805 LPABC buffer)
3806 {
3807 UINT c;
3808 GLYPHMETRICS gm;
3809 FT_UInt glyph_index;
3810 GdiFont *linked_font;
3811
3812 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
3813
3814 if(!FT_IS_SCALABLE(font->ft_face))
3815 return FALSE;
3816
3817 for(c = firstChar; c <= lastChar; c++) {
3818 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
3819 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
3820 &gm, 0, NULL, NULL);
3821 buffer[c - firstChar].abcA = linked_font->gm[glyph_index].lsb;
3822 buffer[c - firstChar].abcB = linked_font->gm[glyph_index].bbx;
3823 buffer[c - firstChar].abcC = linked_font->gm[glyph_index].adv - linked_font->gm[glyph_index].lsb -
3824 linked_font->gm[glyph_index].bbx;
3825 }
3826 return TRUE;
3827 }
3828
3829 /*************************************************************
3830 * WineEngGetCharABCWidthsI
3831 *
3832 */
3833 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
3834 LPABC buffer)
3835 {
3836 UINT c;
3837 GLYPHMETRICS gm;
3838 FT_UInt glyph_index;
3839 GdiFont *linked_font;
3840
3841 if(!FT_IS_SCALABLE(font->ft_face))
3842 return FALSE;
3843
3844 get_glyph_index_linked(font, 'a', &linked_font, &glyph_index);
3845 if (!pgi)
3846 for(c = firstChar; c < firstChar+count; c++) {
3847 WineEngGetGlyphOutline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
3848 &gm, 0, NULL, NULL);
3849 buffer[c - firstChar].abcA = linked_font->gm[c].lsb;
3850 buffer[c - firstChar].abcB = linked_font->gm[c].bbx;
3851 buffer[c - firstChar].abcC = linked_font->gm[c].adv - linked_font->gm[c].lsb
3852 - linked_font->gm[c].bbx;
3853 }
3854 else
3855 for(c = 0; c < count; c++) {
3856 WineEngGetGlyphOutline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
3857 &gm, 0, NULL, NULL);
3858 buffer[c].abcA = linked_font->gm[pgi[c]].lsb;
3859 buffer[c].abcB = linked_font->gm[pgi[c]].bbx;
3860 buffer[c].abcC = linked_font->gm[pgi[c]].adv
3861 - linked_font->gm[pgi[c]].lsb - linked_font->gm[pgi[c]].bbx;
3862 }
3863
3864 return TRUE;
3865 }
3866
3867 /*************************************************************
3868 * WineEngGetTextExtentExPoint
3869 *
3870 */
3871 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
3872 INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
3873 {
3874 INT idx;
3875 INT nfit = 0, ext;
3876 GLYPHMETRICS gm;
3877 TEXTMETRICW tm;
3878 FT_UInt glyph_index;
3879 GdiFont *linked_font;
3880
3881 TRACE("%p, %s, %d, %d, %p\n", font, debugstr_wn(wstr, count), count,
3882 max_ext, size);
3883
3884 size->cx = 0;
3885 WineEngGetTextMetrics(font, &tm);
3886 size->cy = tm.tmHeight;
3887
3888 for(idx = 0; idx < count; idx++) {
3889 get_glyph_index_linked(font, wstr[idx], &linked_font, &glyph_index);
3890 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
3891 &gm, 0, NULL, NULL);
3892 size->cx += linked_font->gm[glyph_index].adv;
3893 ext = size->cx;
3894 if (! pnfit || ext <= max_ext) {
3895 ++nfit;
3896 if (dxs)
3897 dxs[idx] = ext;
3898 }
3899 }
3900
3901 if (pnfit)
3902 *pnfit = nfit;
3903
3904 TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
3905 return TRUE;
3906 }
3907
3908 /*************************************************************
3909 * WineEngGetTextExtentPointI
3910 *
3911 */
3912 BOOL WineEngGetTextExtentPointI(GdiFont *font, const WORD *indices, INT count,
3913 LPSIZE size)
3914 {
3915 INT idx;
3916 GLYPHMETRICS gm;
3917 TEXTMETRICW tm;
3918
3919 TRACE("%p, %p, %d, %p\n", font, indices, count, size);
3920
3921 size->cx = 0;
3922 WineEngGetTextMetrics(font, &tm);
3923 size->cy = tm.tmHeight;
3924
3925 for(idx = 0; idx < count; idx++) {
3926 WineEngGetGlyphOutline(font, indices[idx],
3927 GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL,
3928 NULL);
3929 size->cx += font->gm[indices[idx]].adv;
3930 }
3931 TRACE("return %d,%d\n", size->cx, size->cy);
3932 return TRUE;
3933 }
3934
3935 /*************************************************************
3936 * WineEngGetFontData
3937 *
3938 */
3939 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
3940 DWORD cbData)
3941 {
3942 FT_Face ft_face = font->ft_face;
3943 FT_ULong len;
3944 FT_Error err;
3945
3946 TRACE("font=%p, table=%08x, offset=%08x, buf=%p, cbData=%x\n",
3947 font, table, offset, buf, cbData);
3948
3949 if(!FT_IS_SFNT(ft_face))
3950 return GDI_ERROR;
3951
3952 if(!buf || !cbData)
3953 len = 0;
3954 else
3955 len = cbData;
3956
3957 if(table) { /* MS tags differ in endidness from FT ones */
3958 table = table >> 24 | table << 24 |
3959 (table >> 8 & 0xff00) | (table << 8 & 0xff0000);
3960 }
3961
3962 /* If the FT_Load_Sfnt_Table function is there we'll use it */
3963 if(pFT_Load_Sfnt_Table) {
3964 /* make sure value of len is the value freetype says it needs */
3965 if( buf && len) {
3966 FT_ULong needed = 0;
3967 err = pFT_Load_Sfnt_Table(ft_face, table, offset, NULL, &needed);
3968 if( !err && needed < len) len = needed;
3969 }
3970 err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, &len);
3971 }
3972 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
3973 else { /* Do it the hard way */
3974 TT_Face tt_face = (TT_Face) ft_face;
3975 SFNT_Interface *sfnt;
3976 if (FT_Version.major==2 && FT_Version.minor==0)
3977 {
3978 /* 2.0.x */
3979 sfnt = *(SFNT_Interface**)((char*)tt_face + 528);
3980 }
3981 else
3982 {
3983 /* A field was added in the middle of the structure in 2.1.x */
3984 sfnt = *(SFNT_Interface**)((char*)tt_face + 532);
3985 }
3986 /* make sure value of len is the value freetype says it needs */
3987 if( buf && len) {
3988 FT_ULong needed = 0;
3989 err = sfnt->load_any(tt_face, table, offset, NULL, &needed);
3990 if( !err && needed < len) len = needed;
3991 }
3992 err = sfnt->load_any(tt_face, table, offset, buf, &len);
3993 }
3994 #else
3995 else {
3996 static int msg;
3997 if(!msg) {
3998 MESSAGE("This version of Wine was compiled with freetype headers later than 2.2.0\n"
3999 "but is being run with a freetype library without the FT_Load_Sfnt_Table function.\n"
4000 "Please upgrade your freetype library.\n");
4001 msg++;
4002 }
4003 err = FT_Err_Unimplemented_Feature;
4004 }
4005 #endif
4006 if(err) {
4007 TRACE("Can't find table %08x.\n", table);
4008 return GDI_ERROR;
4009 }
4010 return len;
4011 }
4012
4013 /*************************************************************
4014 * WineEngGetTextFace
4015 *
4016 */
4017 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
4018 {
4019 if(str) {
4020 lstrcpynW(str, font->name, count);
4021 return strlenW(font->name);
4022 } else
4023 return strlenW(font->name) + 1;
4024 }
4025
4026 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
4027 {
4028 if (fs) memcpy(fs, &font->fs, sizeof(FONTSIGNATURE));
4029 return font->charset;
4030 }
4031
4032 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
4033 {
4034 GdiFont *font = dc->gdiFont, *linked_font;
4035 struct list *first_hfont;
4036 BOOL ret;
4037
4038 ret = get_glyph_index_linked(font, c, &linked_font, glyph);
4039 TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
4040 if(font == linked_font)
4041 *new_hfont = dc->hFont;
4042 else
4043 {
4044 first_hfont = list_head(&linked_font->hfontlist);
4045 *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
4046 }
4047
4048 return ret;
4049 }
4050
4051
4052 /*************************************************************
4053 * FontIsLinked
4054 */
4055 BOOL WINAPI FontIsLinked(HDC hdc)
4056 {
4057 DC *dc = DC_GetDCPtr(hdc);
4058 BOOL ret = FALSE;
4059
4060 if(!dc) return FALSE;
4061 if(dc->gdiFont && !list_empty(&dc->gdiFont->child_fonts))
4062 ret = TRUE;
4063 GDI_ReleaseObj(hdc);
4064 TRACE("returning %d\n", ret);
4065 return ret;
4066 }
4067
4068 static BOOL is_hinting_enabled(void)
4069 {
4070 /* Use the >= 2.2.0 function if available */
4071 if(pFT_Get_TrueType_Engine_Type)
4072 {
4073 FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
4074 return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
4075 }
4076 #ifdef FT_DRIVER_HAS_HINTER
4077 else
4078 {
4079 FT_Module mod;
4080
4081 /* otherwise if we've been compiled with < 2.2.0 headers
4082 use the internal macro */
4083 mod = pFT_Get_Module(library, "truetype");
4084 if(mod && FT_DRIVER_HAS_HINTER(mod))
4085 return TRUE;
4086 }
4087 #endif
4088
4089 return FALSE;
4090 }
4091
4092 /*************************************************************************
4093 * GetRasterizerCaps (GDI32.@)
4094 */
4095 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
4096 {
4097 static int hinting = -1;
4098
4099 if(hinting == -1)
4100 hinting = is_hinting_enabled();
4101
4102 lprs->nSize = sizeof(RASTERIZER_STATUS);
4103 lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
4104 lprs->nLanguageID = 0;
4105 return TRUE;
4106 }
4107
4108 /*************************************************************************
4109 * Kerning support for TrueType fonts
4110 */
4111 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
4112
4113 struct TT_kern_table
4114 {
4115 USHORT version;
4116 USHORT nTables;
4117 };
4118
4119 struct TT_kern_subtable
4120 {
4121 USHORT version;
4122 USHORT length;
4123 union
4124 {
4125 USHORT word;
4126 struct
4127 {
4128 USHORT horizontal : 1;
4129 USHORT minimum : 1;
4130 USHORT cross_stream: 1;
4131 USHORT override : 1;
4132 USHORT reserved1 : 4;
4133 USHORT format : 8;
4134 } bits;
4135 } coverage;
4136 };
4137
4138 struct TT_format0_kern_subtable
4139 {
4140 USHORT nPairs;
4141 USHORT searchRange;
4142 USHORT entrySelector;
4143 USHORT rangeShift;
4144 };
4145
4146 struct TT_kern_pair
4147 {
4148 USHORT left;
4149 USHORT right;
4150 short value;
4151 };
4152
4153 static DWORD parse_format0_kern_subtable(GdiFont *font,
4154 const struct TT_format0_kern_subtable *tt_f0_ks,
4155 const USHORT *glyph_to_char,
4156 KERNINGPAIR *kern_pair, DWORD cPairs)
4157 {
4158 USHORT i, nPairs;
4159 const struct TT_kern_pair *tt_kern_pair;
4160
4161 TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
4162
4163 nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
4164
4165 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
4166 nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
4167 GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
4168
4169 if (!kern_pair || !cPairs)
4170 return nPairs;
4171
4172 tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
4173
4174 nPairs = min(nPairs, cPairs);
4175
4176 for (i = 0; i < nPairs; i++)
4177 {
4178 kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
4179 kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
4180 /* this algorithm appears to better match what Windows does */
4181 kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
4182 if (kern_pair->iKernAmount < 0)
4183 {
4184 kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
4185 kern_pair->iKernAmount -= font->ppem;
4186 }
4187 else if (kern_pair->iKernAmount > 0)
4188 {
4189 kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
4190 kern_pair->iKernAmount += font->ppem;
4191 }
4192 kern_pair->iKernAmount /= font->ft_face->units_per_EM;
4193
4194 TRACE("left %u right %u value %d\n",
4195 kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
4196
4197 kern_pair++;
4198 }
4199 TRACE("copied %u entries\n", nPairs);
4200 return nPairs;
4201 }
4202
4203 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
4204 {
4205 DWORD length;
4206 void *buf;
4207 const struct TT_kern_table *tt_kern_table;
4208 const struct TT_kern_subtable *tt_kern_subtable;
4209 USHORT i, nTables;
4210 USHORT *glyph_to_char;
4211
4212 if (font->total_kern_pairs != (DWORD)-1)
4213 {
4214 if (cPairs && kern_pair)
4215 {
4216 cPairs = min(cPairs, font->total_kern_pairs);
4217 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
4218 return cPairs;
4219 }
4220 return font->total_kern_pairs;
4221 }
4222
4223 font->total_kern_pairs = 0;
4224
4225 length = WineEngGetFontData(font, MS_KERN_TAG, 0, NULL, 0);
4226
4227 if (length == GDI_ERROR)
4228 {
4229 TRACE("no kerning data in the font\n");
4230 return 0;
4231 }
4232
4233 buf = HeapAlloc(GetProcessHeap(), 0, length);
4234 if (!buf)
4235 {
4236 WARN("Out of memory\n");
4237 return 0;
4238 }
4239
4240 WineEngGetFontData(font, MS_KERN_TAG, 0, buf, length);
4241
4242 /* build a glyph index to char code map */
4243 glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
4244 if (!glyph_to_char)
4245 {
4246 WARN("Out of memory allocating a glyph index to char code map\n");
4247 HeapFree(GetProcessHeap(), 0, buf);
4248 return 0;
4249 }
4250
4251 if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
4252 {
4253 FT_UInt glyph_code;
4254 FT_ULong char_code;
4255
4256 glyph_code = 0;
4257 char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
4258
4259 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
4260 font->ft_face->num_glyphs, glyph_code, char_code);
4261
4262 while (glyph_code)
4263 {
4264 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
4265
4266 /* FIXME: This doesn't match what Windows does: it does some fancy
4267 * things with duplicate glyph index to char code mappings, while
4268 * we just avoid overriding existing entries.
4269 */
4270 if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
4271 glyph_to_char[glyph_code] = (USHORT)char_code;
4272
4273 char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
4274 }
4275 }
4276 else
4277 {
4278 ULONG n;
4279
4280 FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
4281 for (n = 0; n <= 65535; n++)
4282 glyph_to_char[n] = (USHORT)n;
4283 }
4284
4285 tt_kern_table = buf;
4286 nTables = GET_BE_WORD(tt_kern_table->nTables);
4287 TRACE("version %u, nTables %u\n",
4288 GET_BE_WORD(tt_kern_table->version), nTables);
4289
4290 tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
4291
4292 for (i = 0; i < nTables; i++)
4293 {
4294 struct TT_kern_subtable tt_kern_subtable_copy;
4295
4296 tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
4297 tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
4298 tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
4299
4300 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
4301 tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
4302 tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
4303
4304 /* According to the TrueType specification this is the only format
4305 * that will be properly interpreted by Windows and OS/2
4306 */
4307 if (tt_kern_subtable_copy.coverage.bits.format == 0)
4308 {
4309 DWORD new_chunk, old_total = font->total_kern_pairs;
4310
4311 new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
4312 glyph_to_char, NULL, 0);
4313 font->total_kern_pairs += new_chunk;
4314
4315 if (!font->kern_pairs)
4316 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
4317 font->total_kern_pairs * sizeof(*font->kern_pairs));
4318 else
4319 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
4320 font->total_kern_pairs * sizeof(*font->kern_pairs));
4321
4322 parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
4323 glyph_to_char, font->kern_pairs + old_total, new_chunk);
4324 }
4325 else
4326 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
4327
4328 tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
4329 }
4330
4331 HeapFree(GetProcessHeap(), 0, glyph_to_char);
4332 HeapFree(GetProcessHeap(), 0, buf);
4333
4334 if (cPairs && kern_pair)
4335 {
4336 cPairs = min(cPairs, font->total_kern_pairs);
4337 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
4338 return cPairs;
4339 }
4340 return font->total_kern_pairs;
4341 }
4342
4343 #else /* HAVE_FREETYPE */
4344
4345 /*************************************************************************/
4346
4347 BOOL WineEngInit(void)
4348 {
4349 return FALSE;
4350 }
4351 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
4352 {
4353 return NULL;
4354 }
4355 BOOL WineEngDestroyFontInstance(HFONT hfont)
4356 {
4357 return FALSE;
4358 }
4359
4360 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
4361 {
4362 return 1;
4363 }
4364
4365 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
4366 LPWORD pgi, DWORD flags)
4367 {
4368 return GDI_ERROR;
4369 }
4370
4371 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
4372 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
4373 const MAT2* lpmat)
4374 {
4375 ERR("called but we don't have FreeType\n");
4376 return GDI_ERROR;
4377 }
4378
4379 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
4380 {
4381 ERR("called but we don't have FreeType\n");
4382 return FALSE;
4383 }
4384
4385 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
4386 OUTLINETEXTMETRICW *potm)
4387 {
4388 ERR("called but we don't have FreeType\n");
4389 return 0;
4390 }
4391
4392 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
4393 LPINT buffer)
4394 {
4395 ERR("called but we don't have FreeType\n");
4396 return FALSE;
4397 }
4398
4399 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
4400 LPABC buffer)
4401 {
4402 ERR("called but we don't have FreeType\n");
4403 return FALSE;
4404 }
4405
4406 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
4407 LPABC buffer)
4408 {
4409 ERR("called but we don't have FreeType\n");
4410 return FALSE;
4411 }
4412
4413 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
4414 INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
4415 {
4416 ERR("called but we don't have FreeType\n");
4417 return FALSE;
4418 }
4419
4420 BOOL WineEngGetTextExtentPointI(GdiFont *font, const WORD *indices, INT count,
4421 LPSIZE size)
4422 {
4423 ERR("called but we don't have FreeType\n");
4424 return FALSE;
4425 }
4426
4427 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
4428 DWORD cbData)
4429 {
4430 ERR("called but we don't have FreeType\n");
4431 return GDI_ERROR;
4432 }
4433
4434 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
4435 {
4436 ERR("called but we don't have FreeType\n");
4437 return 0;
4438 }
4439
4440 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
4441 {
4442 FIXME(":stub\n");
4443 return 1;
4444 }
4445
4446 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
4447 {
4448 FIXME(":stub\n");
4449 return TRUE;
4450 }
4451
4452 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
4453 {
4454 FIXME(":stub\n");
4455 return DEFAULT_CHARSET;
4456 }
4457
4458 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
4459 {
4460 return FALSE;
4461 }
4462
4463 BOOL WINAPI FontIsLinked(HDC hdc)
4464 {
4465 return FALSE;
4466 }
4467
4468 /*************************************************************************
4469 * GetRasterizerCaps (GDI32.@)
4470 */
4471 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
4472 {
4473 lprs->nSize = sizeof(RASTERIZER_STATUS);
4474 lprs->wFlags = 0;
4475 lprs->nLanguageID = 0;
4476 return TRUE;
4477 }
4478
4479 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
4480 {
4481 ERR("called but we don't have FreeType\n");
4482 return 0;
4483 }
4484
4485 #endif /* HAVE_FREETYPE */
GDI DIB driver