?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Fix lfWidth before caching the font to avoid duplicate entries in the cache.
[wine/multimedia.git] / dlls / gdi32 / freetype.c
blobb00bc71a4492cb96a3c655b12557041ecbc013fe
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 #ifdef HAVE_SYS_MMAN_H
33 # include <sys/mman.h>
34 #endif
35 #include <string.h>
36 #include <dirent.h>
37 #include <stdio.h>
38 #include <assert.h>
39
40 #ifdef HAVE_CARBON_CARBON_H
41 #define LoadResource __carbon_LoadResource
42 #define CompareString __carbon_CompareString
43 #define GetCurrentThread __carbon_GetCurrentThread
44 #define GetCurrentProcess __carbon_GetCurrentProcess
45 #define AnimatePalette __carbon_AnimatePalette
46 #define EqualRgn __carbon_EqualRgn
47 #define FillRgn __carbon_FillRgn
48 #define FrameRgn __carbon_FrameRgn
49 #define GetPixel __carbon_GetPixel
50 #define InvertRgn __carbon_InvertRgn
51 #define LineTo __carbon_LineTo
52 #define OffsetRgn __carbon_OffsetRgn
53 #define PaintRgn __carbon_PaintRgn
54 #define Polygon __carbon_Polygon
55 #define ResizePalette __carbon_ResizePalette
56 #define SetRectRgn __carbon_SetRectRgn
57 #include <Carbon/Carbon.h>
58 #undef LoadResource
59 #undef CompareString
60 #undef GetCurrentThread
61 #undef _CDECL
62 #undef DPRINTF
63 #undef GetCurrentProcess
64 #undef AnimatePalette
65 #undef EqualRgn
66 #undef FillRgn
67 #undef FrameRgn
68 #undef GetPixel
69 #undef InvertRgn
70 #undef LineTo
71 #undef OffsetRgn
72 #undef PaintRgn
73 #undef Polygon
74 #undef ResizePalette
75 #undef SetRectRgn
76 #endif /* HAVE_CARBON_CARBON_H */
77
78 #include "windef.h"
79 #include "winbase.h"
80 #include "winternl.h"
81 #include "winerror.h"
82 #include "winreg.h"
83 #include "wingdi.h"
84 #include "gdi_private.h"
85 #include "wine/unicode.h"
86 #include "wine/debug.h"
87 #include "wine/list.h"
88
89 WINE_DEFAULT_DEBUG_CHANNEL(font);
90
91 #ifdef HAVE_FREETYPE
92
93 #ifdef HAVE_FT2BUILD_H
94 #include <ft2build.h>
95 #endif
96 #ifdef HAVE_FREETYPE_FREETYPE_H
97 #include <freetype/freetype.h>
98 #endif
99 #ifdef HAVE_FREETYPE_FTGLYPH_H
100 #include <freetype/ftglyph.h>
101 #endif
102 #ifdef HAVE_FREETYPE_TTTABLES_H
103 #include <freetype/tttables.h>
104 #endif
105 #ifdef HAVE_FREETYPE_FTTYPES_H
106 #include <freetype/fttypes.h>
107 #endif
108 #ifdef HAVE_FREETYPE_FTSNAMES_H
109 #include <freetype/ftsnames.h>
110 #else
111 # ifdef HAVE_FREETYPE_FTNAMES_H
112 # include <freetype/ftnames.h>
113 # endif
114 #endif
115 #ifdef HAVE_FREETYPE_TTNAMEID_H
116 #include <freetype/ttnameid.h>
117 #endif
118 #ifdef HAVE_FREETYPE_FTOUTLN_H
119 #include <freetype/ftoutln.h>
120 #endif
121 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
122 #include <freetype/internal/sfnt.h>
123 #endif
124 #ifdef HAVE_FREETYPE_FTTRIGON_H
125 #include <freetype/fttrigon.h>
126 #endif
127 #ifdef HAVE_FREETYPE_FTWINFNT_H
128 #include <freetype/ftwinfnt.h>
129 #endif
130 #ifdef HAVE_FREETYPE_FTMODAPI_H
131 #include <freetype/ftmodapi.h>
132 #endif
133
134 #ifndef HAVE_FT_TRUETYPEENGINETYPE
135 typedef enum
136 {
137 FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
138 FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
139 FT_TRUETYPE_ENGINE_TYPE_PATENTED
140 } FT_TrueTypeEngineType;
141 #endif
142
143 static FT_Library library = 0;
144 typedef struct
145 {
146 FT_Int major;
147 FT_Int minor;
148 FT_Int patch;
149 } FT_Version_t;
150 static FT_Version_t FT_Version;
151 static DWORD FT_SimpleVersion;
152
153 static void *ft_handle = NULL;
154
155 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
156 MAKE_FUNCPTR(FT_Vector_Unit);
157 MAKE_FUNCPTR(FT_Done_Face);
158 MAKE_FUNCPTR(FT_Get_Char_Index);
159 MAKE_FUNCPTR(FT_Get_Module);
160 MAKE_FUNCPTR(FT_Get_Sfnt_Name);
161 MAKE_FUNCPTR(FT_Get_Sfnt_Name_Count);
162 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
163 MAKE_FUNCPTR(FT_Init_FreeType);
164 MAKE_FUNCPTR(FT_Load_Glyph);
165 MAKE_FUNCPTR(FT_Matrix_Multiply);
166 MAKE_FUNCPTR(FT_MulFix);
167 MAKE_FUNCPTR(FT_New_Face);
168 MAKE_FUNCPTR(FT_New_Memory_Face);
169 MAKE_FUNCPTR(FT_Outline_Get_Bitmap);
170 MAKE_FUNCPTR(FT_Outline_Transform);
171 MAKE_FUNCPTR(FT_Outline_Translate);
172 MAKE_FUNCPTR(FT_Select_Charmap);
173 MAKE_FUNCPTR(FT_Set_Charmap);
174 MAKE_FUNCPTR(FT_Set_Pixel_Sizes);
175 MAKE_FUNCPTR(FT_Vector_Transform);
176 static void (*pFT_Library_Version)(FT_Library,FT_Int*,FT_Int*,FT_Int*);
177 static FT_Error (*pFT_Load_Sfnt_Table)(FT_Face,FT_ULong,FT_Long,FT_Byte*,FT_ULong*);
178 static FT_ULong (*pFT_Get_First_Char)(FT_Face,FT_UInt*);
179 static FT_ULong (*pFT_Get_Next_Char)(FT_Face,FT_ULong,FT_UInt*);
180 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type)(FT_Library);
181 #ifdef HAVE_FREETYPE_FTWINFNT_H
182 MAKE_FUNCPTR(FT_Get_WinFNT_Header);
183 #endif
184
185 #ifdef SONAME_LIBFONTCONFIG
186 #include <fontconfig/fontconfig.h>
187 MAKE_FUNCPTR(FcConfigGetCurrent);
188 MAKE_FUNCPTR(FcFontList);
189 MAKE_FUNCPTR(FcFontSetDestroy);
190 MAKE_FUNCPTR(FcInit);
191 MAKE_FUNCPTR(FcObjectSetAdd);
192 MAKE_FUNCPTR(FcObjectSetCreate);
193 MAKE_FUNCPTR(FcObjectSetDestroy);
194 MAKE_FUNCPTR(FcPatternCreate);
195 MAKE_FUNCPTR(FcPatternDestroy);
196 MAKE_FUNCPTR(FcPatternGetBool);
197 MAKE_FUNCPTR(FcPatternGetString);
198 #endif
199
200 #undef MAKE_FUNCPTR
201
202 #ifndef FT_MAKE_TAG
203 #define FT_MAKE_TAG( ch0, ch1, ch2, ch3 ) \
204 ( ((DWORD)(BYTE)(ch0) << 24) | ((DWORD)(BYTE)(ch1) << 16) | \
205 ((DWORD)(BYTE)(ch2) << 8) | (DWORD)(BYTE)(ch3) )
206 #endif
207
208 #ifndef ft_encoding_none
209 #define FT_ENCODING_NONE ft_encoding_none
210 #endif
211 #ifndef ft_encoding_ms_symbol
212 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
213 #endif
214 #ifndef ft_encoding_unicode
215 #define FT_ENCODING_UNICODE ft_encoding_unicode
216 #endif
217 #ifndef ft_encoding_apple_roman
218 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
219 #endif
220
221 #ifdef WORDS_BIGENDIAN
222 #define GET_BE_WORD(x) (x)
223 #else
224 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
225 #endif
226
227 /* This is basically a copy of FT_Bitmap_Size with an extra element added */
228 typedef struct {
229 FT_Short height;
230 FT_Short width;
231 FT_Pos size;
232 FT_Pos x_ppem;
233 FT_Pos y_ppem;
234 FT_Short internal_leading;
235 } Bitmap_Size;
236
237 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
238 So to let this compile on older versions of FreeType we'll define the
239 new structure here. */
240 typedef struct {
241 FT_Short height, width;
242 FT_Pos size, x_ppem, y_ppem;
243 } My_FT_Bitmap_Size;
244
245 struct enum_data
246 {
247 ENUMLOGFONTEXW elf;
248 NEWTEXTMETRICEXW ntm;
249 DWORD type;
250 };
251
252 typedef struct tagFace {
253 struct list entry;
254 WCHAR *StyleName;
255 char *file;
256 void *font_data_ptr;
257 DWORD font_data_size;
258 FT_Long face_index;
259 FONTSIGNATURE fs;
260 FONTSIGNATURE fs_links;
261 DWORD ntmFlags;
262 FT_Fixed font_version;
263 BOOL scalable;
264 Bitmap_Size size; /* set if face is a bitmap */
265 BOOL external; /* TRUE if we should manually add this font to the registry */
266 struct tagFamily *family;
267 /* Cached data for Enum */
268 struct enum_data *cached_enum_data;
269 } Face;
270
271 typedef struct tagFamily {
272 struct list entry;
273 const WCHAR *FamilyName;
274 struct list faces;
275 } Family;
276
277 typedef struct {
278 GLYPHMETRICS gm;
279 INT adv; /* These three hold to widths of the unrotated chars */
280 INT lsb;
281 INT bbx;
282 BOOL init;
283 } GM;
284
285 typedef struct {
286 FLOAT eM11, eM12;
287 FLOAT eM21, eM22;
288 } FMAT2;
289
290 typedef struct {
291 DWORD hash;
292 LOGFONTW lf;
293 FMAT2 matrix;
294 BOOL can_use_bitmap;
295 } FONT_DESC;
296
297 typedef struct tagHFONTLIST {
298 struct list entry;
299 HFONT hfont;
300 } HFONTLIST;
301
302 typedef struct {
303 struct list entry;
304 Face *face;
305 GdiFont *font;
306 } CHILD_FONT;
307
308 struct tagGdiFont {
309 struct list entry;
310 GM **gm;
311 DWORD gmsize;
312 struct list hfontlist;
313 OUTLINETEXTMETRICW *potm;
314 DWORD total_kern_pairs;
315 KERNINGPAIR *kern_pairs;
316 struct list child_fonts;
317
318 /* the following members can be accessed without locking, they are never modified after creation */
319 FT_Face ft_face;
320 struct font_mapping *mapping;
321 LPWSTR name;
322 int charset;
323 int codepage;
324 BOOL fake_italic;
325 BOOL fake_bold;
326 BYTE underline;
327 BYTE strikeout;
328 INT orientation;
329 FONT_DESC font_desc;
330 LONG aveWidth, ppem;
331 float scale_y;
332 SHORT yMax;
333 SHORT yMin;
334 DWORD ntmFlags;
335 FONTSIGNATURE fs;
336 GdiFont *base_font;
337 VOID *GSUB_Table;
338 };
339
340 typedef struct {
341 struct list entry;
342 const WCHAR *font_name;
343 struct list links;
344 } SYSTEM_LINKS;
345
346 #define GM_BLOCK_SIZE 128
347 #define FONT_GM(font,idx) (&(font)->gm[(idx) / GM_BLOCK_SIZE][(idx) % GM_BLOCK_SIZE])
348
349 static struct list gdi_font_list = LIST_INIT(gdi_font_list);
350 static struct list unused_gdi_font_list = LIST_INIT(unused_gdi_font_list);
351 #define UNUSED_CACHE_SIZE 10
352 static struct list child_font_list = LIST_INIT(child_font_list);
353 static struct list system_links = LIST_INIT(system_links);
354
355 static struct list font_subst_list = LIST_INIT(font_subst_list);
356
357 static struct list font_list = LIST_INIT(font_list);
358
359 static const WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
360 static const WCHAR defSans[] = {'A','r','i','a','l','\0'};
361 static const WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
362
363 static const WCHAR RegularW[] = {'R','e','g','u','l','a','r','\0'};
364
365 static const WCHAR fontsW[] = {'\\','f','o','n','t','s','\0'};
366 static const WCHAR win9x_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
367 'W','i','n','d','o','w','s','\\',
368 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
369 'F','o','n','t','s','\0'};
370
371 static const WCHAR winnt_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
372 'W','i','n','d','o','w','s',' ','N','T','\\',
373 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
374 'F','o','n','t','s','\0'};
375
376 static const WCHAR system_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
377 static const WCHAR FixedSys_Value[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
378 static const WCHAR System_Value[] = {'F','O','N','T','S','.','F','O','N','\0'};
379 static const WCHAR OEMFont_Value[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
380
381 static const WCHAR * const SystemFontValues[4] = {
382 System_Value,
383 OEMFont_Value,
384 FixedSys_Value,
385 NULL
386 };
387
388 static const WCHAR external_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
389 'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
390
391 static const WCHAR ArabicW[] = {'A','r','a','b','i','c','\0'};
392 static const WCHAR BalticW[] = {'B','a','l','t','i','c','\0'};
393 static const WCHAR CHINESE_BIG5W[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
394 static const WCHAR CHINESE_GB2312W[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
395 static const WCHAR Central_EuropeanW[] = {'C','e','n','t','r','a','l',' ',
396 'E','u','r','o','p','e','a','n','\0'};
397 static const WCHAR CyrillicW[] = {'C','y','r','i','l','l','i','c','\0'};
398 static const WCHAR GreekW[] = {'G','r','e','e','k','\0'};
399 static const WCHAR HangulW[] = {'H','a','n','g','u','l','\0'};
400 static const WCHAR Hangul_Johab_W[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
401 static const WCHAR HebrewW[] = {'H','e','b','r','e','w','\0'};
402 static const WCHAR JapaneseW[] = {'J','a','p','a','n','e','s','e','\0'};
403 static const WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
404 static const WCHAR ThaiW[] = {'T','h','a','i','\0'};
405 static const WCHAR TurkishW[] = {'T','u','r','k','i','s','h','\0'};
406 static const WCHAR VietnameseW[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
407 static const WCHAR WesternW[] = {'W','e','s','t','e','r','n','\0'};
408 static const WCHAR OEM_DOSW[] = {'O','E','M','/','D','O','S','\0'};
409
410 static const WCHAR * const ElfScriptsW[32] = { /* these are in the order of the fsCsb[0] bits */
411 WesternW, /*00*/
412 Central_EuropeanW,
413 CyrillicW,
414 GreekW,
415 TurkishW,
416 HebrewW,
417 ArabicW,
418 BalticW,
419 VietnameseW, /*08*/
420 NULL, NULL, NULL, NULL, NULL, NULL, NULL, /*15*/
421 ThaiW,
422 JapaneseW,
423 CHINESE_GB2312W,
424 HangulW,
425 CHINESE_BIG5W,
426 Hangul_Johab_W,
427 NULL, NULL, /*23*/
428 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
429 SymbolW /*31*/
430 };
431
432 typedef struct {
433 WCHAR *name;
434 INT charset;
435 } NameCs;
436
437 typedef struct tagFontSubst {
438 struct list entry;
439 NameCs from;
440 NameCs to;
441 } FontSubst;
442
443 struct font_mapping
444 {
445 struct list entry;
446 int refcount;
447 dev_t dev;
448 ino_t ino;
449 void *data;
450 size_t size;
451 };
452
453 static struct list mappings_list = LIST_INIT( mappings_list );
454
455 static BOOL have_installed_roman_font = FALSE; /* CreateFontInstance will fail if this is still FALSE */
456
457 static CRITICAL_SECTION freetype_cs;
458 static CRITICAL_SECTION_DEBUG critsect_debug =
459 {
460 0, 0, &freetype_cs,
461 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
462 0, 0, { (DWORD_PTR)(__FILE__ ": freetype_cs") }
463 };
464 static CRITICAL_SECTION freetype_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
465
466 static const WCHAR font_mutex_nameW[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
467
468 static const WCHAR szDefaultFallbackLink[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0};
469 static BOOL use_default_fallback = FALSE;
470
471 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph);
472
473 /****************************************
474 * Notes on .fon files
475 *
476 * The fonts System, FixedSys and Terminal are special. There are typically multiple
477 * versions installed for different resolutions and codepages. Windows stores which one to use
478 * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
479 * Key Meaning
480 * FIXEDFON.FON FixedSys
481 * FONTS.FON System
482 * OEMFONT.FON Terminal
483 * LogPixels Current dpi set by the display control panel applet
484 * (HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontDPI
485 * also has a LogPixels value that appears to mirror this)
486 *
487 * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
488 * (vgaoem.fon would be your oemfont.fon if you have a US setup).
489 * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
490 * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
491 * so that makes sense.
492 *
493 * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
494 * to be mapped into the registry on Windows 2000 at least).
495 * I have
496 * woafont=app850.fon
497 * ega80woa.fon=ega80850.fon
498 * ega40woa.fon=ega40850.fon
499 * cga80woa.fon=cga80850.fon
500 * cga40woa.fon=cga40850.fon
501 */
502
503 /* These are all structures needed for the GSUB table */
504
505 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
506 #define TATEGAKI_LOWER_BOUND 0x02F1
507
508 typedef struct {
509 DWORD version;
510 WORD ScriptList;
511 WORD FeatureList;
512 WORD LookupList;
513 } GSUB_Header;
514
515 typedef struct {
516 CHAR ScriptTag[4];
517 WORD Script;
518 } GSUB_ScriptRecord;
519
520 typedef struct {
521 WORD ScriptCount;
522 GSUB_ScriptRecord ScriptRecord[1];
523 } GSUB_ScriptList;
524
525 typedef struct {
526 CHAR LangSysTag[4];
527 WORD LangSys;
528 } GSUB_LangSysRecord;
529
530 typedef struct {
531 WORD DefaultLangSys;
532 WORD LangSysCount;
533 GSUB_LangSysRecord LangSysRecord[1];
534 } GSUB_Script;
535
536 typedef struct {
537 WORD LookupOrder; /* Reserved */
538 WORD ReqFeatureIndex;
539 WORD FeatureCount;
540 WORD FeatureIndex[1];
541 } GSUB_LangSys;
542
543 typedef struct {
544 CHAR FeatureTag[4];
545 WORD Feature;
546 } GSUB_FeatureRecord;
547
548 typedef struct {
549 WORD FeatureCount;
550 GSUB_FeatureRecord FeatureRecord[1];
551 } GSUB_FeatureList;
552
553 typedef struct {
554 WORD FeatureParams; /* Reserved */
555 WORD LookupCount;
556 WORD LookupListIndex[1];
557 } GSUB_Feature;
558
559 typedef struct {
560 WORD LookupCount;
561 WORD Lookup[1];
562 } GSUB_LookupList;
563
564 typedef struct {
565 WORD LookupType;
566 WORD LookupFlag;
567 WORD SubTableCount;
568 WORD SubTable[1];
569 } GSUB_LookupTable;
570
571 typedef struct {
572 WORD CoverageFormat;
573 WORD GlyphCount;
574 WORD GlyphArray[1];
575 } GSUB_CoverageFormat1;
576
577 typedef struct {
578 WORD Start;
579 WORD End;
580 WORD StartCoverageIndex;
581 } GSUB_RangeRecord;
582
583 typedef struct {
584 WORD CoverageFormat;
585 WORD RangeCount;
586 GSUB_RangeRecord RangeRecord[1];
587 } GSUB_CoverageFormat2;
588
589 typedef struct {
590 WORD SubstFormat; /* = 1 */
591 WORD Coverage;
592 WORD DeltaGlyphID;
593 } GSUB_SingleSubstFormat1;
594
595 typedef struct {
596 WORD SubstFormat; /* = 2 */
597 WORD Coverage;
598 WORD GlyphCount;
599 WORD Substitute[1];
600 }GSUB_SingleSubstFormat2;
601
602 #ifdef HAVE_CARBON_CARBON_H
603 static char *find_cache_dir(void)
604 {
605 FSRef ref;
606 OSErr err;
607 static char cached_path[MAX_PATH];
608 static const char *wine = "/Wine", *fonts = "/Fonts";
609
610 if(*cached_path) return cached_path;
611
612 err = FSFindFolder(kUserDomain, kCachedDataFolderType, kCreateFolder, &ref);
613 if(err != noErr)
614 {
615 WARN("can't create cached data folder\n");
616 return NULL;
617 }
618 err = FSRefMakePath(&ref, (unsigned char*)cached_path, sizeof(cached_path));
619 if(err != noErr)
620 {
621 WARN("can't create cached data path\n");
622 *cached_path = '\0';
623 return NULL;
624 }
625 if(strlen(cached_path) + strlen(wine) + strlen(fonts) + 1 > sizeof(cached_path))
626 {
627 ERR("Could not create full path\n");
628 *cached_path = '\0';
629 return NULL;
630 }
631 strcat(cached_path, wine);
632
633 if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
634 {
635 WARN("Couldn't mkdir %s\n", cached_path);
636 *cached_path = '\0';
637 return NULL;
638 }
639 strcat(cached_path, fonts);
640 if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
641 {
642 WARN("Couldn't mkdir %s\n", cached_path);
643 *cached_path = '\0';
644 return NULL;
645 }
646 return cached_path;
647 }
648
649 /******************************************************************
650 * expand_mac_font
651 *
652 * Extracts individual TrueType font files from a Mac suitcase font
653 * and saves them into the user's caches directory (see
654 * find_cache_dir()).
655 * Returns a NULL terminated array of filenames.
656 *
657 * We do this because they are apps that try to read ttf files
658 * themselves and they don't like Mac suitcase files.
659 */
660 static char **expand_mac_font(const char *path)
661 {
662 FSRef ref;
663 SInt16 res_ref;
664 OSStatus s;
665 unsigned int idx;
666 const char *out_dir;
667 const char *filename;
668 int output_len;
669 struct {
670 char **array;
671 unsigned int size, max_size;
672 } ret;
673
674 TRACE("path %s\n", path);
675
676 s = FSPathMakeRef((unsigned char*)path, &ref, FALSE);
677 if(s != noErr)
678 {
679 WARN("failed to get ref\n");
680 return NULL;
681 }
682
683 s = FSOpenResourceFile(&ref, 0, NULL, fsRdPerm, &res_ref);
684 if(s != noErr)
685 {
686 TRACE("no data fork, so trying resource fork\n");
687 res_ref = FSOpenResFile(&ref, fsRdPerm);
688 if(res_ref == -1)
689 {
690 TRACE("unable to open resource fork\n");
691 return NULL;
692 }
693 }
694
695 ret.size = 0;
696 ret.max_size = 10;
697 ret.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.max_size * sizeof(*ret.array));
698 if(!ret.array)
699 {
700 CloseResFile(res_ref);
701 return NULL;
702 }
703
704 out_dir = find_cache_dir();
705
706 filename = strrchr(path, '/');
707 if(!filename) filename = path;
708 else filename++;
709
710 /* output filename has the form out_dir/filename_%04x.ttf */
711 output_len = strlen(out_dir) + 1 + strlen(filename) + 5 + 5;
712
713 UseResFile(res_ref);
714 idx = 1;
715 while(1)
716 {
717 FamRec *fam_rec;
718 unsigned short *num_faces_ptr, num_faces, face;
719 AsscEntry *assoc;
720 Handle fond;
721 ResType fond_res = FT_MAKE_TAG('F','O','N','D');
722
723 fond = Get1IndResource(fond_res, idx);
724 if(!fond) break;
725 TRACE("got fond resource %d\n", idx);
726 HLock(fond);
727
728 fam_rec = *(FamRec**)fond;
729 num_faces_ptr = (unsigned short *)(fam_rec + 1);
730 num_faces = GET_BE_WORD(*num_faces_ptr);
731 num_faces++;
732 assoc = (AsscEntry*)(num_faces_ptr + 1);
733 TRACE("num faces %04x\n", num_faces);
734 for(face = 0; face < num_faces; face++, assoc++)
735 {
736 Handle sfnt;
737 ResType sfnt_res = FT_MAKE_TAG('s','f','n','t');
738 unsigned short size, font_id;
739 char *output;
740
741 size = GET_BE_WORD(assoc->fontSize);
742 font_id = GET_BE_WORD(assoc->fontID);
743 if(size != 0)
744 {
745 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id, size);
746 continue;
747 }
748
749 TRACE("trying to load sfnt id %04x\n", font_id);
750 sfnt = GetResource(sfnt_res, font_id);
751 if(!sfnt)
752 {
753 TRACE("can't get sfnt resource %04x\n", font_id);
754 continue;
755 }
756
757 output = HeapAlloc(GetProcessHeap(), 0, output_len);
758 if(output)
759 {
760 int fd;
761
762 sprintf(output, "%s/%s_%04x.ttf", out_dir, filename, font_id);
763
764 fd = open(output, O_CREAT | O_EXCL | O_WRONLY, 0600);
765 if(fd != -1 || errno == EEXIST)
766 {
767 if(fd != -1)
768 {
769 unsigned char *sfnt_data;
770
771 HLock(sfnt);
772 sfnt_data = *(unsigned char**)sfnt;
773 write(fd, sfnt_data, GetHandleSize(sfnt));
774 HUnlock(sfnt);
775 close(fd);
776 }
777 if(ret.size >= ret.max_size - 1) /* Always want the last element to be NULL */
778 {
779 ret.max_size *= 2;
780 ret.array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.array, ret.max_size * sizeof(*ret.array));
781 }
782 ret.array[ret.size++] = output;
783 }
784 else
785 {
786 WARN("unable to create %s\n", output);
787 HeapFree(GetProcessHeap(), 0, output);
788 }
789 }
790 ReleaseResource(sfnt);
791 }
792 HUnlock(fond);
793 ReleaseResource(fond);
794 idx++;
795 }
796 CloseResFile(res_ref);
797
798 return ret.array;
799 }
800
801 #endif /* HAVE_CARBON_CARBON_H */
802
803 static inline BOOL is_win9x(void)
804 {
805 return GetVersion() & 0x80000000;
806 }
807 /*
808 This function builds an FT_Fixed from a float. It puts the integer part
809 in the highest 16 bits and the decimal part in the lowest 16 bits of the FT_Fixed.
810 It fails if the integer part of the float number is greater than SHORT_MAX.
811 */
812 static inline FT_Fixed FT_FixedFromFloat(float f)
813 {
814 short value = f;
815 unsigned short fract = (f - value) * 0xFFFF;
816 return (FT_Fixed)((long)value << 16 | (unsigned long)fract);
817 }
818
819 /*
820 This function builds an FT_Fixed from a FIXED. It simply put f.value
821 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
822 */
823 static inline FT_Fixed FT_FixedFromFIXED(FIXED f)
824 {
825 return (FT_Fixed)((long)f.value << 16 | (unsigned long)f.fract);
826 }
827
828
829 static Face *find_face_from_filename(const WCHAR *file_name, const WCHAR *face_name)
830 {
831 Family *family;
832 Face *face;
833 const char *file;
834 DWORD len = WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, NULL, 0, NULL, NULL);
835 char *file_nameA = HeapAlloc(GetProcessHeap(), 0, len);
836
837 WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, file_nameA, len, NULL, NULL);
838 TRACE("looking for file %s name %s\n", debugstr_a(file_nameA), debugstr_w(face_name));
839
840 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
841 {
842 if(face_name && strcmpiW(face_name, family->FamilyName))
843 continue;
844 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
845 {
846 if (!face->file)
847 continue;
848 file = strrchr(face->file, '/');
849 if(!file)
850 file = face->file;
851 else
852 file++;
853 if(!strcasecmp(file, file_nameA))
854 {
855 HeapFree(GetProcessHeap(), 0, file_nameA);
856 return face;
857 }
858 }
859 }
860 HeapFree(GetProcessHeap(), 0, file_nameA);
861 return NULL;
862 }
863
864 static Family *find_family_from_name(const WCHAR *name)
865 {
866 Family *family;
867
868 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
869 {
870 if(!strcmpiW(family->FamilyName, name))
871 return family;
872 }
873
874 return NULL;
875 }
876
877 static void DumpSubstList(void)
878 {
879 FontSubst *psub;
880
881 LIST_FOR_EACH_ENTRY(psub, &font_subst_list, FontSubst, entry)
882 {
883 if(psub->from.charset != -1 || psub->to.charset != -1)
884 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
885 psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
886 else
887 TRACE("%s -> %s\n", debugstr_w(psub->from.name),
888 debugstr_w(psub->to.name));
889 }
890 return;
891 }
892
893 static LPWSTR strdupW(LPCWSTR p)
894 {
895 LPWSTR ret;
896 DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
897 ret = HeapAlloc(GetProcessHeap(), 0, len);
898 memcpy(ret, p, len);
899 return ret;
900 }
901
902 static LPSTR strdupA(LPCSTR p)
903 {
904 LPSTR ret;
905 DWORD len = (strlen(p) + 1);
906 ret = HeapAlloc(GetProcessHeap(), 0, len);
907 memcpy(ret, p, len);
908 return ret;
909 }
910
911 static FontSubst *get_font_subst(const struct list *subst_list, const WCHAR *from_name,
912 INT from_charset)
913 {
914 FontSubst *element;
915
916 LIST_FOR_EACH_ENTRY(element, subst_list, FontSubst, entry)
917 {
918 if(!strcmpiW(element->from.name, from_name) &&
919 (element->from.charset == from_charset ||
920 element->from.charset == -1))
921 return element;
922 }
923
924 return NULL;
925 }
926
927 #define ADD_FONT_SUBST_FORCE 1
928
929 static BOOL add_font_subst(struct list *subst_list, FontSubst *subst, INT flags)
930 {
931 FontSubst *from_exist, *to_exist;
932
933 from_exist = get_font_subst(subst_list, subst->from.name, subst->from.charset);
934
935 if(from_exist && (flags & ADD_FONT_SUBST_FORCE))
936 {
937 list_remove(&from_exist->entry);
938 HeapFree(GetProcessHeap(), 0, &from_exist->from.name);
939 HeapFree(GetProcessHeap(), 0, &from_exist->to.name);
940 HeapFree(GetProcessHeap(), 0, from_exist);
941 from_exist = NULL;
942 }
943
944 if(!from_exist)
945 {
946 to_exist = get_font_subst(subst_list, subst->to.name, subst->to.charset);
947
948 if(to_exist)
949 {
950 HeapFree(GetProcessHeap(), 0, subst->to.name);
951 subst->to.name = strdupW(to_exist->to.name);
952 }
953
954 list_add_tail(subst_list, &subst->entry);
955
956 return TRUE;
957 }
958
959 HeapFree(GetProcessHeap(), 0, subst->from.name);
960 HeapFree(GetProcessHeap(), 0, subst->to.name);
961 HeapFree(GetProcessHeap(), 0, subst);
962 return FALSE;
963 }
964
965 static void split_subst_info(NameCs *nc, LPSTR str)
966 {
967 CHAR *p = strrchr(str, ',');
968 DWORD len;
969
970 nc->charset = -1;
971 if(p && *(p+1)) {
972 nc->charset = strtol(p+1, NULL, 10);
973 *p = '\0';
974 }
975 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
976 nc->name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
977 MultiByteToWideChar(CP_ACP, 0, str, -1, nc->name, len);
978 }
979
980 static void LoadSubstList(void)
981 {
982 FontSubst *psub;
983 HKEY hkey;
984 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
985 LPSTR value;
986 LPVOID data;
987
988 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
989 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
990 &hkey) == ERROR_SUCCESS) {
991
992 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
993 &valuelen, &datalen, NULL, NULL);
994
995 valuelen++; /* returned value doesn't include room for '\0' */
996 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
997 data = HeapAlloc(GetProcessHeap(), 0, datalen);
998
999 dlen = datalen;
1000 vlen = valuelen;
1001 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
1002 &dlen) == ERROR_SUCCESS) {
1003 TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
1004
1005 psub = HeapAlloc(GetProcessHeap(), 0, sizeof(*psub));
1006 split_subst_info(&psub->from, value);
1007 split_subst_info(&psub->to, data);
1008
1009 /* Win 2000 doesn't allow mapping between different charsets
1010 or mapping of DEFAULT_CHARSET */
1011 if((psub->to.charset != psub->from.charset) ||
1012 psub->to.charset == DEFAULT_CHARSET) {
1013 HeapFree(GetProcessHeap(), 0, psub->to.name);
1014 HeapFree(GetProcessHeap(), 0, psub->from.name);
1015 HeapFree(GetProcessHeap(), 0, psub);
1016 } else {
1017 add_font_subst(&font_subst_list, psub, 0);
1018 }
1019 /* reset dlen and vlen */
1020 dlen = datalen;
1021 vlen = valuelen;
1022 }
1023 HeapFree(GetProcessHeap(), 0, data);
1024 HeapFree(GetProcessHeap(), 0, value);
1025 RegCloseKey(hkey);
1026 }
1027 }
1028
1029 static WCHAR *get_familyname(FT_Face ft_face)
1030 {
1031 WCHAR *family = NULL;
1032 FT_SfntName name;
1033 FT_UInt num_names, name_index, i;
1034
1035 if(FT_IS_SFNT(ft_face))
1036 {
1037 num_names = pFT_Get_Sfnt_Name_Count(ft_face);
1038
1039 for(name_index = 0; name_index < num_names; name_index++)
1040 {
1041 if(!pFT_Get_Sfnt_Name(ft_face, name_index, &name))
1042 {
1043 if((name.name_id == TT_NAME_ID_FONT_FAMILY) &&
1044 (name.language_id == GetUserDefaultLCID()) &&
1045 (name.platform_id == TT_PLATFORM_MICROSOFT) &&
1046 (name.encoding_id == TT_MS_ID_UNICODE_CS))
1047 {
1048 /* String is not nul terminated and string_len is a byte length. */
1049 family = HeapAlloc(GetProcessHeap(), 0, name.string_len + 2);
1050 for(i = 0; i < name.string_len / 2; i++)
1051 {
1052 WORD *tmp = (WORD *)&name.string[i * 2];
1053 family[i] = GET_BE_WORD(*tmp);
1054 }
1055 family[i] = 0;
1056
1057 TRACE("Got localised name %s\n", debugstr_w(family));
1058 return family;
1059 }
1060 }
1061 }
1062 }
1063
1064 return NULL;
1065 }
1066
1067
1068 /*****************************************************************
1069 * load_sfnt_table
1070 *
1071 * Wrapper around FT_Load_Sfnt_Table to cope with older versions
1072 * of FreeType that don't export this function.
1073 *
1074 */
1075 static FT_Error load_sfnt_table(FT_Face ft_face, FT_ULong table, FT_Long offset, FT_Byte *buf, FT_ULong *len)
1076 {
1077
1078 FT_Error err;
1079
1080 /* If the FT_Load_Sfnt_Table function is there we'll use it */
1081 if(pFT_Load_Sfnt_Table)
1082 {
1083 err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, len);
1084 }
1085 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
1086 else /* Do it the hard way */
1087 {
1088 TT_Face tt_face = (TT_Face) ft_face;
1089 SFNT_Interface *sfnt;
1090 if (FT_Version.major==2 && FT_Version.minor==0)
1091 {
1092 /* 2.0.x */
1093 sfnt = *(SFNT_Interface**)((char*)tt_face + 528);
1094 }
1095 else
1096 {
1097 /* A field was added in the middle of the structure in 2.1.x */
1098 sfnt = *(SFNT_Interface**)((char*)tt_face + 532);
1099 }
1100 err = sfnt->load_any(tt_face, table, offset, buf, len);
1101 }
1102 #else
1103 else
1104 {
1105 static int msg;
1106 if(!msg)
1107 {
1108 MESSAGE("This version of Wine was compiled with freetype headers later than 2.2.0\n"
1109 "but is being run with a freetype library without the FT_Load_Sfnt_Table function.\n"
1110 "Please upgrade your freetype library.\n");
1111 msg++;
1112 }
1113 err = FT_Err_Unimplemented_Feature;
1114 }
1115 #endif
1116 return err;
1117 }
1118
1119
1120 #define ADDFONT_EXTERNAL_FONT 0x01
1121 #define ADDFONT_FORCE_BITMAP 0x02
1122 static INT AddFontToList(const char *file, void *font_data_ptr, DWORD font_data_size, char *fake_family, const WCHAR *target_family, DWORD flags)
1123 {
1124 FT_Face ft_face;
1125 TT_OS2 *pOS2;
1126 TT_Header *pHeader = NULL;
1127 WCHAR *english_family, *localised_family, *StyleW;
1128 DWORD len;
1129 Family *family;
1130 Face *face;
1131 struct list *family_elem_ptr, *face_elem_ptr;
1132 FT_Error err;
1133 FT_Long face_index = 0, num_faces;
1134 #ifdef HAVE_FREETYPE_FTWINFNT_H
1135 FT_WinFNT_HeaderRec winfnt_header;
1136 #endif
1137 int i, bitmap_num, internal_leading;
1138 FONTSIGNATURE fs;
1139
1140 /* we always load external fonts from files - otherwise we would get a crash in update_reg_entries */
1141 assert(file || !(flags & ADDFONT_EXTERNAL_FONT));
1142
1143 #ifdef HAVE_CARBON_CARBON_H
1144 if(file && !fake_family)
1145 {
1146 char **mac_list = expand_mac_font(file);
1147 if(mac_list)
1148 {
1149 BOOL had_one = FALSE;
1150 char **cursor;
1151 for(cursor = mac_list; *cursor; cursor++)
1152 {
1153 had_one = TRUE;
1154 AddFontToList(*cursor, NULL, 0, NULL, NULL, flags);
1155 HeapFree(GetProcessHeap(), 0, *cursor);
1156 }
1157 HeapFree(GetProcessHeap(), 0, mac_list);
1158 if(had_one)
1159 return 1;
1160 }
1161 }
1162 #endif /* HAVE_CARBON_CARBON_H */
1163
1164 do {
1165 char *family_name = fake_family;
1166
1167 if (file)
1168 {
1169 TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
1170 err = pFT_New_Face(library, file, face_index, &ft_face);
1171 } else
1172 {
1173 TRACE("Loading font from ptr %p size %d, index %ld\n", font_data_ptr, font_data_size, face_index);
1174 err = pFT_New_Memory_Face(library, font_data_ptr, font_data_size, face_index, &ft_face);
1175 }
1176
1177 if(err != 0) {
1178 WARN("Unable to load font %s/%p err = %x\n", debugstr_a(file), font_data_ptr, err);
1179 return 0;
1180 }
1181
1182 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*/
1183 WARN("Ignoring font %s/%p\n", debugstr_a(file), font_data_ptr);
1184 pFT_Done_Face(ft_face);
1185 return 0;
1186 }
1187
1188 /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1189 if(!FT_IS_SCALABLE(ft_face) && FT_SimpleVersion < ((2 << 16) | (1 << 8) | (9 << 0))) {
1190 WARN("FreeType version < 2.1.9, skipping bitmap font %s/%p\n", debugstr_a(file), font_data_ptr);
1191 pFT_Done_Face(ft_face);
1192 return 0;
1193 }
1194
1195 if(FT_IS_SFNT(ft_face))
1196 {
1197 if(!(pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2)) ||
1198 !pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea) ||
1199 !(pHeader = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_head)))
1200 {
1201 TRACE("Font %s/%p lacks either an OS2, HHEA or HEAD table.\n"
1202 "Skipping this font.\n", debugstr_a(file), font_data_ptr);
1203 pFT_Done_Face(ft_face);
1204 return 0;
1205 }
1206
1207 /* Wine uses ttfs as an intermediate step in building its bitmap fonts;
1208 we don't want to load these. */
1209 if(!memcmp(pOS2->achVendID, "Wine", sizeof(pOS2->achVendID)))
1210 {
1211 FT_ULong len = 0;
1212
1213 if(!load_sfnt_table(ft_face, FT_MAKE_TAG('E','B','S','C'), 0, NULL, &len))
1214 {
1215 TRACE("Skipping Wine bitmap-only TrueType font %s\n", debugstr_a(file));
1216 pFT_Done_Face(ft_face);
1217 return 0;
1218 }
1219 }
1220 }
1221
1222 if(!ft_face->family_name || !ft_face->style_name) {
1223 TRACE("Font %s/%p lacks either a family or style name\n", debugstr_a(file), font_data_ptr);
1224 pFT_Done_Face(ft_face);
1225 return 0;
1226 }
1227
1228 if(ft_face->family_name[0] == '.') /* Ignore fonts with names beginning with a dot */
1229 {
1230 TRACE("Ignoring %s since its family name begins with a dot\n", debugstr_a(file));
1231 pFT_Done_Face(ft_face);
1232 return 0;
1233 }
1234
1235 if (target_family)
1236 {
1237 localised_family = get_familyname(ft_face);
1238 if (localised_family && strcmpiW(localised_family,target_family)!=0)
1239 {
1240 TRACE("Skipping Index %i: Incorrect Family name for replacement\n",(INT)face_index);
1241 HeapFree(GetProcessHeap(), 0, localised_family);
1242 num_faces = ft_face->num_faces;
1243 pFT_Done_Face(ft_face);
1244 continue;
1245 }
1246 HeapFree(GetProcessHeap(), 0, localised_family);
1247 }
1248
1249 if(!family_name)
1250 family_name = ft_face->family_name;
1251
1252 bitmap_num = 0;
1253 do {
1254 My_FT_Bitmap_Size *size = NULL;
1255 FT_ULong tmp_size;
1256
1257 if(!FT_IS_SCALABLE(ft_face))
1258 size = (My_FT_Bitmap_Size *)ft_face->available_sizes + bitmap_num;
1259
1260 len = MultiByteToWideChar(CP_ACP, 0, family_name, -1, NULL, 0);
1261 english_family = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1262 MultiByteToWideChar(CP_ACP, 0, family_name, -1, english_family, len);
1263
1264 localised_family = NULL;
1265 if(!fake_family) {
1266 localised_family = get_familyname(ft_face);
1267 if(localised_family && !strcmpW(localised_family, english_family)) {
1268 HeapFree(GetProcessHeap(), 0, localised_family);
1269 localised_family = NULL;
1270 }
1271 }
1272
1273 family = NULL;
1274 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1275 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1276 if(!strcmpW(family->FamilyName, localised_family ? localised_family : english_family))
1277 break;
1278 family = NULL;
1279 }
1280 if(!family) {
1281 family = HeapAlloc(GetProcessHeap(), 0, sizeof(*family));
1282 family->FamilyName = strdupW(localised_family ? localised_family : english_family);
1283 list_init(&family->faces);
1284 list_add_tail(&font_list, &family->entry);
1285
1286 if(localised_family) {
1287 FontSubst *subst = HeapAlloc(GetProcessHeap(), 0, sizeof(*subst));
1288 subst->from.name = strdupW(english_family);
1289 subst->from.charset = -1;
1290 subst->to.name = strdupW(localised_family);
1291 subst->to.charset = -1;
1292 add_font_subst(&font_subst_list, subst, 0);
1293 }
1294 }
1295 HeapFree(GetProcessHeap(), 0, localised_family);
1296 HeapFree(GetProcessHeap(), 0, english_family);
1297
1298 len = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0);
1299 StyleW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1300 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, StyleW, len);
1301
1302 internal_leading = 0;
1303 memset(&fs, 0, sizeof(fs));
1304
1305 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
1306 if(pOS2) {
1307 fs.fsCsb[0] = pOS2->ulCodePageRange1;
1308 fs.fsCsb[1] = pOS2->ulCodePageRange2;
1309 fs.fsUsb[0] = pOS2->ulUnicodeRange1;
1310 fs.fsUsb[1] = pOS2->ulUnicodeRange2;
1311 fs.fsUsb[2] = pOS2->ulUnicodeRange3;
1312 fs.fsUsb[3] = pOS2->ulUnicodeRange4;
1313 if(pOS2->version == 0) {
1314 FT_UInt dummy;
1315
1316 if(!pFT_Get_First_Char || (pFT_Get_First_Char( ft_face, &dummy ) < 0x100))
1317 fs.fsCsb[0] |= FS_LATIN1;
1318 else
1319 fs.fsCsb[0] |= FS_SYMBOL;
1320 }
1321 }
1322 #ifdef HAVE_FREETYPE_FTWINFNT_H
1323 else if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header)) {
1324 CHARSETINFO csi;
1325 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header.pixel_height, winfnt_header.charset,
1326 winfnt_header.vertical_resolution,winfnt_header.horizontal_resolution, winfnt_header.nominal_point_size);
1327 if(TranslateCharsetInfo((DWORD*)(UINT_PTR)winfnt_header.charset, &csi, TCI_SRCCHARSET))
1328 fs = csi.fs;
1329 internal_leading = winfnt_header.internal_leading;
1330 }
1331 #endif
1332
1333 face_elem_ptr = list_head(&family->faces);
1334 while(face_elem_ptr) {
1335 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1336 face_elem_ptr = list_next(&family->faces, face_elem_ptr);
1337 if(!strcmpW(face->StyleName, StyleW) &&
1338 (FT_IS_SCALABLE(ft_face) || ((size->y_ppem == face->size.y_ppem) && !memcmp(&fs, &face->fs, sizeof(fs)) ))) {
1339 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1340 debugstr_w(family->FamilyName), debugstr_w(StyleW),
1341 face->font_version, pHeader ? pHeader->Font_Revision : 0);
1342
1343 if(fake_family) {
1344 TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
1345 HeapFree(GetProcessHeap(), 0, StyleW);
1346 pFT_Done_Face(ft_face);
1347 return 1;
1348 }
1349 if(!pHeader || pHeader->Font_Revision <= face->font_version) {
1350 TRACE("Original font is newer so skipping this one\n");
1351 HeapFree(GetProcessHeap(), 0, StyleW);
1352 pFT_Done_Face(ft_face);
1353 return 1;
1354 } else {
1355 TRACE("Replacing original with this one\n");
1356 list_remove(&face->entry);
1357 HeapFree(GetProcessHeap(), 0, face->file);
1358 HeapFree(GetProcessHeap(), 0, face->StyleName);
1359 HeapFree(GetProcessHeap(), 0, face);
1360 break;
1361 }
1362 }
1363 }
1364 face = HeapAlloc(GetProcessHeap(), 0, sizeof(*face));
1365 face->cached_enum_data = NULL;
1366 list_add_tail(&family->faces, &face->entry);
1367 face->StyleName = StyleW;
1368 if (file)
1369 {
1370 face->file = strdupA(file);
1371 face->font_data_ptr = NULL;
1372 face->font_data_size = 0;
1373 }
1374 else
1375 {
1376 face->file = NULL;
1377 face->font_data_ptr = font_data_ptr;
1378 face->font_data_size = font_data_size;
1379 }
1380 face->face_index = face_index;
1381 face->ntmFlags = 0;
1382 if (ft_face->style_flags & FT_STYLE_FLAG_ITALIC)
1383 face->ntmFlags |= NTM_ITALIC;
1384 if (ft_face->style_flags & FT_STYLE_FLAG_BOLD)
1385 face->ntmFlags |= NTM_BOLD;
1386 if (face->ntmFlags == 0) face->ntmFlags = NTM_REGULAR;
1387 face->font_version = pHeader ? pHeader->Font_Revision : 0;
1388 face->family = family;
1389 face->external = (flags & ADDFONT_EXTERNAL_FONT) ? TRUE : FALSE;
1390 face->fs = fs;
1391 memset(&face->fs_links, 0, sizeof(face->fs_links));
1392
1393 if(FT_IS_SCALABLE(ft_face)) {
1394 memset(&face->size, 0, sizeof(face->size));
1395 face->scalable = TRUE;
1396 } else {
1397 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1398 size->height, size->width, size->size >> 6,
1399 size->x_ppem >> 6, size->y_ppem >> 6);
1400 face->size.height = size->height;
1401 face->size.width = size->width;
1402 face->size.size = size->size;
1403 face->size.x_ppem = size->x_ppem;
1404 face->size.y_ppem = size->y_ppem;
1405 face->size.internal_leading = internal_leading;
1406 face->scalable = FALSE;
1407 }
1408
1409 /* check for the presence of the 'CFF ' table to check if the font is Type1 */
1410 tmp_size = 0;
1411 if (pFT_Load_Sfnt_Table && !pFT_Load_Sfnt_Table(ft_face, FT_MAKE_TAG('C','F','F',' '), 0, NULL, &tmp_size))
1412 {
1413 TRACE("Font %s/%p is OTF Type1\n", wine_dbgstr_a(file), font_data_ptr);
1414 face->ntmFlags |= NTM_PS_OPENTYPE;
1415 }
1416
1417 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1418 face->fs.fsCsb[0], face->fs.fsCsb[1],
1419 face->fs.fsUsb[0], face->fs.fsUsb[1],
1420 face->fs.fsUsb[2], face->fs.fsUsb[3]);
1421
1422
1423 if(face->fs.fsCsb[0] == 0) { /* let's see if we can find any interesting cmaps */
1424 for(i = 0; i < ft_face->num_charmaps; i++) {
1425 switch(ft_face->charmaps[i]->encoding) {
1426 case FT_ENCODING_UNICODE:
1427 case FT_ENCODING_APPLE_ROMAN:
1428 face->fs.fsCsb[0] |= FS_LATIN1;
1429 break;
1430 case FT_ENCODING_MS_SYMBOL:
1431 face->fs.fsCsb[0] |= FS_SYMBOL;
1432 break;
1433 default:
1434 break;
1435 }
1436 }
1437 }
1438
1439 if (!(face->fs.fsCsb[0] & FS_SYMBOL))
1440 have_installed_roman_font = TRUE;
1441 } while(!FT_IS_SCALABLE(ft_face) && ++bitmap_num < ft_face->num_fixed_sizes);
1442
1443 num_faces = ft_face->num_faces;
1444 pFT_Done_Face(ft_face);
1445 TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
1446 debugstr_w(StyleW));
1447 } while(num_faces > ++face_index);
1448 return num_faces;
1449 }
1450
1451 static INT AddFontFileToList(const char *file, char *fake_family, const WCHAR *target_family, DWORD flags)
1452 {
1453 return AddFontToList(file, NULL, 0, fake_family, target_family, flags);
1454 }
1455
1456 static void DumpFontList(void)
1457 {
1458 Family *family;
1459 Face *face;
1460 struct list *family_elem_ptr, *face_elem_ptr;
1461
1462 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1463 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1464 TRACE("Family: %s\n", debugstr_w(family->FamilyName));
1465 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1466 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1467 TRACE("\t%s\t%08x", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
1468 if(!face->scalable)
1469 TRACE(" %d", face->size.height);
1470 TRACE("\n");
1471 }
1472 }
1473 return;
1474 }
1475
1476 /***********************************************************
1477 * The replacement list is a way to map an entire font
1478 * family onto another family. For example adding
1479 *
1480 * [HKCU\Software\Wine\Fonts\Replacements]
1481 * "Wingdings"="Winedings"
1482 *
1483 * would enumerate the Winedings font both as Winedings and
1484 * Wingdings. However if a real Wingdings font is present the
1485 * replacement does not take place.
1486 *
1487 */
1488 static void LoadReplaceList(void)
1489 {
1490 HKEY hkey;
1491 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1492 LPWSTR value;
1493 LPVOID data;
1494 Family *family;
1495 Face *face;
1496 struct list *family_elem_ptr, *face_elem_ptr;
1497 CHAR familyA[400];
1498
1499 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1500 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
1501 {
1502 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1503 &valuelen, &datalen, NULL, NULL);
1504
1505 valuelen++; /* returned value doesn't include room for '\0' */
1506 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1507 data = HeapAlloc(GetProcessHeap(), 0, datalen);
1508
1509 dlen = datalen;
1510 vlen = valuelen;
1511 while(RegEnumValueW(hkey, i++, value, &vlen, NULL, &type, data,
1512 &dlen) == ERROR_SUCCESS) {
1513 TRACE("Got %s=%s\n", debugstr_w(value), debugstr_w(data));
1514 /* "NewName"="Oldname" */
1515 WideCharToMultiByte(CP_ACP, 0, value, -1, familyA, sizeof(familyA), NULL, NULL);
1516
1517 /* Find the old family and hence all of the font files
1518 in that family */
1519 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1520 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1521 if(!strcmpiW(family->FamilyName, data)) {
1522 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1523 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1524 TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
1525 debugstr_w(face->StyleName), familyA);
1526 /* Now add a new entry with the new family name */
1527 AddFontToList(face->file, face->font_data_ptr, face->font_data_size, familyA, family->FamilyName, ADDFONT_FORCE_BITMAP | (face->external ? ADDFONT_EXTERNAL_FONT : 0));
1528 }
1529 break;
1530 }
1531 }
1532 /* reset dlen and vlen */
1533 dlen = datalen;
1534 vlen = valuelen;
1535 }
1536 HeapFree(GetProcessHeap(), 0, data);
1537 HeapFree(GetProcessHeap(), 0, value);
1538 RegCloseKey(hkey);
1539 }
1540 }
1541
1542 /*************************************************************
1543 * init_system_links
1544 */
1545 static BOOL init_system_links(void)
1546 {
1547 static const WCHAR system_link[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1548 'W','i','n','d','o','w','s',' ','N','T','\\',
1549 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
1550 'S','y','s','t','e','m','L','i','n','k',0};
1551 HKEY hkey;
1552 BOOL ret = FALSE;
1553 DWORD type, max_val, max_data, val_len, data_len, index;
1554 WCHAR *value, *data;
1555 WCHAR *entry, *next;
1556 SYSTEM_LINKS *font_link, *system_font_link;
1557 CHILD_FONT *child_font;
1558 static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
1559 static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
1560 static const WCHAR System[] = {'S','y','s','t','e','m',0};
1561 FONTSIGNATURE fs;
1562 Family *family;
1563 Face *face;
1564 FontSubst *psub;
1565
1566 if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
1567 {
1568 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
1569 value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
1570 data = HeapAlloc(GetProcessHeap(), 0, max_data);
1571 val_len = max_val + 1;
1572 data_len = max_data;
1573 index = 0;
1574 while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
1575 {
1576 TRACE("%s:\n", debugstr_w(value));
1577
1578 memset(&fs, 0, sizeof(fs));
1579 font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
1580 psub = get_font_subst(&font_subst_list, value, -1);
1581 font_link->font_name = (psub)? strdupW(psub->to.name) : strdupW(value);
1582 list_init(&font_link->links);
1583 for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
1584 {
1585 WCHAR *face_name;
1586 CHILD_FONT *child_font;
1587
1588 TRACE("\t%s\n", debugstr_w(entry));
1589
1590 next = entry + strlenW(entry) + 1;
1591
1592 face_name = strchrW(entry, ',');
1593 if(face_name)
1594 {
1595 *face_name++ = 0;
1596 while(isspaceW(*face_name))
1597 face_name++;
1598
1599 psub = get_font_subst(&font_subst_list, face_name, -1);
1600 if(psub)
1601 face_name = psub->to.name;
1602 }
1603 face = find_face_from_filename(entry, face_name);
1604 if(!face)
1605 {
1606 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
1607 continue;
1608 }
1609
1610 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1611 child_font->face = face;
1612 child_font->font = NULL;
1613 fs.fsCsb[0] |= face->fs.fsCsb[0];
1614 fs.fsCsb[1] |= face->fs.fsCsb[1];
1615 TRACE("Adding file %s index %ld\n", child_font->face->file, child_font->face->face_index);
1616 list_add_tail(&font_link->links, &child_font->entry);
1617 }
1618 family = find_family_from_name(font_link->font_name);
1619 if(family)
1620 {
1621 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
1622 {
1623 face->fs_links = fs;
1624 }
1625 }
1626 list_add_tail(&system_links, &font_link->entry);
1627 val_len = max_val + 1;
1628 data_len = max_data;
1629 }
1630
1631 HeapFree(GetProcessHeap(), 0, value);
1632 HeapFree(GetProcessHeap(), 0, data);
1633 RegCloseKey(hkey);
1634 }
1635
1636 /* Explicitly add an entry for the system font, this links to Tahoma and any links
1637 that Tahoma has */
1638
1639 system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
1640 system_font_link->font_name = strdupW(System);
1641 list_init(&system_font_link->links);
1642
1643 face = find_face_from_filename(tahoma_ttf, Tahoma);
1644 if(face)
1645 {
1646 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1647 child_font->face = face;
1648 child_font->font = NULL;
1649 TRACE("Found Tahoma in %s index %ld\n", child_font->face->file, child_font->face->face_index);
1650 list_add_tail(&system_font_link->links, &child_font->entry);
1651 }
1652 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
1653 {
1654 if(!strcmpiW(font_link->font_name, Tahoma))
1655 {
1656 CHILD_FONT *font_link_entry;
1657 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
1658 {
1659 CHILD_FONT *new_child;
1660 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
1661 new_child->face = font_link_entry->face;
1662 new_child->font = NULL;
1663 list_add_tail(&system_font_link->links, &new_child->entry);
1664 }
1665 break;
1666 }
1667 }
1668 list_add_tail(&system_links, &system_font_link->entry);
1669 return ret;
1670 }
1671
1672 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
1673 {
1674 DIR *dir;
1675 struct dirent *dent;
1676 char path[MAX_PATH];
1677
1678 TRACE("Loading fonts from %s\n", debugstr_a(dirname));
1679
1680 dir = opendir(dirname);
1681 if(!dir) {
1682 WARN("Can't open directory %s\n", debugstr_a(dirname));
1683 return FALSE;
1684 }
1685 while((dent = readdir(dir)) != NULL) {
1686 struct stat statbuf;
1687
1688 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
1689 continue;
1690
1691 TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
1692
1693 sprintf(path, "%s/%s", dirname, dent->d_name);
1694
1695 if(stat(path, &statbuf) == -1)
1696 {
1697 WARN("Can't stat %s\n", debugstr_a(path));
1698 continue;
1699 }
1700 if(S_ISDIR(statbuf.st_mode))
1701 ReadFontDir(path, external_fonts);
1702 else
1703 AddFontFileToList(path, NULL, NULL, external_fonts ? ADDFONT_EXTERNAL_FONT : 0);
1704 }
1705 closedir(dir);
1706 return TRUE;
1707 }
1708
1709 static void load_fontconfig_fonts(void)
1710 {
1711 #ifdef SONAME_LIBFONTCONFIG
1712 void *fc_handle = NULL;
1713 FcConfig *config;
1714 FcPattern *pat;
1715 FcObjectSet *os;
1716 FcFontSet *fontset;
1717 int i, len;
1718 char *file;
1719 const char *ext;
1720
1721 fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
1722 if(!fc_handle) {
1723 TRACE("Wine cannot find the fontconfig library (%s).\n",
1724 SONAME_LIBFONTCONFIG);
1725 return;
1726 }
1727 #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;}
1728 LOAD_FUNCPTR(FcConfigGetCurrent);
1729 LOAD_FUNCPTR(FcFontList);
1730 LOAD_FUNCPTR(FcFontSetDestroy);
1731 LOAD_FUNCPTR(FcInit);
1732 LOAD_FUNCPTR(FcObjectSetAdd);
1733 LOAD_FUNCPTR(FcObjectSetCreate);
1734 LOAD_FUNCPTR(FcObjectSetDestroy);
1735 LOAD_FUNCPTR(FcPatternCreate);
1736 LOAD_FUNCPTR(FcPatternDestroy);
1737 LOAD_FUNCPTR(FcPatternGetBool);
1738 LOAD_FUNCPTR(FcPatternGetString);
1739 #undef LOAD_FUNCPTR
1740
1741 if(!pFcInit()) return;
1742
1743 config = pFcConfigGetCurrent();
1744 pat = pFcPatternCreate();
1745 os = pFcObjectSetCreate();
1746 pFcObjectSetAdd(os, FC_FILE);
1747 pFcObjectSetAdd(os, FC_SCALABLE);
1748 fontset = pFcFontList(config, pat, os);
1749 if(!fontset) return;
1750 for(i = 0; i < fontset->nfont; i++) {
1751 FcBool scalable;
1752
1753 if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
1754 continue;
1755 TRACE("fontconfig: %s\n", file);
1756
1757 /* We're just interested in OT/TT fonts for now, so this hack just
1758 picks up the scalable fonts without extensions .pf[ab] to save time
1759 loading every other font */
1760
1761 if(pFcPatternGetBool(fontset->fonts[i], FC_SCALABLE, 0, &scalable) == FcResultMatch && !scalable)
1762 {
1763 TRACE("not scalable\n");
1764 continue;
1765 }
1766
1767 len = strlen( file );
1768 if(len < 4) continue;
1769 ext = &file[ len - 3 ];
1770 if(strcasecmp(ext, "pfa") && strcasecmp(ext, "pfb"))
1771 AddFontFileToList(file, NULL, NULL, ADDFONT_EXTERNAL_FONT);
1772 }
1773 pFcFontSetDestroy(fontset);
1774 pFcObjectSetDestroy(os);
1775 pFcPatternDestroy(pat);
1776 sym_not_found:
1777 #endif
1778 return;
1779 }
1780
1781 static BOOL load_font_from_data_dir(LPCWSTR file)
1782 {
1783 BOOL ret = FALSE;
1784 const char *data_dir = wine_get_data_dir();
1785
1786 if (!data_dir) data_dir = wine_get_build_dir();
1787
1788 if (data_dir)
1789 {
1790 INT len;
1791 char *unix_name;
1792
1793 len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
1794
1795 unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
1796
1797 strcpy(unix_name, data_dir);
1798 strcat(unix_name, "/fonts/");
1799
1800 WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
1801
1802 EnterCriticalSection( &freetype_cs );
1803 ret = AddFontFileToList(unix_name, NULL, NULL, ADDFONT_FORCE_BITMAP);
1804 LeaveCriticalSection( &freetype_cs );
1805 HeapFree(GetProcessHeap(), 0, unix_name);
1806 }
1807 return ret;
1808 }
1809
1810 static BOOL load_font_from_winfonts_dir(LPCWSTR file)
1811 {
1812 static const WCHAR slashW[] = {'\\','\0'};
1813 BOOL ret = FALSE;
1814 WCHAR windowsdir[MAX_PATH];
1815 char *unixname;
1816
1817 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1818 strcatW(windowsdir, fontsW);
1819 strcatW(windowsdir, slashW);
1820 strcatW(windowsdir, file);
1821 if ((unixname = wine_get_unix_file_name(windowsdir))) {
1822 EnterCriticalSection( &freetype_cs );
1823 ret = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
1824 LeaveCriticalSection( &freetype_cs );
1825 HeapFree(GetProcessHeap(), 0, unixname);
1826 }
1827 return ret;
1828 }
1829
1830 static void load_system_fonts(void)
1831 {
1832 HKEY hkey;
1833 WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
1834 const WCHAR * const *value;
1835 DWORD dlen, type;
1836 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
1837 char *unixname;
1838
1839 if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
1840 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1841 strcatW(windowsdir, fontsW);
1842 for(value = SystemFontValues; *value; value++) {
1843 dlen = sizeof(data);
1844 if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
1845 type == REG_SZ) {
1846 BOOL added = FALSE;
1847
1848 sprintfW(pathW, fmtW, windowsdir, data);
1849 if((unixname = wine_get_unix_file_name(pathW))) {
1850 added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
1851 HeapFree(GetProcessHeap(), 0, unixname);
1852 }
1853 if (!added)
1854 load_font_from_data_dir(data);
1855 }
1856 }
1857 RegCloseKey(hkey);
1858 }
1859 }
1860
1861 /*************************************************************
1862 *
1863 * This adds registry entries for any externally loaded fonts
1864 * (fonts from fontconfig or FontDirs). It also deletes entries
1865 * of no longer existing fonts.
1866 *
1867 */
1868 static void update_reg_entries(void)
1869 {
1870 HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
1871 LPWSTR valueW;
1872 DWORD len, len_fam;
1873 Family *family;
1874 Face *face;
1875 struct list *family_elem_ptr, *face_elem_ptr;
1876 WCHAR *file;
1877 static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
1878 static const WCHAR spaceW[] = {' ', '\0'};
1879 char *path;
1880
1881 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
1882 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
1883 ERR("Can't create Windows font reg key\n");
1884 goto end;
1885 }
1886
1887 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
1888 0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
1889 ERR("Can't create Windows font reg key\n");
1890 goto end;
1891 }
1892
1893 if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
1894 0, NULL, 0, KEY_ALL_ACCESS, NULL, &external_key, NULL) != ERROR_SUCCESS) {
1895 ERR("Can't create external font reg key\n");
1896 goto end;
1897 }
1898
1899 /* enumerate the fonts and add external ones to the two keys */
1900
1901 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1902 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1903 len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
1904 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1905 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1906 if(!face->external) continue;
1907 len = len_fam;
1908 if(strcmpiW(face->StyleName, RegularW))
1909 len = len_fam + strlenW(face->StyleName) + 1;
1910 valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1911 strcpyW(valueW, family->FamilyName);
1912 if(len != len_fam) {
1913 strcatW(valueW, spaceW);
1914 strcatW(valueW, face->StyleName);
1915 }
1916 strcatW(valueW, TrueType);
1917
1918 file = wine_get_dos_file_name(face->file);
1919 if(file)
1920 len = strlenW(file) + 1;
1921 else
1922 {
1923 if((path = strrchr(face->file, '/')) == NULL)
1924 path = face->file;
1925 else
1926 path++;
1927 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
1928
1929 file = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1930 MultiByteToWideChar(CP_ACP, 0, path, -1, file, len);
1931 }
1932 RegSetValueExW(winnt_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1933 RegSetValueExW(win9x_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1934 RegSetValueExW(external_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1935
1936 HeapFree(GetProcessHeap(), 0, file);
1937 HeapFree(GetProcessHeap(), 0, valueW);
1938 }
1939 }
1940 end:
1941 if(external_key) RegCloseKey(external_key);
1942 if(win9x_key) RegCloseKey(win9x_key);
1943 if(winnt_key) RegCloseKey(winnt_key);
1944 return;
1945 }
1946
1947 static void delete_external_font_keys(void)
1948 {
1949 HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
1950 DWORD dlen, vlen, datalen, valuelen, i, type;
1951 LPWSTR valueW;
1952 LPVOID data;
1953
1954 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
1955 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
1956 ERR("Can't create Windows font reg key\n");
1957 goto end;
1958 }
1959
1960 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
1961 0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
1962 ERR("Can't create Windows font reg key\n");
1963 goto end;
1964 }
1965
1966 if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &external_key) != ERROR_SUCCESS) {
1967 ERR("Can't create external font reg key\n");
1968 goto end;
1969 }
1970
1971 /* Delete all external fonts added last time */
1972
1973 RegQueryInfoKeyW(external_key, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1974 &valuelen, &datalen, NULL, NULL);
1975 valuelen++; /* returned value doesn't include room for '\0' */
1976 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1977 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
1978
1979 dlen = datalen * sizeof(WCHAR);
1980 vlen = valuelen;
1981 i = 0;
1982 while(RegEnumValueW(external_key, i++, valueW, &vlen, NULL, &type, data,
1983 &dlen) == ERROR_SUCCESS) {
1984
1985 RegDeleteValueW(winnt_key, valueW);
1986 RegDeleteValueW(win9x_key, valueW);
1987 /* reset dlen and vlen */
1988 dlen = datalen;
1989 vlen = valuelen;
1990 }
1991 HeapFree(GetProcessHeap(), 0, data);
1992 HeapFree(GetProcessHeap(), 0, valueW);
1993
1994 /* Delete the old external fonts key */
1995 RegCloseKey(external_key);
1996 RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
1997
1998 end:
1999 if(win9x_key) RegCloseKey(win9x_key);
2000 if(winnt_key) RegCloseKey(winnt_key);
2001 }
2002
2003 /*************************************************************
2004 * WineEngAddFontResourceEx
2005 *
2006 */
2007 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2008 {
2009 INT ret = 0;
2010 if (ft_handle) /* do it only if we have freetype up and running */
2011 {
2012 char *unixname;
2013
2014 if(flags)
2015 FIXME("Ignoring flags %x\n", flags);
2016
2017 if((unixname = wine_get_unix_file_name(file)))
2018 {
2019 EnterCriticalSection( &freetype_cs );
2020 ret = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2021 LeaveCriticalSection( &freetype_cs );
2022 HeapFree(GetProcessHeap(), 0, unixname);
2023 }
2024 if (!ret && !strchrW(file, '\\')) {
2025 /* Try in %WINDIR%/fonts, needed for Fotobuch Designer */
2026 ret = load_font_from_winfonts_dir(file);
2027 if (!ret) {
2028 /* Try in datadir/fonts (or builddir/fonts),
2029 * needed for Magic the Gathering Online
2030 */
2031 ret = load_font_from_data_dir(file);
2032 }
2033 }
2034 }
2035 return ret;
2036 }
2037
2038 /*************************************************************
2039 * WineEngAddFontMemResourceEx
2040 *
2041 */
2042 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
2043 {
2044 if (ft_handle) /* do it only if we have freetype up and running */
2045 {
2046 PVOID pFontCopy = HeapAlloc(GetProcessHeap(), 0, cbFont);
2047
2048 TRACE("Copying %d bytes of data from %p to %p\n", cbFont, pbFont, pFontCopy);
2049 memcpy(pFontCopy, pbFont, cbFont);
2050
2051 EnterCriticalSection( &freetype_cs );
2052 *pcFonts = AddFontToList(NULL, pFontCopy, cbFont, NULL, NULL, ADDFONT_FORCE_BITMAP);
2053 LeaveCriticalSection( &freetype_cs );
2054
2055 if (*pcFonts == 0)
2056 {
2057 TRACE("AddFontToList failed\n");
2058 HeapFree(GetProcessHeap(), 0, pFontCopy);
2059 return NULL;
2060 }
2061 /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
2062 * For now return something unique but quite random
2063 */
2064 TRACE("Returning handle %lx\n", ((INT_PTR)pFontCopy)^0x87654321);
2065 return (HANDLE)(((INT_PTR)pFontCopy)^0x87654321);
2066 }
2067
2068 *pcFonts = 0;
2069 return 0;
2070 }
2071
2072 /*************************************************************
2073 * WineEngRemoveFontResourceEx
2074 *
2075 */
2076 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2077 {
2078 FIXME(":stub\n");
2079 return TRUE;
2080 }
2081
2082 static const struct nls_update_font_list
2083 {
2084 UINT ansi_cp, oem_cp;
2085 const char *oem, *fixed, *system;
2086 const char *courier, *serif, *small, *sserif;
2087 /* these are for font substitute */
2088 const char *shelldlg, *tmsrmn;
2089 } nls_update_font_list[] =
2090 {
2091 /* Latin 1 (United States) */
2092 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
2093 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2094 "Tahoma","Times New Roman",
2095 },
2096 /* Latin 1 (Multilingual) */
2097 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
2098 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2099 "Tahoma","Times New Roman", /* FIXME unverified */
2100 },
2101 /* Eastern Europe */
2102 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
2103 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
2104 "Tahoma","Times New Roman", /* FIXME unverified */
2105 },
2106 /* Cyrillic */
2107 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
2108 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
2109 "Tahoma","Times New Roman", /* FIXME unverified */
2110 },
2111 /* Greek */
2112 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
2113 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
2114 "Tahoma","Times New Roman", /* FIXME unverified */
2115 },
2116 /* Turkish */
2117 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
2118 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
2119 "Tahoma","Times New Roman", /* FIXME unverified */
2120 },
2121 /* Hebrew */
2122 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
2123 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
2124 "Tahoma","Times New Roman", /* FIXME unverified */
2125 },
2126 /* Arabic */
2127 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
2128 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
2129 "Tahoma","Times New Roman", /* FIXME unverified */
2130 },
2131 /* Baltic */
2132 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
2133 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
2134 "Tahoma","Times New Roman", /* FIXME unverified */
2135 },
2136 /* Vietnamese */
2137 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
2138 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2139 "Tahoma","Times New Roman", /* FIXME unverified */
2140 },
2141 /* Thai */
2142 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
2143 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
2144 "Tahoma","Times New Roman", /* FIXME unverified */
2145 },
2146 /* Japanese */
2147 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
2148 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
2149 "MS UI Gothic","MS Serif",
2150 },
2151 /* Chinese Simplified */
2152 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
2153 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2154 "Tahoma", "Times New Roman", /* FIXME unverified */
2155 },
2156 /* Korean */
2157 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
2158 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2159 "Gulim", "Batang",
2160 },
2161 /* Chinese Traditional */
2162 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
2163 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2164 "PMingLiU", "MingLiU",
2165 }
2166 };
2167
2168 static inline HKEY create_fonts_NT_registry_key(void)
2169 {
2170 HKEY hkey = 0;
2171
2172 RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
2173 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2174 return hkey;
2175 }
2176
2177 static inline HKEY create_fonts_9x_registry_key(void)
2178 {
2179 HKEY hkey = 0;
2180
2181 RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
2182 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2183 return hkey;
2184 }
2185
2186 static inline HKEY create_config_fonts_registry_key(void)
2187 {
2188 HKEY hkey = 0;
2189
2190 RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
2191 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2192 return hkey;
2193 }
2194
2195 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl)
2196 {
2197 RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
2198 RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
2199 RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)fl->sserif, strlen(fl->sserif)+1);
2200 RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
2201 }
2202
2203 static void update_font_info(void)
2204 {
2205 char buf[40], cpbuf[40];
2206 DWORD len, type;
2207 HKEY hkey = 0;
2208 UINT i, ansi_cp = 0, oem_cp = 0;
2209
2210 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL) != ERROR_SUCCESS)
2211 return;
2212
2213 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
2214 (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
2215 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
2216 (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
2217 sprintf( cpbuf, "%u,%u", ansi_cp, oem_cp );
2218
2219 /* Setup Default_Fallback usage */
2220 if (ansi_cp == 932)
2221 use_default_fallback = TRUE;
2222
2223 len = sizeof(buf);
2224 if (RegQueryValueExA(hkey, "Codepages", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
2225 {
2226 if (!strcmp( buf, cpbuf )) /* already set correctly */
2227 {
2228 RegCloseKey(hkey);
2229 return;
2230 }
2231 TRACE("updating registry, codepages changed %s -> %u,%u\n", buf, ansi_cp, oem_cp);
2232 }
2233 else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp, oem_cp);
2234
2235 RegSetValueExA(hkey, "Codepages", 0, REG_SZ, (const BYTE *)cpbuf, strlen(cpbuf)+1);
2236 RegCloseKey(hkey);
2237
2238 for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
2239 {
2240 if (nls_update_font_list[i].ansi_cp == ansi_cp &&
2241 nls_update_font_list[i].oem_cp == oem_cp)
2242 {
2243 HKEY hkey;
2244
2245 hkey = create_config_fonts_registry_key();
2246 RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
2247 RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
2248 RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
2249 RegCloseKey(hkey);
2250
2251 hkey = create_fonts_NT_registry_key();
2252 add_font_list(hkey, &nls_update_font_list[i]);
2253 RegCloseKey(hkey);
2254
2255 hkey = create_fonts_9x_registry_key();
2256 add_font_list(hkey, &nls_update_font_list[i]);
2257 RegCloseKey(hkey);
2258
2259 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
2260 {
2261 RegSetValueExA(hkey, "MS Shell Dlg", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].shelldlg,
2262 strlen(nls_update_font_list[i].shelldlg)+1);
2263 RegSetValueExA(hkey, "Tms Rmn", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].tmsrmn,
2264 strlen(nls_update_font_list[i].tmsrmn)+1);
2265 RegCloseKey(hkey);
2266 }
2267 return;
2268 }
2269 }
2270 FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp, oem_cp);
2271 }
2272
2273
2274 static BOOL init_freetype(void)
2275 {
2276 ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
2277 if(!ft_handle) {
2278 WINE_MESSAGE(
2279 "Wine cannot find the FreeType font library. To enable Wine to\n"
2280 "use TrueType fonts please install a version of FreeType greater than\n"
2281 "or equal to 2.0.5.\n"
2282 "http://www.freetype.org\n");
2283 return FALSE;
2284 }
2285
2286 #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;}
2287
2288 LOAD_FUNCPTR(FT_Vector_Unit)
2289 LOAD_FUNCPTR(FT_Done_Face)
2290 LOAD_FUNCPTR(FT_Get_Char_Index)
2291 LOAD_FUNCPTR(FT_Get_Module)
2292 LOAD_FUNCPTR(FT_Get_Sfnt_Name)
2293 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
2294 LOAD_FUNCPTR(FT_Get_Sfnt_Table)
2295 LOAD_FUNCPTR(FT_Init_FreeType)
2296 LOAD_FUNCPTR(FT_Load_Glyph)
2297 LOAD_FUNCPTR(FT_Matrix_Multiply)
2298 LOAD_FUNCPTR(FT_MulFix)
2299 LOAD_FUNCPTR(FT_New_Face)
2300 LOAD_FUNCPTR(FT_New_Memory_Face)
2301 LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
2302 LOAD_FUNCPTR(FT_Outline_Transform)
2303 LOAD_FUNCPTR(FT_Outline_Translate)
2304 LOAD_FUNCPTR(FT_Select_Charmap)
2305 LOAD_FUNCPTR(FT_Set_Charmap)
2306 LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
2307 LOAD_FUNCPTR(FT_Vector_Transform)
2308
2309 #undef LOAD_FUNCPTR
2310 /* Don't warn if these ones are missing */
2311 pFT_Library_Version = wine_dlsym(ft_handle, "FT_Library_Version", NULL, 0);
2312 pFT_Load_Sfnt_Table = wine_dlsym(ft_handle, "FT_Load_Sfnt_Table", NULL, 0);
2313 pFT_Get_First_Char = wine_dlsym(ft_handle, "FT_Get_First_Char", NULL, 0);
2314 pFT_Get_Next_Char = wine_dlsym(ft_handle, "FT_Get_Next_Char", NULL, 0);
2315 pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
2316 #ifdef HAVE_FREETYPE_FTWINFNT_H
2317 pFT_Get_WinFNT_Header = wine_dlsym(ft_handle, "FT_Get_WinFNT_Header", NULL, 0);
2318 #endif
2319 if(!wine_dlsym(ft_handle, "FT_Get_Postscript_Name", NULL, 0) &&
2320 !wine_dlsym(ft_handle, "FT_Sqrt64", NULL, 0)) {
2321 /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
2322 <= 2.0.3 has FT_Sqrt64 */
2323 goto sym_not_found;
2324 }
2325
2326 if(pFT_Init_FreeType(&library) != 0) {
2327 ERR("Can't init FreeType library\n");
2328 wine_dlclose(ft_handle, NULL, 0);
2329 ft_handle = NULL;
2330 return FALSE;
2331 }
2332 FT_Version.major = FT_Version.minor = FT_Version.patch = -1;
2333 if (pFT_Library_Version)
2334 pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
2335
2336 if (FT_Version.major<=0)
2337 {
2338 FT_Version.major=2;
2339 FT_Version.minor=0;
2340 FT_Version.patch=5;
2341 }
2342 TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
2343 FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
2344 ((FT_Version.minor << 8) & 0x00ff00) |
2345 ((FT_Version.patch ) & 0x0000ff);
2346
2347 return TRUE;
2348
2349 sym_not_found:
2350 WINE_MESSAGE(
2351 "Wine cannot find certain functions that it needs inside the FreeType\n"
2352 "font library. To enable Wine to use TrueType fonts please upgrade\n"
2353 "FreeType to at least version 2.0.5.\n"
2354 "http://www.freetype.org\n");
2355 wine_dlclose(ft_handle, NULL, 0);
2356 ft_handle = NULL;
2357 return FALSE;
2358 }
2359
2360 /*************************************************************
2361 * WineEngInit
2362 *
2363 * Initialize FreeType library and create a list of available faces
2364 */
2365 BOOL WineEngInit(void)
2366 {
2367 static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
2368 static const WCHAR pathW[] = {'P','a','t','h',0};
2369 HKEY hkey;
2370 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
2371 LPVOID data;
2372 WCHAR windowsdir[MAX_PATH];
2373 char *unixname;
2374 HANDLE font_mutex;
2375 const char *data_dir;
2376
2377 TRACE("\n");
2378
2379 /* update locale dependent font info in registry */
2380 update_font_info();
2381
2382 if(!init_freetype()) return FALSE;
2383
2384 if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL) {
2385 ERR("Failed to create font mutex\n");
2386 return FALSE;
2387 }
2388 WaitForSingleObject(font_mutex, INFINITE);
2389
2390 delete_external_font_keys();
2391
2392 /* load the system bitmap fonts */
2393 load_system_fonts();
2394
2395 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
2396 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2397 strcatW(windowsdir, fontsW);
2398 if((unixname = wine_get_unix_file_name(windowsdir)))
2399 {
2400 ReadFontDir(unixname, FALSE);
2401 HeapFree(GetProcessHeap(), 0, unixname);
2402 }
2403
2404 /* load the system truetype fonts */
2405 data_dir = wine_get_data_dir();
2406 if (!data_dir) data_dir = wine_get_build_dir();
2407 if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/")))) {
2408 strcpy(unixname, data_dir);
2409 strcat(unixname, "/fonts/");
2410 ReadFontDir(unixname, TRUE);
2411 HeapFree(GetProcessHeap(), 0, unixname);
2412 }
2413
2414 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
2415 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
2416 full path as the entry. Also look for any .fon fonts, since ReadFontDir
2417 will skip these. */
2418 if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
2419 is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
2420 &hkey) == ERROR_SUCCESS) {
2421 LPWSTR valueW;
2422 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2423 &valuelen, &datalen, NULL, NULL);
2424
2425 valuelen++; /* returned value doesn't include room for '\0' */
2426 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2427 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
2428 if (valueW && data)
2429 {
2430 dlen = datalen * sizeof(WCHAR);
2431 vlen = valuelen;
2432 while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, data,
2433 &dlen) == ERROR_SUCCESS) {
2434 if(((LPWSTR)data)[0] && ((LPWSTR)data)[1] == ':')
2435 {
2436 if((unixname = wine_get_unix_file_name((LPWSTR)data)))
2437 {
2438 AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2439 HeapFree(GetProcessHeap(), 0, unixname);
2440 }
2441 }
2442 else if(dlen / 2 >= 6 && !strcmpiW(((LPWSTR)data) + dlen / 2 - 5, dot_fonW))
2443 {
2444 WCHAR pathW[MAX_PATH];
2445 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
2446 BOOL added = FALSE;
2447
2448 sprintfW(pathW, fmtW, windowsdir, data);
2449 if((unixname = wine_get_unix_file_name(pathW)))
2450 {
2451 added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2452 HeapFree(GetProcessHeap(), 0, unixname);
2453 }
2454 if (!added)
2455 load_font_from_data_dir(data);
2456 }
2457 /* reset dlen and vlen */
2458 dlen = datalen;
2459 vlen = valuelen;
2460 }
2461 }
2462 HeapFree(GetProcessHeap(), 0, data);
2463 HeapFree(GetProcessHeap(), 0, valueW);
2464 RegCloseKey(hkey);
2465 }
2466
2467 load_fontconfig_fonts();
2468
2469 /* then look in any directories that we've specified in the config file */
2470 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
2471 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
2472 {
2473 DWORD len;
2474 LPWSTR valueW;
2475 LPSTR valueA, ptr;
2476
2477 if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
2478 {
2479 len += sizeof(WCHAR);
2480 valueW = HeapAlloc( GetProcessHeap(), 0, len );
2481 if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
2482 {
2483 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
2484 valueA = HeapAlloc( GetProcessHeap(), 0, len );
2485 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
2486 TRACE( "got font path %s\n", debugstr_a(valueA) );
2487 ptr = valueA;
2488 while (ptr)
2489 {
2490 LPSTR next = strchr( ptr, ':' );
2491 if (next) *next++ = 0;
2492 ReadFontDir( ptr, TRUE );
2493 ptr = next;
2494 }
2495 HeapFree( GetProcessHeap(), 0, valueA );
2496 }
2497 HeapFree( GetProcessHeap(), 0, valueW );
2498 }
2499 RegCloseKey(hkey);
2500 }
2501
2502 DumpFontList();
2503 LoadSubstList();
2504 DumpSubstList();
2505 LoadReplaceList();
2506 update_reg_entries();
2507
2508 init_system_links();
2509
2510 ReleaseMutex(font_mutex);
2511 return TRUE;
2512 }
2513
2514
2515 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
2516 {
2517 TT_OS2 *pOS2;
2518 TT_HoriHeader *pHori;
2519
2520 LONG ppem;
2521
2522 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
2523 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
2524
2525 if(height == 0) height = 16;
2526
2527 /* Calc. height of EM square:
2528 *
2529 * For +ve lfHeight we have
2530 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
2531 * Re-arranging gives:
2532 * ppem = units_per_em * lfheight / (winAscent + winDescent)
2533 *
2534 * For -ve lfHeight we have
2535 * |lfHeight| = ppem
2536 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
2537 * with il = winAscent + winDescent - units_per_em]
2538 *
2539 */
2540
2541 if(height > 0) {
2542 if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
2543 ppem = ft_face->units_per_EM * height /
2544 (pHori->Ascender - pHori->Descender);
2545 else
2546 ppem = ft_face->units_per_EM * height /
2547 (pOS2->usWinAscent + pOS2->usWinDescent);
2548 }
2549 else
2550 ppem = -height;
2551
2552 return ppem;
2553 }
2554
2555 static struct font_mapping *map_font_file( const char *name )
2556 {
2557 struct font_mapping *mapping;
2558 struct stat st;
2559 int fd;
2560
2561 if ((fd = open( name, O_RDONLY )) == -1) return NULL;
2562 if (fstat( fd, &st ) == -1) goto error;
2563
2564 LIST_FOR_EACH_ENTRY( mapping, &mappings_list, struct font_mapping, entry )
2565 {
2566 if (mapping->dev == st.st_dev && mapping->ino == st.st_ino)
2567 {
2568 mapping->refcount++;
2569 close( fd );
2570 return mapping;
2571 }
2572 }
2573 if (!(mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping) )))
2574 goto error;
2575
2576 mapping->data = mmap( NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );
2577 close( fd );
2578
2579 if (mapping->data == MAP_FAILED)
2580 {
2581 HeapFree( GetProcessHeap(), 0, mapping );
2582 return NULL;
2583 }
2584 mapping->refcount = 1;
2585 mapping->dev = st.st_dev;
2586 mapping->ino = st.st_ino;
2587 mapping->size = st.st_size;
2588 list_add_tail( &mappings_list, &mapping->entry );
2589 return mapping;
2590
2591 error:
2592 close( fd );
2593 return NULL;
2594 }
2595
2596 static void unmap_font_file( struct font_mapping *mapping )
2597 {
2598 if (!--mapping->refcount)
2599 {
2600 list_remove( &mapping->entry );
2601 munmap( mapping->data, mapping->size );
2602 HeapFree( GetProcessHeap(), 0, mapping );
2603 }
2604 }
2605
2606 static LONG load_VDMX(GdiFont*, LONG);
2607
2608 static FT_Face OpenFontFace(GdiFont *font, Face *face, LONG width, LONG height)
2609 {
2610 FT_Error err;
2611 FT_Face ft_face;
2612 void *data_ptr;
2613 DWORD data_size;
2614
2615 TRACE("%s/%p, %ld, %d x %d\n", debugstr_a(face->file), face->font_data_ptr, face->face_index, width, height);
2616
2617 if (face->file)
2618 {
2619 if (!(font->mapping = map_font_file( face->file )))
2620 {
2621 WARN("failed to map %s\n", debugstr_a(face->file));
2622 return 0;
2623 }
2624 data_ptr = font->mapping->data;
2625 data_size = font->mapping->size;
2626 }
2627 else
2628 {
2629 data_ptr = face->font_data_ptr;
2630 data_size = face->font_data_size;
2631 }
2632
2633 err = pFT_New_Memory_Face(library, data_ptr, data_size, face->face_index, &ft_face);
2634 if(err) {
2635 ERR("FT_New_Face rets %d\n", err);
2636 return 0;
2637 }
2638
2639 /* set it here, as load_VDMX needs it */
2640 font->ft_face = ft_face;
2641
2642 if(FT_IS_SCALABLE(ft_face)) {
2643 /* load the VDMX table if we have one */
2644 font->ppem = load_VDMX(font, height);
2645 if(font->ppem == 0)
2646 font->ppem = calc_ppem_for_height(ft_face, height);
2647
2648 if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
2649 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font->ppem, err);
2650 } else {
2651 font->ppem = height;
2652 if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
2653 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width, height, err);
2654 }
2655 return ft_face;
2656 }
2657
2658
2659 static int get_nearest_charset(Face *face, int *cp)
2660 {
2661 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
2662 a single face with the requested charset. The idea is to check if
2663 the selected font supports the current ANSI codepage, if it does
2664 return the corresponding charset, else return the first charset */
2665
2666 CHARSETINFO csi;
2667 int acp = GetACP(), i;
2668 DWORD fs0;
2669
2670 *cp = acp;
2671 if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
2672 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
2673 return csi.ciCharset;
2674
2675 for(i = 0; i < 32; i++) {
2676 fs0 = 1L << i;
2677 if(face->fs.fsCsb[0] & fs0) {
2678 if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
2679 *cp = csi.ciACP;
2680 return csi.ciCharset;
2681 }
2682 else
2683 FIXME("TCI failing on %x\n", fs0);
2684 }
2685 }
2686
2687 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
2688 face->fs.fsCsb[0], face->file);
2689 *cp = acp;
2690 return DEFAULT_CHARSET;
2691 }
2692
2693 static GdiFont *alloc_font(void)
2694 {
2695 GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
2696 ret->gmsize = 1;
2697 ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM*));
2698 ret->gm[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
2699 ret->potm = NULL;
2700 ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
2701 ret->total_kern_pairs = (DWORD)-1;
2702 ret->kern_pairs = NULL;
2703 list_init(&ret->hfontlist);
2704 list_init(&ret->child_fonts);
2705 return ret;
2706 }
2707
2708 static void free_font(GdiFont *font)
2709 {
2710 struct list *cursor, *cursor2;
2711 int i;
2712
2713 LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
2714 {
2715 CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
2716 struct list *first_hfont;
2717 HFONTLIST *hfontlist;
2718 list_remove(cursor);
2719 if(child->font)
2720 {
2721 first_hfont = list_head(&child->font->hfontlist);
2722 hfontlist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2723 DeleteObject(hfontlist->hfont);
2724 HeapFree(GetProcessHeap(), 0, hfontlist);
2725 free_font(child->font);
2726 }
2727 HeapFree(GetProcessHeap(), 0, child);
2728 }
2729
2730 if (font->ft_face) pFT_Done_Face(font->ft_face);
2731 if (font->mapping) unmap_font_file( font->mapping );
2732 HeapFree(GetProcessHeap(), 0, font->kern_pairs);
2733 HeapFree(GetProcessHeap(), 0, font->potm);
2734 HeapFree(GetProcessHeap(), 0, font->name);
2735 for (i = 0; i < font->gmsize; i++)
2736 HeapFree(GetProcessHeap(),0,font->gm[i]);
2737 HeapFree(GetProcessHeap(), 0, font->gm);
2738 HeapFree(GetProcessHeap(), 0, font->GSUB_Table);
2739 HeapFree(GetProcessHeap(), 0, font);
2740 }
2741
2742
2743 /*************************************************************
2744 * load_VDMX
2745 *
2746 * load the vdmx entry for the specified height
2747 */
2748
2749 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
2750 ( ( (FT_ULong)_x4 << 24 ) | \
2751 ( (FT_ULong)_x3 << 16 ) | \
2752 ( (FT_ULong)_x2 << 8 ) | \
2753 (FT_ULong)_x1 )
2754
2755 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
2756
2757 typedef struct {
2758 BYTE bCharSet;
2759 BYTE xRatio;
2760 BYTE yStartRatio;
2761 BYTE yEndRatio;
2762 } Ratios;
2763
2764 typedef struct {
2765 WORD recs;
2766 BYTE startsz;
2767 BYTE endsz;
2768 } VDMX_group;
2769
2770 static LONG load_VDMX(GdiFont *font, LONG height)
2771 {
2772 WORD hdr[3], tmp;
2773 VDMX_group group;
2774 BYTE devXRatio, devYRatio;
2775 USHORT numRecs, numRatios;
2776 DWORD result, offset = -1;
2777 LONG ppem = 0;
2778 int i;
2779
2780 result = WineEngGetFontData(font, MS_VDMX_TAG, 0, hdr, 6);
2781
2782 if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
2783 return ppem;
2784
2785 /* FIXME: need the real device aspect ratio */
2786 devXRatio = 1;
2787 devYRatio = 1;
2788
2789 numRecs = GET_BE_WORD(hdr[1]);
2790 numRatios = GET_BE_WORD(hdr[2]);
2791
2792 TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
2793 for(i = 0; i < numRatios; i++) {
2794 Ratios ratio;
2795
2796 offset = (3 * 2) + (i * sizeof(Ratios));
2797 WineEngGetFontData(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
2798 offset = -1;
2799
2800 TRACE("Ratios[%d] %d %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
2801
2802 if((ratio.xRatio == 0 &&
2803 ratio.yStartRatio == 0 &&
2804 ratio.yEndRatio == 0) ||
2805 (devXRatio == ratio.xRatio &&
2806 devYRatio >= ratio.yStartRatio &&
2807 devYRatio <= ratio.yEndRatio))
2808 {
2809 offset = (3 * 2) + (numRatios * 4) + (i * 2);
2810 WineEngGetFontData(font, MS_VDMX_TAG, offset, &tmp, 2);
2811 offset = GET_BE_WORD(tmp);
2812 break;
2813 }
2814 }
2815
2816 if(offset == -1) {
2817 FIXME("No suitable ratio found\n");
2818 return ppem;
2819 }
2820
2821 if(WineEngGetFontData(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
2822 USHORT recs;
2823 BYTE startsz, endsz;
2824 WORD *vTable;
2825
2826 recs = GET_BE_WORD(group.recs);
2827 startsz = group.startsz;
2828 endsz = group.endsz;
2829
2830 TRACE("recs=%d startsz=%d endsz=%d\n", recs, startsz, endsz);
2831
2832 vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
2833 result = WineEngGetFontData(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
2834 if(result == GDI_ERROR) {
2835 FIXME("Failed to retrieve vTable\n");
2836 goto end;
2837 }
2838
2839 if(height > 0) {
2840 for(i = 0; i < recs; i++) {
2841 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2842 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2843 ppem = GET_BE_WORD(vTable[i * 3]);
2844
2845 if(yMax + -yMin == height) {
2846 font->yMax = yMax;
2847 font->yMin = yMin;
2848 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
2849 break;
2850 }
2851 if(yMax + -yMin > height) {
2852 if(--i < 0) {
2853 ppem = 0;
2854 goto end; /* failed */
2855 }
2856 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2857 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2858 ppem = GET_BE_WORD(vTable[i * 3]);
2859 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
2860 break;
2861 }
2862 }
2863 if(!font->yMax) {
2864 ppem = 0;
2865 TRACE("ppem not found for height %d\n", height);
2866 }
2867 } else {
2868 ppem = -height;
2869 if(ppem < startsz || ppem > endsz)
2870 goto end;
2871
2872 for(i = 0; i < recs; i++) {
2873 USHORT yPelHeight;
2874 yPelHeight = GET_BE_WORD(vTable[i * 3]);
2875
2876 if(yPelHeight > ppem)
2877 break; /* failed */
2878
2879 if(yPelHeight == ppem) {
2880 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2881 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2882 TRACE("ppem %d found; yMax=%d yMin=%d\n", ppem, font->yMax, font->yMin);
2883 break;
2884 }
2885 }
2886 }
2887 end:
2888 HeapFree(GetProcessHeap(), 0, vTable);
2889 }
2890
2891 return ppem;
2892 }
2893
2894 static BOOL fontcmp(const GdiFont *font, FONT_DESC *fd)
2895 {
2896 if(font->font_desc.hash != fd->hash) return TRUE;
2897 if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
2898 if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
2899 if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
2900 return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
2901 }
2902
2903 static void calc_hash(FONT_DESC *pfd)
2904 {
2905 DWORD hash = 0, *ptr, two_chars;
2906 WORD *pwc;
2907 unsigned int i;
2908
2909 for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
2910 hash ^= *ptr;
2911 for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
2912 hash ^= *ptr;
2913 for(i = 0, ptr = (DWORD*)&pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
2914 two_chars = *ptr;
2915 pwc = (WCHAR *)&two_chars;
2916 if(!*pwc) break;
2917 *pwc = toupperW(*pwc);
2918 pwc++;
2919 *pwc = toupperW(*pwc);
2920 hash ^= two_chars;
2921 if(!*pwc) break;
2922 }
2923 hash ^= !pfd->can_use_bitmap;
2924 pfd->hash = hash;
2925 return;
2926 }
2927
2928 static GdiFont *find_in_cache(HFONT hfont, LOGFONTW *plf, XFORM *pxf, BOOL can_use_bitmap)
2929 {
2930 GdiFont *ret;
2931 FONT_DESC fd;
2932 HFONTLIST *hflist;
2933 struct list *font_elem_ptr, *hfontlist_elem_ptr;
2934
2935 fd.lf = *plf;
2936 memcpy(&fd.matrix, pxf, sizeof(FMAT2));
2937 fd.can_use_bitmap = can_use_bitmap;
2938 calc_hash(&fd);
2939
2940 /* try the in-use list */
2941 LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
2942 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2943 if(!fontcmp(ret, &fd)) {
2944 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2945 LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
2946 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
2947 if(hflist->hfont == hfont)
2948 return ret;
2949 }
2950 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2951 hflist->hfont = hfont;
2952 list_add_head(&ret->hfontlist, &hflist->entry);
2953 return ret;
2954 }
2955 }
2956
2957 /* then the unused list */
2958 font_elem_ptr = list_head(&unused_gdi_font_list);
2959 while(font_elem_ptr) {
2960 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2961 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2962 if(!fontcmp(ret, &fd)) {
2963 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2964 assert(list_empty(&ret->hfontlist));
2965 TRACE("Found %p in unused list\n", ret);
2966 list_remove(&ret->entry);
2967 list_add_head(&gdi_font_list, &ret->entry);
2968 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2969 hflist->hfont = hfont;
2970 list_add_head(&ret->hfontlist, &hflist->entry);
2971 return ret;
2972 }
2973 }
2974 return NULL;
2975 }
2976
2977
2978 /*************************************************************
2979 * create_child_font_list
2980 */
2981 static BOOL create_child_font_list(GdiFont *font)
2982 {
2983 BOOL ret = FALSE;
2984 SYSTEM_LINKS *font_link;
2985 CHILD_FONT *font_link_entry, *new_child;
2986
2987 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2988 {
2989 if(!strcmpW(font_link->font_name, font->name))
2990 {
2991 TRACE("found entry in system list\n");
2992 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2993 {
2994 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
2995 new_child->face = font_link_entry->face;
2996 new_child->font = NULL;
2997 list_add_tail(&font->child_fonts, &new_child->entry);
2998 TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
2999 }
3000 ret = TRUE;
3001 break;
3002 }
3003 }
3004 /*
3005 * if not SYMBOL or OEM then we also get all the fonts for Microsoft
3006 * Sans Serif. This is how asian windows get default fallbacks for fonts
3007 */
3008 if (use_default_fallback && font->charset != SYMBOL_CHARSET &&
3009 font->charset != OEM_CHARSET &&
3010 strcmpW(font->name,szDefaultFallbackLink) != 0)
3011 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
3012 {
3013 if(!strcmpW(font_link->font_name,szDefaultFallbackLink))
3014 {
3015 TRACE("found entry in default fallback list\n");
3016 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
3017 {
3018 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
3019 new_child->face = font_link_entry->face;
3020 new_child->font = NULL;
3021 list_add_tail(&font->child_fonts, &new_child->entry);
3022 TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
3023 }
3024 ret = TRUE;
3025 break;
3026 }
3027 }
3028
3029 return ret;
3030 }
3031
3032 static BOOL select_charmap(FT_Face ft_face, FT_Encoding encoding)
3033 {
3034 FT_Error ft_err = FT_Err_Invalid_CharMap_Handle;
3035
3036 if (pFT_Set_Charmap)
3037 {
3038 FT_Int i;
3039 FT_CharMap cmap0, cmap1, cmap2, cmap3, cmap_def;
3040
3041 cmap0 = cmap1 = cmap2 = cmap3 = cmap_def = NULL;
3042
3043 for (i = 0; i < ft_face->num_charmaps; i++)
3044 {
3045 if (ft_face->charmaps[i]->encoding == encoding)
3046 {
3047 TRACE("found cmap with platform_id %u, encoding_id %u\n",
3048 ft_face->charmaps[i]->platform_id, ft_face->charmaps[i]->encoding_id);
3049
3050 switch (ft_face->charmaps[i]->platform_id)
3051 {
3052 default:
3053 cmap_def = ft_face->charmaps[i];
3054 break;
3055 case 0: /* Apple Unicode */
3056 cmap0 = ft_face->charmaps[i];
3057 break;
3058 case 1: /* Macintosh */
3059 cmap1 = ft_face->charmaps[i];
3060 break;
3061 case 2: /* ISO */
3062 cmap2 = ft_face->charmaps[i];
3063 break;
3064 case 3: /* Microsoft */
3065 cmap3 = ft_face->charmaps[i];
3066 break;
3067 }
3068 }
3069
3070 if (cmap3) /* prefer Microsoft cmap table */
3071 ft_err = pFT_Set_Charmap(ft_face, cmap3);
3072 else if (cmap1)
3073 ft_err = pFT_Set_Charmap(ft_face, cmap1);
3074 else if (cmap2)
3075 ft_err = pFT_Set_Charmap(ft_face, cmap2);
3076 else if (cmap0)
3077 ft_err = pFT_Set_Charmap(ft_face, cmap0);
3078 else if (cmap_def)
3079 ft_err = pFT_Set_Charmap(ft_face, cmap_def);
3080 }
3081 return ft_err == FT_Err_Ok;
3082 }
3083
3084 return pFT_Select_Charmap(ft_face, encoding) == FT_Err_Ok;
3085 }
3086
3087 /*************************************************************
3088 * WineEngCreateFontInstance
3089 *
3090 */
3091 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
3092 {
3093 GdiFont *ret;
3094 Face *face, *best, *best_bitmap;
3095 Family *family, *last_resort_family;
3096 struct list *family_elem_ptr, *face_elem_ptr;
3097 INT height, width = 0;
3098 unsigned int score = 0, new_score;
3099 signed int diff = 0, newdiff;
3100 BOOL bd, it, can_use_bitmap;
3101 LOGFONTW lf;
3102 CHARSETINFO csi;
3103 HFONTLIST *hflist;
3104
3105 EnterCriticalSection( &freetype_cs );
3106
3107 LIST_FOR_EACH_ENTRY(ret, &child_font_list, struct tagGdiFont, entry)
3108 {
3109 struct list *first_hfont = list_head(&ret->hfontlist);
3110 hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
3111 if(hflist->hfont == hfont)
3112 {
3113 LeaveCriticalSection( &freetype_cs );
3114 return ret;
3115 }
3116 }
3117
3118 if (!GetObjectW( hfont, sizeof(lf), &lf ))
3119 {
3120 LeaveCriticalSection( &freetype_cs );
3121 return NULL;
3122 }
3123 lf.lfWidth = abs(lf.lfWidth);
3124
3125 can_use_bitmap = GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_RA_ABLE;
3126
3127 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
3128 debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
3129 lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
3130 lf.lfEscapement);
3131
3132 /* check the cache first */
3133 if((ret = find_in_cache(hfont, &lf, &dc->xformWorld2Vport, can_use_bitmap)) != NULL) {
3134 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
3135 LeaveCriticalSection( &freetype_cs );
3136 return ret;
3137 }
3138
3139 TRACE("not in cache\n");
3140 if(list_empty(&font_list)) /* No fonts installed */
3141 {
3142 TRACE("No fonts installed\n");
3143 LeaveCriticalSection( &freetype_cs );
3144 return NULL;
3145 }
3146 if(!have_installed_roman_font)
3147 {
3148 TRACE("No roman font installed\n");
3149 LeaveCriticalSection( &freetype_cs );
3150 return NULL;
3151 }
3152
3153 ret = alloc_font();
3154
3155 memcpy(&ret->font_desc.matrix, &dc->xformWorld2Vport, sizeof(FMAT2));
3156 ret->font_desc.lf = lf;
3157 ret->font_desc.can_use_bitmap = can_use_bitmap;
3158 calc_hash(&ret->font_desc);
3159 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
3160 hflist->hfont = hfont;
3161 list_add_head(&ret->hfontlist, &hflist->entry);
3162
3163
3164 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
3165 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
3166 original value lfCharSet. Note this is a special case for
3167 Symbol and doesn't happen at least for "Wingdings*" */
3168
3169 if(!strcmpiW(lf.lfFaceName, SymbolW))
3170 lf.lfCharSet = SYMBOL_CHARSET;
3171
3172 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
3173 switch(lf.lfCharSet) {
3174 case DEFAULT_CHARSET:
3175 csi.fs.fsCsb[0] = 0;
3176 break;
3177 default:
3178 FIXME("Untranslated charset %d\n", lf.lfCharSet);
3179 csi.fs.fsCsb[0] = 0;
3180 break;
3181 }
3182 }
3183
3184 family = NULL;
3185 if(lf.lfFaceName[0] != '\0') {
3186 FontSubst *psub;
3187 SYSTEM_LINKS *font_link;
3188 CHILD_FONT *font_link_entry;
3189 LPWSTR FaceName = lf.lfFaceName;
3190
3191 /*
3192 * Check for a leading '@' this signals that the font is being
3193 * requested in tategaki mode (vertical writing substitution) but
3194 * does not affect the fontface that is to be selected.
3195 */
3196 if (lf.lfFaceName[0]=='@')
3197 FaceName = &lf.lfFaceName[1];
3198
3199 psub = get_font_subst(&font_subst_list, FaceName, lf.lfCharSet);
3200
3201 if(psub) {
3202 TRACE("substituting %s -> %s\n", debugstr_w(FaceName),
3203 debugstr_w(psub->to.name));
3204 strcpyW(FaceName, psub->to.name);
3205 }
3206
3207 /* We want a match on name and charset or just name if
3208 charset was DEFAULT_CHARSET. If the latter then
3209 we fixup the returned charset later in get_nearest_charset
3210 where we'll either use the charset of the current ansi codepage
3211 or if that's unavailable the first charset that the font supports.
3212 */
3213 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3214 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3215 if(!strcmpiW(family->FamilyName, FaceName)) {
3216 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3217 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3218 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
3219 if(face->scalable || can_use_bitmap)
3220 goto found;
3221 }
3222 }
3223 }
3224
3225 /*
3226 * Try check the SystemLink list first for a replacement font.
3227 * We may find good replacements there.
3228 */
3229 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
3230 {
3231 if(!strcmpiW(font_link->font_name, FaceName))
3232 {
3233 TRACE("found entry in system list\n");
3234 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
3235 {
3236 face = font_link_entry->face;
3237 family = face->family;
3238 if(csi.fs.fsCsb[0] &
3239 (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]) || !csi.fs.fsCsb[0])
3240 {
3241 if(face->scalable || can_use_bitmap)
3242 goto found;
3243 }
3244 }
3245 }
3246 }
3247 }
3248
3249 /* If requested charset was DEFAULT_CHARSET then try using charset
3250 corresponding to the current ansi codepage */
3251 if(!csi.fs.fsCsb[0]) {
3252 INT acp = GetACP();
3253 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
3254 FIXME("TCI failed on codepage %d\n", acp);
3255 csi.fs.fsCsb[0] = 0;
3256 } else
3257 lf.lfCharSet = csi.ciCharset;
3258 }
3259
3260 /* Face families are in the top 4 bits of lfPitchAndFamily,
3261 so mask with 0xF0 before testing */
3262
3263 if((lf.lfPitchAndFamily & FIXED_PITCH) ||
3264 (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
3265 strcpyW(lf.lfFaceName, defFixed);
3266 else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
3267 strcpyW(lf.lfFaceName, defSerif);
3268 else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
3269 strcpyW(lf.lfFaceName, defSans);
3270 else
3271 strcpyW(lf.lfFaceName, defSans);
3272 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3273 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3274 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
3275 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3276 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3277 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
3278 if(face->scalable || can_use_bitmap)
3279 goto found;
3280 }
3281 }
3282 }
3283
3284 last_resort_family = NULL;
3285 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3286 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3287 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3288 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3289 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) {
3290 if(face->scalable)
3291 goto found;
3292 if(can_use_bitmap && !last_resort_family)
3293 last_resort_family = family;
3294 }
3295 }
3296 }
3297
3298 if(last_resort_family) {
3299 family = last_resort_family;
3300 csi.fs.fsCsb[0] = 0;
3301 goto found;
3302 }
3303
3304 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3305 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3306 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3307 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3308 if(face->scalable) {
3309 csi.fs.fsCsb[0] = 0;
3310 WARN("just using first face for now\n");
3311 goto found;
3312 }
3313 if(can_use_bitmap && !last_resort_family)
3314 last_resort_family = family;
3315 }
3316 }
3317 if(!last_resort_family) {
3318 FIXME("can't find a single appropriate font - bailing\n");
3319 free_font(ret);
3320 LeaveCriticalSection( &freetype_cs );
3321 return NULL;
3322 }
3323
3324 WARN("could only find a bitmap font - this will probably look awful!\n");
3325 family = last_resort_family;
3326 csi.fs.fsCsb[0] = 0;
3327
3328 found:
3329 it = lf.lfItalic ? 1 : 0;
3330 bd = lf.lfWeight > 550 ? 1 : 0;
3331
3332 height = GDI_ROUND( (FLOAT)lf.lfHeight * dc->xformWorld2Vport.eM22 );
3333 height = lf.lfHeight < 0 ? -abs(height) : abs(height);
3334
3335 face = best = best_bitmap = NULL;
3336 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
3337 {
3338 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
3339 {
3340 BOOL italic, bold;
3341
3342 italic = (face->ntmFlags & NTM_ITALIC) ? 1 : 0;
3343 bold = (face->ntmFlags & NTM_BOLD) ? 1 : 0;
3344 new_score = (italic ^ it) + (bold ^ bd);
3345 if(!best || new_score <= score)
3346 {
3347 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
3348 italic, bold, it, bd);
3349 score = new_score;
3350 best = face;
3351 if(best->scalable && score == 0) break;
3352 if(!best->scalable)
3353 {
3354 if(height > 0)
3355 newdiff = height - (signed int)(best->size.height);
3356 else
3357 newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
3358 if(!best_bitmap || new_score < score ||
3359 (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
3360 {
3361 TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
3362 diff = newdiff;
3363 best_bitmap = best;
3364 if(score == 0 && diff == 0) break;
3365 }
3366 }
3367 }
3368 }
3369 }
3370 if(best)
3371 face = best->scalable ? best : best_bitmap;
3372 ret->fake_italic = (it && !(face->ntmFlags & NTM_ITALIC));
3373 ret->fake_bold = (bd && !(face->ntmFlags & NTM_BOLD));
3374
3375 ret->fs = face->fs;
3376
3377 if(csi.fs.fsCsb[0]) {
3378 ret->charset = lf.lfCharSet;
3379 ret->codepage = csi.ciACP;
3380 }
3381 else
3382 ret->charset = get_nearest_charset(face, &ret->codepage);
3383
3384 TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family->FamilyName),
3385 debugstr_w(face->StyleName), face->file, face->font_data_ptr, face->face_index);
3386
3387 ret->aveWidth = height ? lf.lfWidth : 0;
3388
3389 if(!face->scalable) {
3390 /* Windows uses integer scaling factors for bitmap fonts */
3391 INT scale, scaled_height;
3392
3393 if (height != 0) height = diff;
3394 height += face->size.height;
3395
3396 scale = (height + face->size.height - 1) / face->size.height;
3397 scaled_height = scale * face->size.height;
3398 /* XP allows not more than 10% deviation */
3399 if (scale > 1 && scaled_height - height > scaled_height / 10) scale--;
3400 ret->scale_y = scale;
3401
3402 width = face->size.x_ppem >> 6;
3403 height = face->size.y_ppem >> 6;
3404 }
3405 else
3406 ret->scale_y = 1.0;
3407 TRACE("font scale y: %f\n", ret->scale_y);
3408
3409 ret->ft_face = OpenFontFace(ret, face, width, height);
3410
3411 if (!ret->ft_face)
3412 {
3413 free_font( ret );
3414 LeaveCriticalSection( &freetype_cs );
3415 return 0;
3416 }
3417
3418 ret->ntmFlags = face->ntmFlags;
3419
3420 if (ret->charset == SYMBOL_CHARSET &&
3421 select_charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
3422 /* No ops */
3423 }
3424 else if (select_charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
3425 /* No ops */
3426 }
3427 else {
3428 select_charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
3429 }
3430
3431 ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
3432 ret->name = strdupW(family->FamilyName);
3433 ret->underline = lf.lfUnderline ? 0xff : 0;
3434 ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
3435 create_child_font_list(ret);
3436
3437 if (lf.lfFaceName[0]=='@') /* We need to try to load the GSUB table */
3438 {
3439 int length = WineEngGetFontData (ret, GSUB_TAG , 0, NULL, 0);
3440 if (length != GDI_ERROR)
3441 {
3442 ret->GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
3443 WineEngGetFontData(ret, GSUB_TAG , 0, ret->GSUB_Table, length);
3444 TRACE("Loaded GSUB table of %i bytes\n",length);
3445 }
3446 }
3447
3448 TRACE("caching: gdiFont=%p hfont=%p\n", ret, hfont);
3449
3450 list_add_head(&gdi_font_list, &ret->entry);
3451 LeaveCriticalSection( &freetype_cs );
3452 return ret;
3453 }
3454
3455 static void dump_gdi_font_list(void)
3456 {
3457 GdiFont *gdiFont;
3458 struct list *elem_ptr;
3459
3460 TRACE("---------- gdiFont Cache ----------\n");
3461 LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
3462 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
3463 TRACE("gdiFont=%p %s %d\n",
3464 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
3465 }
3466
3467 TRACE("---------- Unused gdiFont Cache ----------\n");
3468 LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
3469 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
3470 TRACE("gdiFont=%p %s %d\n",
3471 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
3472 }
3473 }
3474
3475 /*************************************************************
3476 * WineEngDestroyFontInstance
3477 *
3478 * free the gdiFont associated with this handle
3479 *
3480 */
3481 BOOL WineEngDestroyFontInstance(HFONT handle)
3482 {
3483 GdiFont *gdiFont;
3484 HFONTLIST *hflist;
3485 BOOL ret = FALSE;
3486 struct list *font_elem_ptr, *hfontlist_elem_ptr;
3487 int i = 0;
3488
3489 EnterCriticalSection( &freetype_cs );
3490
3491 LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
3492 {
3493 struct list *first_hfont = list_head(&gdiFont->hfontlist);
3494 hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
3495 if(hflist->hfont == handle)
3496 {
3497 TRACE("removing child font %p from child list\n", gdiFont);
3498 list_remove(&gdiFont->entry);
3499 LeaveCriticalSection( &freetype_cs );
3500 return TRUE;
3501 }
3502 }
3503
3504 TRACE("destroying hfont=%p\n", handle);
3505 if(TRACE_ON(font))
3506 dump_gdi_font_list();
3507
3508 font_elem_ptr = list_head(&gdi_font_list);
3509 while(font_elem_ptr) {
3510 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3511 font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
3512
3513 hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
3514 while(hfontlist_elem_ptr) {
3515 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
3516 hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
3517 if(hflist->hfont == handle) {
3518 list_remove(&hflist->entry);
3519 HeapFree(GetProcessHeap(), 0, hflist);
3520 ret = TRUE;
3521 }
3522 }
3523 if(list_empty(&gdiFont->hfontlist)) {
3524 TRACE("Moving to Unused list\n");
3525 list_remove(&gdiFont->entry);
3526 list_add_head(&unused_gdi_font_list, &gdiFont->entry);
3527 }
3528 }
3529
3530
3531 font_elem_ptr = list_head(&unused_gdi_font_list);
3532 while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
3533 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3534 while(font_elem_ptr) {
3535 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3536 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3537 TRACE("freeing %p\n", gdiFont);
3538 list_remove(&gdiFont->entry);
3539 free_font(gdiFont);
3540 }
3541 LeaveCriticalSection( &freetype_cs );
3542 return ret;
3543 }
3544
3545 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
3546 NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
3547 {
3548 GdiFont *font;
3549 LONG width, height;
3550
3551 if (face->cached_enum_data)
3552 {
3553 TRACE("Cached\n");
3554 *pelf = face->cached_enum_data->elf;
3555 *pntm = face->cached_enum_data->ntm;
3556 *ptype = face->cached_enum_data->type;
3557 return;
3558 }
3559
3560 font = alloc_font();
3561
3562 if(face->scalable) {
3563 height = 100;
3564 width = 0;
3565 } else {
3566 height = face->size.y_ppem >> 6;
3567 width = face->size.x_ppem >> 6;
3568 }
3569 font->scale_y = 1.0;
3570
3571 if (!(font->ft_face = OpenFontFace(font, face, width, height)))
3572 {
3573 free_font(font);
3574 return;
3575 }
3576
3577 font->name = strdupW(face->family->FamilyName);
3578 font->ntmFlags = face->ntmFlags;
3579
3580 if (WineEngGetOutlineTextMetrics(font, 0, NULL))
3581 {
3582 memcpy(&pntm->ntmTm, &font->potm->otmTextMetrics, sizeof(TEXTMETRICW));
3583
3584 pntm->ntmTm.ntmSizeEM = font->potm->otmEMSquare;
3585
3586 lstrcpynW(pelf->elfLogFont.lfFaceName,
3587 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFamilyName),
3588 LF_FACESIZE);
3589 lstrcpynW(pelf->elfFullName,
3590 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFaceName),
3591 LF_FULLFACESIZE);
3592 lstrcpynW(pelf->elfStyle,
3593 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpStyleName),
3594 LF_FACESIZE);
3595 }
3596 else
3597 {
3598 WineEngGetTextMetrics(font, (TEXTMETRICW *)&pntm->ntmTm);
3599
3600 pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
3601
3602 lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
3603 lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FULLFACESIZE);
3604 lstrcpynW(pelf->elfStyle, face->StyleName, LF_FACESIZE);
3605 }
3606
3607 pntm->ntmTm.ntmFlags = face->ntmFlags;
3608 pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
3609 pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
3610 pntm->ntmFontSig = face->fs;
3611
3612 pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
3613
3614 pelf->elfLogFont.lfEscapement = 0;
3615 pelf->elfLogFont.lfOrientation = 0;
3616 pelf->elfLogFont.lfHeight = pntm->ntmTm.tmHeight;
3617 pelf->elfLogFont.lfWidth = pntm->ntmTm.tmAveCharWidth;
3618 pelf->elfLogFont.lfWeight = pntm->ntmTm.tmWeight;
3619 pelf->elfLogFont.lfItalic = pntm->ntmTm.tmItalic;
3620 pelf->elfLogFont.lfUnderline = pntm->ntmTm.tmUnderlined;
3621 pelf->elfLogFont.lfStrikeOut = pntm->ntmTm.tmStruckOut;
3622 pelf->elfLogFont.lfCharSet = pntm->ntmTm.tmCharSet;
3623 pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
3624 pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
3625 pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
3626 pelf->elfLogFont.lfPitchAndFamily = (pntm->ntmTm.tmPitchAndFamily & 0xf1) + 1;
3627
3628 *ptype = 0;
3629 if (pntm->ntmTm.tmPitchAndFamily & TMPF_TRUETYPE)
3630 *ptype |= TRUETYPE_FONTTYPE;
3631 if (pntm->ntmTm.tmPitchAndFamily & TMPF_DEVICE)
3632 *ptype |= DEVICE_FONTTYPE;
3633 if(!(pntm->ntmTm.tmPitchAndFamily & TMPF_VECTOR))
3634 *ptype |= RASTER_FONTTYPE;
3635
3636 face->cached_enum_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*face->cached_enum_data));
3637 if (face->cached_enum_data)
3638 {
3639 face->cached_enum_data->elf = *pelf;
3640 face->cached_enum_data->ntm = *pntm;
3641 face->cached_enum_data->type = *ptype;
3642 }
3643
3644 free_font(font);
3645 }
3646
3647 /*************************************************************
3648 * WineEngEnumFonts
3649 *
3650 */
3651 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
3652 {
3653 Family *family;
3654 Face *face;
3655 struct list *family_elem_ptr, *face_elem_ptr;
3656 ENUMLOGFONTEXW elf;
3657 NEWTEXTMETRICEXW ntm;
3658 DWORD type;
3659 FONTSIGNATURE fs;
3660 CHARSETINFO csi;
3661 LOGFONTW lf;
3662 int i;
3663
3664 if (!plf)
3665 {
3666 lf.lfCharSet = DEFAULT_CHARSET;
3667 lf.lfPitchAndFamily = 0;
3668 lf.lfFaceName[0] = 0;
3669 plf = &lf;
3670 }
3671
3672 TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
3673
3674 EnterCriticalSection( &freetype_cs );
3675 if(plf->lfFaceName[0]) {
3676 FontSubst *psub;
3677 psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
3678
3679 if(psub) {
3680 TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
3681 debugstr_w(psub->to.name));
3682 lf = *plf;
3683 strcpyW(lf.lfFaceName, psub->to.name);
3684 plf = &lf;
3685 }
3686
3687 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3688 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3689 if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
3690 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3691 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3692 GetEnumStructs(face, &elf, &ntm, &type);
3693 for(i = 0; i < 32; i++) {
3694 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3695 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3696 strcpyW(elf.elfScript, OEM_DOSW);
3697 i = 32; /* break out of loop */
3698 } else if(!(face->fs.fsCsb[0] & (1L << i)))
3699 continue;
3700 else {
3701 fs.fsCsb[0] = 1L << i;
3702 fs.fsCsb[1] = 0;
3703 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3704 TCI_SRCFONTSIG))
3705 csi.ciCharset = DEFAULT_CHARSET;
3706 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3707 if(csi.ciCharset != DEFAULT_CHARSET) {
3708 elf.elfLogFont.lfCharSet =
3709 ntm.ntmTm.tmCharSet = csi.ciCharset;
3710 if(ElfScriptsW[i])
3711 strcpyW(elf.elfScript, ElfScriptsW[i]);
3712 else
3713 FIXME("Unknown elfscript for bit %d\n", i);
3714 }
3715 }
3716 TRACE("enuming face %s full %s style %s charset %d type %d script %s it %d weight %d ntmflags %08x\n",
3717 debugstr_w(elf.elfLogFont.lfFaceName),
3718 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3719 csi.ciCharset, type, debugstr_w(elf.elfScript),
3720 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3721 ntm.ntmTm.ntmFlags);
3722 /* release section before callback (FIXME) */
3723 LeaveCriticalSection( &freetype_cs );
3724 if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return 0;
3725 EnterCriticalSection( &freetype_cs );
3726 }
3727 }
3728 }
3729 }
3730 } else {
3731 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3732 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3733 face_elem_ptr = list_head(&family->faces);
3734 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3735 GetEnumStructs(face, &elf, &ntm, &type);
3736 for(i = 0; i < 32; i++) {
3737 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3738 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3739 strcpyW(elf.elfScript, OEM_DOSW);
3740 i = 32; /* break out of loop */
3741 } else if(!(face->fs.fsCsb[0] & (1L << i)))
3742 continue;
3743 else {
3744 fs.fsCsb[0] = 1L << i;
3745 fs.fsCsb[1] = 0;
3746 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3747 TCI_SRCFONTSIG))
3748 csi.ciCharset = DEFAULT_CHARSET;
3749 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3750 if(csi.ciCharset != DEFAULT_CHARSET) {
3751 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet =
3752 csi.ciCharset;
3753 if(ElfScriptsW[i])
3754 strcpyW(elf.elfScript, ElfScriptsW[i]);
3755 else
3756 FIXME("Unknown elfscript for bit %d\n", i);
3757 }
3758 }
3759 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
3760 debugstr_w(elf.elfLogFont.lfFaceName),
3761 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3762 csi.ciCharset, type, debugstr_w(elf.elfScript),
3763 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3764 ntm.ntmTm.ntmFlags);
3765 /* release section before callback (FIXME) */
3766 LeaveCriticalSection( &freetype_cs );
3767 if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return 0;
3768 EnterCriticalSection( &freetype_cs );
3769 }
3770 }
3771 }
3772 LeaveCriticalSection( &freetype_cs );
3773 return 1;
3774 }
3775
3776 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
3777 {
3778 pt->x.value = vec->x >> 6;
3779 pt->x.fract = (vec->x & 0x3f) << 10;
3780 pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
3781 pt->y.value = vec->y >> 6;
3782 pt->y.fract = (vec->y & 0x3f) << 10;
3783 pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
3784 return;
3785 }
3786
3787 /***************************************************
3788 * According to the MSDN documentation on WideCharToMultiByte,
3789 * certain codepages cannot set the default_used parameter.
3790 * This returns TRUE if the codepage can set that parameter, false else
3791 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
3792 */
3793 static BOOL codepage_sets_default_used(UINT codepage)
3794 {
3795 switch (codepage)
3796 {
3797 case CP_UTF7:
3798 case CP_UTF8:
3799 case CP_SYMBOL:
3800 return FALSE;
3801 default:
3802 return TRUE;
3803 }
3804 }
3805
3806 /*
3807 * GSUB Table handling functions
3808 */
3809
3810 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
3811 {
3812 const GSUB_CoverageFormat1* cf1;
3813
3814 cf1 = (GSUB_CoverageFormat1*)table;
3815
3816 if (GET_BE_WORD(cf1->CoverageFormat) == 1)
3817 {
3818 int count = GET_BE_WORD(cf1->GlyphCount);
3819 int i;
3820 TRACE("Coverage Format 1, %i glyphs\n",count);
3821 for (i = 0; i < count; i++)
3822 if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
3823 return i;
3824 return -1;
3825 }
3826 else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
3827 {
3828 const GSUB_CoverageFormat2* cf2;
3829 int i;
3830 int count;
3831 cf2 = (GSUB_CoverageFormat2*)cf1;
3832
3833 count = GET_BE_WORD(cf2->RangeCount);
3834 TRACE("Coverage Format 2, %i ranges\n",count);
3835 for (i = 0; i < count; i++)
3836 {
3837 if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
3838 return -1;
3839 if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
3840 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
3841 {
3842 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
3843 glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
3844 }
3845 }
3846 return -1;
3847 }
3848 else
3849 ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
3850
3851 return -1;
3852 }
3853
3854 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
3855 {
3856 const GSUB_ScriptList *script;
3857 const GSUB_Script *deflt = NULL;
3858 int i;
3859 script = (GSUB_ScriptList*)((LPBYTE)header + GET_BE_WORD(header->ScriptList));
3860
3861 TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
3862 for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
3863 {
3864 const GSUB_Script *scr;
3865 int offset;
3866
3867 offset = GET_BE_WORD(script->ScriptRecord[i].Script);
3868 scr = (GSUB_Script*)((LPBYTE)script + offset);
3869
3870 if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
3871 return scr;
3872 if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
3873 deflt = scr;
3874 }
3875 return deflt;
3876 }
3877
3878 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
3879 {
3880 int i;
3881 int offset;
3882 const GSUB_LangSys *Lang;
3883
3884 TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
3885
3886 for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
3887 {
3888 offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
3889 Lang = (GSUB_LangSys*)((LPBYTE)script + offset);
3890
3891 if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
3892 return Lang;
3893 }
3894 offset = GET_BE_WORD(script->DefaultLangSys);
3895 if (offset)
3896 {
3897 Lang = (GSUB_LangSys*)((LPBYTE)script + offset);
3898 return Lang;
3899 }
3900 return NULL;
3901 }
3902
3903 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
3904 {
3905 int i;
3906 const GSUB_FeatureList *feature;
3907 feature = (GSUB_FeatureList*)((LPBYTE)header + GET_BE_WORD(header->FeatureList));
3908
3909 TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
3910 for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
3911 {
3912 int index = GET_BE_WORD(lang->FeatureIndex[i]);
3913 if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
3914 {
3915 const GSUB_Feature *feat;
3916 feat = (GSUB_Feature*)((LPBYTE)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
3917 return feat;
3918 }
3919 }
3920 return NULL;
3921 }
3922
3923 static FT_UInt GSUB_apply_feature(const GSUB_Header * header, const GSUB_Feature* feature, UINT glyph)
3924 {
3925 int i;
3926 int offset;
3927 const GSUB_LookupList *lookup;
3928 lookup = (GSUB_LookupList*)((LPBYTE)header + GET_BE_WORD(header->LookupList));
3929
3930 TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
3931 for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
3932 {
3933 const GSUB_LookupTable *look;
3934 offset = GET_BE_WORD(lookup->Lookup[GET_BE_WORD(feature->LookupListIndex[i])]);
3935 look = (GSUB_LookupTable*)((LPBYTE)lookup + offset);
3936 TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
3937 if (GET_BE_WORD(look->LookupType) != 1)
3938 FIXME("We only handle SubType 1\n");
3939 else
3940 {
3941 int j;
3942
3943 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
3944 {
3945 const GSUB_SingleSubstFormat1 *ssf1;
3946 offset = GET_BE_WORD(look->SubTable[j]);
3947 ssf1 = (GSUB_SingleSubstFormat1*)((LPBYTE)look+offset);
3948 if (GET_BE_WORD(ssf1->SubstFormat) == 1)
3949 {
3950 int offset = GET_BE_WORD(ssf1->Coverage);
3951 TRACE(" subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
3952 if (GSUB_is_glyph_covered((LPBYTE)ssf1+offset, glyph) != -1)
3953 {
3954 TRACE(" Glyph 0x%x ->",glyph);
3955 glyph += GET_BE_WORD(ssf1->DeltaGlyphID);
3956 TRACE(" 0x%x\n",glyph);
3957 }
3958 }
3959 else
3960 {
3961 const GSUB_SingleSubstFormat2 *ssf2;
3962 INT index;
3963 INT offset;
3964
3965 ssf2 = (GSUB_SingleSubstFormat2 *)ssf1;
3966 offset = GET_BE_WORD(ssf1->Coverage);
3967 TRACE(" subtype 2, glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
3968 index = GSUB_is_glyph_covered((LPBYTE)ssf2+offset, glyph);
3969 TRACE(" Coverage index %i\n",index);
3970 if (index != -1)
3971 {
3972 TRACE(" Glyph is 0x%x ->",glyph);
3973 glyph = GET_BE_WORD(ssf2->Substitute[index]);
3974 TRACE("0x%x\n",glyph);
3975 }
3976 }
3977 }
3978 }
3979 }
3980 return glyph;
3981 }
3982
3983 static const char* get_opentype_script(const GdiFont *font)
3984 {
3985 /*
3986 * I am not sure if this is the correct way to generate our script tag
3987 */
3988
3989 switch (font->charset)
3990 {
3991 case ANSI_CHARSET: return "latn";
3992 case BALTIC_CHARSET: return "latn"; /* ?? */
3993 case CHINESEBIG5_CHARSET: return "hani";
3994 case EASTEUROPE_CHARSET: return "latn"; /* ?? */
3995 case GB2312_CHARSET: return "hani";
3996 case GREEK_CHARSET: return "grek";
3997 case HANGUL_CHARSET: return "hang";
3998 case RUSSIAN_CHARSET: return "cyrl";
3999 case SHIFTJIS_CHARSET: return "kana";
4000 case TURKISH_CHARSET: return "latn"; /* ?? */
4001 case VIETNAMESE_CHARSET: return "latn";
4002 case JOHAB_CHARSET: return "latn"; /* ?? */
4003 case ARABIC_CHARSET: return "arab";
4004 case HEBREW_CHARSET: return "hebr";
4005 case THAI_CHARSET: return "thai";
4006 default: return "latn";
4007 }
4008 }
4009
4010 static FT_UInt get_GSUB_vert_glyph(const GdiFont *font, UINT glyph)
4011 {
4012 const GSUB_Header *header;
4013 const GSUB_Script *script;
4014 const GSUB_LangSys *language;
4015 const GSUB_Feature *feature;
4016
4017 if (!font->GSUB_Table)
4018 return glyph;
4019
4020 header = font->GSUB_Table;
4021
4022 script = GSUB_get_script_table(header, get_opentype_script(font));
4023 if (!script)
4024 {
4025 TRACE("Script not found\n");
4026 return glyph;
4027 }
4028 language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
4029 if (!language)
4030 {
4031 TRACE("Language not found\n");
4032 return glyph;
4033 }
4034 feature = GSUB_get_feature(header, language, "vrt2");
4035 if (!feature)
4036 feature = GSUB_get_feature(header, language, "vert");
4037 if (!feature)
4038 {
4039 TRACE("vrt2/vert feature not found\n");
4040 return glyph;
4041 }
4042 return GSUB_apply_feature(header, feature, glyph);
4043 }
4044
4045 static FT_UInt get_glyph_index(const GdiFont *font, UINT glyph)
4046 {
4047 FT_UInt glyphId;
4048
4049 if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
4050 WCHAR wc = (WCHAR)glyph;
4051 BOOL default_used;
4052 BOOL *default_used_pointer;
4053 FT_UInt ret;
4054 char buf;
4055 default_used_pointer = NULL;
4056 default_used = FALSE;
4057 if (codepage_sets_default_used(font->codepage))
4058 default_used_pointer = &default_used;
4059 if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
4060 ret = 0;
4061 else
4062 ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
4063 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
4064 return get_GSUB_vert_glyph(font,ret);
4065 }
4066
4067 if(font->charset == SYMBOL_CHARSET && glyph < 0x100)
4068 glyph = glyph + 0xf000;
4069 glyphId = pFT_Get_Char_Index(font->ft_face, glyph);
4070 return get_GSUB_vert_glyph(font,glyphId);
4071 }
4072
4073 /*************************************************************
4074 * WineEngGetGlyphIndices
4075 *
4076 */
4077 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
4078 LPWORD pgi, DWORD flags)
4079 {
4080 int i;
4081 int default_char = -1;
4082
4083 if (flags & GGI_MARK_NONEXISTING_GLYPHS) default_char = 0xffff; /* XP would use 0x1f for bitmap fonts */
4084
4085 for(i = 0; i < count; i++)
4086 {
4087 pgi[i] = get_glyph_index(font, lpstr[i]);
4088 if (pgi[i] == 0)
4089 {
4090 if (default_char == -1)
4091 {
4092 if (FT_IS_SFNT(font->ft_face))
4093 {
4094 TT_OS2 *pOS2 = pFT_Get_Sfnt_Table(font->ft_face, ft_sfnt_os2);
4095 default_char = (pOS2->usDefaultChar ? get_glyph_index(font, pOS2->usDefaultChar) : 0);
4096 }
4097 else
4098 {
4099 TEXTMETRICW textm;
4100 WineEngGetTextMetrics(font, &textm);
4101 default_char = textm.tmDefaultChar;
4102 }
4103 }
4104 pgi[i] = default_char;
4105 }
4106 }
4107 return count;
4108 }
4109
4110 /*************************************************************
4111 * WineEngGetGlyphOutline
4112 *
4113 * Behaves in exactly the same way as the win32 api GetGlyphOutline
4114 * except that the first parameter is the HWINEENGFONT of the font in
4115 * question rather than an HDC.
4116 *
4117 */
4118 DWORD WineEngGetGlyphOutline(GdiFont *incoming_font, UINT glyph, UINT format,
4119 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
4120 const MAT2* lpmat)
4121 {
4122 static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
4123 FT_Face ft_face = incoming_font->ft_face;
4124 GdiFont *font = incoming_font;
4125 FT_UInt glyph_index;
4126 DWORD width, height, pitch, needed = 0;
4127 FT_Bitmap ft_bitmap;
4128 FT_Error err;
4129 INT left, right, top = 0, bottom = 0, adv, lsb, bbx;
4130 FT_Angle angle = 0;
4131 FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
4132 float widthRatio = 1.0;
4133 FT_Matrix transMat = identityMat;
4134 BOOL needsTransform = FALSE;
4135 BOOL tategaki = (font->GSUB_Table != NULL);
4136 UINT original_index;
4137
4138
4139 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
4140 buflen, buf, lpmat);
4141
4142 EnterCriticalSection( &freetype_cs );
4143
4144 if(format & GGO_GLYPH_INDEX) {
4145 glyph_index = get_GSUB_vert_glyph(incoming_font,glyph);
4146 original_index = glyph;
4147 format &= ~GGO_GLYPH_INDEX;
4148 } else {
4149 get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
4150 ft_face = font->ft_face;
4151 original_index = glyph_index;
4152 }
4153
4154 /* tategaki never appears to happen to lower glyph index */
4155 if (glyph_index < TATEGAKI_LOWER_BOUND )
4156 tategaki = FALSE;
4157
4158 if(original_index >= font->gmsize * GM_BLOCK_SIZE) {
4159 font->gmsize = (original_index / GM_BLOCK_SIZE + 1);
4160 font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
4161 font->gmsize * sizeof(GM*));
4162 } else {
4163 if(format == GGO_METRICS && font->gm[original_index / GM_BLOCK_SIZE] != NULL && FONT_GM(font,original_index)->init ) {
4164 *lpgm = FONT_GM(font,original_index)->gm;
4165 LeaveCriticalSection( &freetype_cs );
4166 return 1; /* FIXME */
4167 }
4168 }
4169
4170 if (!font->gm[original_index / GM_BLOCK_SIZE])
4171 font->gm[original_index / GM_BLOCK_SIZE] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
4172
4173 if(font->orientation || (format != GGO_METRICS && format != GGO_BITMAP && format != WINE_GGO_GRAY16_BITMAP) || lpmat)
4174 load_flags |= FT_LOAD_NO_BITMAP;
4175
4176 err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
4177
4178 if(err) {
4179 WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
4180 LeaveCriticalSection( &freetype_cs );
4181 return GDI_ERROR;
4182 }
4183
4184 /* Scaling factor */
4185 if (font->aveWidth && font->potm)
4186 {
4187 widthRatio = (float)font->aveWidth * font->font_desc.matrix.eM11;
4188 widthRatio /= (float)font->potm->otmTextMetrics.tmAveCharWidth;
4189 }
4190 else
4191 widthRatio = font->scale_y;
4192
4193 left = (INT)(ft_face->glyph->metrics.horiBearingX * widthRatio) & -64;
4194 right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) * widthRatio + 63) & -64;
4195
4196 adv = (INT)((ft_face->glyph->metrics.horiAdvance * widthRatio) + 63) >> 6;
4197 lsb = left >> 6;
4198 bbx = (right - left) >> 6;
4199
4200 /* Scaling transform */
4201 if(font->aveWidth) {
4202 FT_Matrix scaleMat;
4203 scaleMat.xx = FT_FixedFromFloat(widthRatio);
4204 scaleMat.xy = 0;
4205 scaleMat.yx = 0;
4206 scaleMat.yy = FT_FixedFromFloat(font->scale_y);
4207
4208 pFT_Matrix_Multiply(&scaleMat, &transMat);
4209 needsTransform = TRUE;
4210 }
4211
4212 /* Slant transform */
4213 if (font->fake_italic) {
4214 FT_Matrix slantMat;
4215
4216 slantMat.xx = (1 << 16);
4217 slantMat.xy = ((1 << 16) >> 2);
4218 slantMat.yx = 0;
4219 slantMat.yy = (1 << 16);
4220 pFT_Matrix_Multiply(&slantMat, &transMat);
4221 needsTransform = TRUE;
4222 }
4223
4224 /* Rotation transform */
4225 if(font->orientation && !tategaki) {
4226 FT_Matrix rotationMat;
4227 FT_Vector vecAngle;
4228 angle = FT_FixedFromFloat((float)font->orientation / 10.0);
4229 pFT_Vector_Unit(&vecAngle, angle);
4230 rotationMat.xx = vecAngle.x;
4231 rotationMat.xy = -vecAngle.y;
4232 rotationMat.yx = -rotationMat.xy;
4233 rotationMat.yy = rotationMat.xx;
4234
4235 pFT_Matrix_Multiply(&rotationMat, &transMat);
4236 needsTransform = TRUE;
4237 }
4238
4239 /* Extra transformation specified by caller */
4240 if (lpmat) {
4241 FT_Matrix extraMat;
4242 extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
4243 extraMat.xy = FT_FixedFromFIXED(lpmat->eM21);
4244 extraMat.yx = FT_FixedFromFIXED(lpmat->eM12);
4245 extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
4246 pFT_Matrix_Multiply(&extraMat, &transMat);
4247 needsTransform = TRUE;
4248 }
4249
4250 if(!needsTransform) {
4251 top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
4252 bottom = (ft_face->glyph->metrics.horiBearingY -
4253 ft_face->glyph->metrics.height) & -64;
4254 lpgm->gmCellIncX = adv;
4255 lpgm->gmCellIncY = 0;
4256 } else {
4257 INT xc, yc;
4258 FT_Vector vec;
4259 for(xc = 0; xc < 2; xc++) {
4260 for(yc = 0; yc < 2; yc++) {
4261 vec.x = (ft_face->glyph->metrics.horiBearingX +
4262 xc * ft_face->glyph->metrics.width);
4263 vec.y = ft_face->glyph->metrics.horiBearingY -
4264 yc * ft_face->glyph->metrics.height;
4265 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
4266 pFT_Vector_Transform(&vec, &transMat);
4267 if(xc == 0 && yc == 0) {
4268 left = right = vec.x;
4269 top = bottom = vec.y;
4270 } else {
4271 if(vec.x < left) left = vec.x;
4272 else if(vec.x > right) right = vec.x;
4273 if(vec.y < bottom) bottom = vec.y;
4274 else if(vec.y > top) top = vec.y;
4275 }
4276 }
4277 }
4278 left = left & -64;
4279 right = (right + 63) & -64;
4280 bottom = bottom & -64;
4281 top = (top + 63) & -64;
4282
4283 TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
4284 vec.x = ft_face->glyph->metrics.horiAdvance;
4285 vec.y = 0;
4286 pFT_Vector_Transform(&vec, &transMat);
4287 lpgm->gmCellIncX = (vec.x+63) >> 6;
4288 lpgm->gmCellIncY = -((vec.y+63) >> 6);
4289 }
4290 lpgm->gmBlackBoxX = (right - left) >> 6;
4291 lpgm->gmBlackBoxY = (top - bottom) >> 6;
4292 lpgm->gmptGlyphOrigin.x = left >> 6;
4293 lpgm->gmptGlyphOrigin.y = top >> 6;
4294
4295 if(format == GGO_METRICS || format == GGO_BITMAP || format == WINE_GGO_GRAY16_BITMAP)
4296 {
4297 FONT_GM(font,original_index)->gm = *lpgm;
4298 FONT_GM(font,original_index)->adv = adv;
4299 FONT_GM(font,original_index)->lsb = lsb;
4300 FONT_GM(font,original_index)->bbx = bbx;
4301 FONT_GM(font,original_index)->init = TRUE;
4302 }
4303
4304 if(format == GGO_METRICS)
4305 {
4306 LeaveCriticalSection( &freetype_cs );
4307 return 1; /* FIXME */
4308 }
4309
4310 if(ft_face->glyph->format != ft_glyph_format_outline && format != GGO_BITMAP && format != WINE_GGO_GRAY16_BITMAP) {
4311 TRACE("loaded a bitmap\n");
4312 LeaveCriticalSection( &freetype_cs );
4313 return GDI_ERROR;
4314 }
4315
4316 switch(format) {
4317 case GGO_BITMAP:
4318 width = lpgm->gmBlackBoxX;
4319 height = lpgm->gmBlackBoxY;
4320 pitch = ((width + 31) >> 5) << 2;
4321 needed = pitch * height;
4322
4323 if(!buf || !buflen) break;
4324
4325 switch(ft_face->glyph->format) {
4326 case ft_glyph_format_bitmap:
4327 {
4328 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
4329 INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
4330 INT h = ft_face->glyph->bitmap.rows;
4331 while(h--) {
4332 memcpy(dst, src, w);
4333 src += ft_face->glyph->bitmap.pitch;
4334 dst += pitch;
4335 }
4336 break;
4337 }
4338
4339 case ft_glyph_format_outline:
4340 ft_bitmap.width = width;
4341 ft_bitmap.rows = height;
4342 ft_bitmap.pitch = pitch;
4343 ft_bitmap.pixel_mode = ft_pixel_mode_mono;
4344 ft_bitmap.buffer = buf;
4345
4346 if(needsTransform) {
4347 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
4348 }
4349
4350 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
4351
4352 /* Note: FreeType will only set 'black' bits for us. */
4353 memset(buf, 0, needed);
4354 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
4355 break;
4356
4357 default:
4358 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
4359 LeaveCriticalSection( &freetype_cs );
4360 return GDI_ERROR;
4361 }
4362 break;
4363
4364 case GGO_GRAY2_BITMAP:
4365 case GGO_GRAY4_BITMAP:
4366 case GGO_GRAY8_BITMAP:
4367 case WINE_GGO_GRAY16_BITMAP:
4368 {
4369 unsigned int mult, row, col;
4370 BYTE *start, *ptr;
4371
4372 width = lpgm->gmBlackBoxX;
4373 height = lpgm->gmBlackBoxY;
4374 pitch = (width + 3) / 4 * 4;
4375 needed = pitch * height;
4376
4377 if(!buf || !buflen) break;
4378
4379 switch(ft_face->glyph->format) {
4380 case ft_glyph_format_bitmap:
4381 {
4382 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
4383 INT h = ft_face->glyph->bitmap.rows;
4384 INT x;
4385 while(h--) {
4386 for(x = 0; x < pitch; x++)
4387 dst[x] = (src[x / 8] & (1 << ( (7 - (x % 8))))) ? 0xff : 0;
4388 src += ft_face->glyph->bitmap.pitch;
4389 dst += pitch;
4390 }
4391 LeaveCriticalSection( &freetype_cs );
4392 return needed;
4393 }
4394 case ft_glyph_format_outline:
4395 {
4396 ft_bitmap.width = width;
4397 ft_bitmap.rows = height;
4398 ft_bitmap.pitch = pitch;
4399 ft_bitmap.pixel_mode = ft_pixel_mode_grays;
4400 ft_bitmap.buffer = buf;
4401
4402 if(needsTransform)
4403 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
4404
4405 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
4406
4407 memset(ft_bitmap.buffer, 0, buflen);
4408
4409 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
4410
4411 if(format == GGO_GRAY2_BITMAP)
4412 mult = 4;
4413 else if(format == GGO_GRAY4_BITMAP)
4414 mult = 16;
4415 else if(format == GGO_GRAY8_BITMAP)
4416 mult = 64;
4417 else /* format == WINE_GGO_GRAY16_BITMAP */
4418 {
4419 LeaveCriticalSection( &freetype_cs );
4420 return needed;
4421 }
4422 break;
4423 }
4424 default:
4425 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
4426 LeaveCriticalSection( &freetype_cs );
4427 return GDI_ERROR;
4428 }
4429
4430 start = buf;
4431 for(row = 0; row < height; row++) {
4432 ptr = start;
4433 for(col = 0; col < width; col++, ptr++) {
4434 *ptr = (((int)*ptr) * mult + 128) / 256;
4435 }
4436 start += pitch;
4437 }
4438 break;
4439 }
4440
4441 case GGO_NATIVE:
4442 {
4443 int contour, point = 0, first_pt;
4444 FT_Outline *outline = &ft_face->glyph->outline;
4445 TTPOLYGONHEADER *pph;
4446 TTPOLYCURVE *ppc;
4447 DWORD pph_start, cpfx, type;
4448
4449 if(buflen == 0) buf = NULL;
4450
4451 if (needsTransform && buf) {
4452 pFT_Outline_Transform(outline, &transMat);
4453 }
4454
4455 for(contour = 0; contour < outline->n_contours; contour++) {
4456 pph_start = needed;
4457 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
4458 first_pt = point;
4459 if(buf) {
4460 pph->dwType = TT_POLYGON_TYPE;
4461 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
4462 }
4463 needed += sizeof(*pph);
4464 point++;
4465 while(point <= outline->contours[contour]) {
4466 ppc = (TTPOLYCURVE *)((char *)buf + needed);
4467 type = (outline->tags[point] & FT_Curve_Tag_On) ?
4468 TT_PRIM_LINE : TT_PRIM_QSPLINE;
4469 cpfx = 0;
4470 do {
4471 if(buf)
4472 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4473 cpfx++;
4474 point++;
4475 } while(point <= outline->contours[contour] &&
4476 (outline->tags[point] & FT_Curve_Tag_On) ==
4477 (outline->tags[point-1] & FT_Curve_Tag_On));
4478 /* At the end of a contour Windows adds the start point, but
4479 only for Beziers */
4480 if(point > outline->contours[contour] &&
4481 !(outline->tags[point-1] & FT_Curve_Tag_On)) {
4482 if(buf)
4483 FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
4484 cpfx++;
4485 } else if(point <= outline->contours[contour] &&
4486 outline->tags[point] & FT_Curve_Tag_On) {
4487 /* add closing pt for bezier */
4488 if(buf)
4489 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4490 cpfx++;
4491 point++;
4492 }
4493 if(buf) {
4494 ppc->wType = type;
4495 ppc->cpfx = cpfx;
4496 }
4497 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
4498 }
4499 if(buf)
4500 pph->cb = needed - pph_start;
4501 }
4502 break;
4503 }
4504 case GGO_BEZIER:
4505 {
4506 /* Convert the quadratic Beziers to cubic Beziers.
4507 The parametric eqn for a cubic Bezier is, from PLRM:
4508 r(t) = at^3 + bt^2 + ct + r0
4509 with the control points:
4510 r1 = r0 + c/3
4511 r2 = r1 + (c + b)/3
4512 r3 = r0 + c + b + a
4513
4514 A quadratic Beizer has the form:
4515 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
4516
4517 So equating powers of t leads to:
4518 r1 = 2/3 p1 + 1/3 p0
4519 r2 = 2/3 p1 + 1/3 p2
4520 and of course r0 = p0, r3 = p2
4521 */
4522
4523 int contour, point = 0, first_pt;
4524 FT_Outline *outline = &ft_face->glyph->outline;
4525 TTPOLYGONHEADER *pph;
4526 TTPOLYCURVE *ppc;
4527 DWORD pph_start, cpfx, type;
4528 FT_Vector cubic_control[4];
4529 if(buflen == 0) buf = NULL;
4530
4531 if (needsTransform && buf) {
4532 pFT_Outline_Transform(outline, &transMat);
4533 }
4534
4535 for(contour = 0; contour < outline->n_contours; contour++) {
4536 pph_start = needed;
4537 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
4538 first_pt = point;
4539 if(buf) {
4540 pph->dwType = TT_POLYGON_TYPE;
4541 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
4542 }
4543 needed += sizeof(*pph);
4544 point++;
4545 while(point <= outline->contours[contour]) {
4546 ppc = (TTPOLYCURVE *)((char *)buf + needed);
4547 type = (outline->tags[point] & FT_Curve_Tag_On) ?
4548 TT_PRIM_LINE : TT_PRIM_CSPLINE;
4549 cpfx = 0;
4550 do {
4551 if(type == TT_PRIM_LINE) {
4552 if(buf)
4553 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4554 cpfx++;
4555 point++;
4556 } else {
4557 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
4558 so cpfx = 3n */
4559
4560 /* FIXME: Possible optimization in endpoint calculation
4561 if there are two consecutive curves */
4562 cubic_control[0] = outline->points[point-1];
4563 if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
4564 cubic_control[0].x += outline->points[point].x + 1;
4565 cubic_control[0].y += outline->points[point].y + 1;
4566 cubic_control[0].x >>= 1;
4567 cubic_control[0].y >>= 1;
4568 }
4569 if(point+1 > outline->contours[contour])
4570 cubic_control[3] = outline->points[first_pt];
4571 else {
4572 cubic_control[3] = outline->points[point+1];
4573 if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
4574 cubic_control[3].x += outline->points[point].x + 1;
4575 cubic_control[3].y += outline->points[point].y + 1;
4576 cubic_control[3].x >>= 1;
4577 cubic_control[3].y >>= 1;
4578 }
4579 }
4580 /* r1 = 1/3 p0 + 2/3 p1
4581 r2 = 1/3 p2 + 2/3 p1 */
4582 cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
4583 cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
4584 cubic_control[2] = cubic_control[1];
4585 cubic_control[1].x += (cubic_control[0].x + 1) / 3;
4586 cubic_control[1].y += (cubic_control[0].y + 1) / 3;
4587 cubic_control[2].x += (cubic_control[3].x + 1) / 3;
4588 cubic_control[2].y += (cubic_control[3].y + 1) / 3;
4589 if(buf) {
4590 FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
4591 FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
4592 FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
4593 }
4594 cpfx += 3;
4595 point++;
4596 }
4597 } while(point <= outline->contours[contour] &&
4598 (outline->tags[point] & FT_Curve_Tag_On) ==
4599 (outline->tags[point-1] & FT_Curve_Tag_On));
4600 /* At the end of a contour Windows adds the start point,
4601 but only for Beziers and we've already done that.
4602 */
4603 if(point <= outline->contours[contour] &&
4604 outline->tags[point] & FT_Curve_Tag_On) {
4605 /* This is the closing pt of a bezier, but we've already
4606 added it, so just inc point and carry on */
4607 point++;
4608 }
4609 if(buf) {
4610 ppc->wType = type;
4611 ppc->cpfx = cpfx;
4612 }
4613 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
4614 }
4615 if(buf)
4616 pph->cb = needed - pph_start;
4617 }
4618 break;
4619 }
4620
4621 default:
4622 FIXME("Unsupported format %d\n", format);
4623 LeaveCriticalSection( &freetype_cs );
4624 return GDI_ERROR;
4625 }
4626 LeaveCriticalSection( &freetype_cs );
4627 return needed;
4628 }
4629
4630 static BOOL get_bitmap_text_metrics(GdiFont *font)
4631 {
4632 FT_Face ft_face = font->ft_face;
4633 #ifdef HAVE_FREETYPE_FTWINFNT_H
4634 FT_WinFNT_HeaderRec winfnt_header;
4635 #endif
4636 const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
4637 font->potm = HeapAlloc(GetProcessHeap(), 0, size);
4638 font->potm->otmSize = size;
4639
4640 #define TM font->potm->otmTextMetrics
4641 #ifdef HAVE_FREETYPE_FTWINFNT_H
4642 if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
4643 {
4644 TM.tmHeight = winfnt_header.pixel_height;
4645 TM.tmAscent = winfnt_header.ascent;
4646 TM.tmDescent = TM.tmHeight - TM.tmAscent;
4647 TM.tmInternalLeading = winfnt_header.internal_leading;
4648 TM.tmExternalLeading = winfnt_header.external_leading;
4649 TM.tmAveCharWidth = winfnt_header.avg_width;
4650 TM.tmMaxCharWidth = winfnt_header.max_width;
4651 TM.tmWeight = winfnt_header.weight;
4652 TM.tmOverhang = 0;
4653 TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
4654 TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
4655 TM.tmFirstChar = winfnt_header.first_char;
4656 TM.tmLastChar = winfnt_header.last_char;
4657 TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
4658 TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
4659 TM.tmItalic = winfnt_header.italic;
4660 TM.tmUnderlined = font->underline;
4661 TM.tmStruckOut = font->strikeout;
4662 TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
4663 TM.tmCharSet = winfnt_header.charset;
4664 }
4665 else
4666 #endif
4667 {
4668 TM.tmAscent = ft_face->size->metrics.ascender >> 6;
4669 TM.tmDescent = -ft_face->size->metrics.descender >> 6;
4670 TM.tmHeight = TM.tmAscent + TM.tmDescent;
4671 TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
4672 TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
4673 TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
4674 TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
4675 TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
4676 TM.tmOverhang = 0;
4677 TM.tmDigitizedAspectX = 96; /* FIXME */
4678 TM.tmDigitizedAspectY = 96; /* FIXME */
4679 TM.tmFirstChar = 1;
4680 TM.tmLastChar = 255;
4681 TM.tmDefaultChar = 32;
4682 TM.tmBreakChar = 32;
4683 TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
4684 TM.tmUnderlined = font->underline;
4685 TM.tmStruckOut = font->strikeout;
4686 /* NB inverted meaning of TMPF_FIXED_PITCH */
4687 TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
4688 TM.tmCharSet = font->charset;
4689 }
4690 #undef TM
4691
4692 return TRUE;
4693 }
4694
4695
4696 static void scale_font_metrics(const GdiFont *font, LPTEXTMETRICW ptm)
4697 {
4698 float scale_x;
4699
4700 if (font->aveWidth)
4701 {
4702 scale_x = (float)font->aveWidth * font->font_desc.matrix.eM11;
4703 scale_x /= (float)font->potm->otmTextMetrics.tmAveCharWidth;
4704 }
4705 else
4706 scale_x = font->scale_y;
4707
4708 ptm->tmHeight = (float)ptm->tmHeight * font->scale_y;
4709 ptm->tmAscent = (float)ptm->tmAscent * font->scale_y;
4710 ptm->tmDescent = (float)ptm->tmDescent * font->scale_y;
4711 ptm->tmInternalLeading = (float)ptm->tmInternalLeading * font->scale_y;
4712 ptm->tmExternalLeading = (float)ptm->tmExternalLeading * font->scale_y;
4713
4714 ptm->tmAveCharWidth = (float)ptm->tmAveCharWidth * scale_x;
4715 ptm->tmMaxCharWidth = (float)ptm->tmMaxCharWidth * scale_x;
4716 }
4717
4718 /*************************************************************
4719 * WineEngGetTextMetrics
4720 *
4721 */
4722 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
4723 {
4724 EnterCriticalSection( &freetype_cs );
4725 if(!font->potm) {
4726 if(!WineEngGetOutlineTextMetrics(font, 0, NULL))
4727 if(!get_bitmap_text_metrics(font))
4728 {
4729 LeaveCriticalSection( &freetype_cs );
4730 return FALSE;
4731 }
4732 }
4733 if(!font->potm)
4734 {
4735 LeaveCriticalSection( &freetype_cs );
4736 return FALSE;
4737 }
4738 *ptm = font->potm->otmTextMetrics;
4739 scale_font_metrics(font, ptm);
4740 LeaveCriticalSection( &freetype_cs );
4741 return TRUE;
4742 }
4743
4744
4745 /*************************************************************
4746 * WineEngGetOutlineTextMetrics
4747 *
4748 */
4749 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
4750 OUTLINETEXTMETRICW *potm)
4751 {
4752 FT_Face ft_face = font->ft_face;
4753 UINT needed, lenfam, lensty, ret;
4754 TT_OS2 *pOS2;
4755 TT_HoriHeader *pHori;
4756 TT_Postscript *pPost;
4757 FT_Fixed x_scale, y_scale;
4758 WCHAR *family_nameW, *style_nameW;
4759 static const WCHAR spaceW[] = {' ', '\0'};
4760 char *cp;
4761 INT ascent, descent;
4762
4763 TRACE("font=%p\n", font);
4764
4765 if(!FT_IS_SCALABLE(ft_face))
4766 return 0;
4767
4768 EnterCriticalSection( &freetype_cs );
4769
4770 if(font->potm) {
4771 if(cbSize >= font->potm->otmSize)
4772 {
4773 memcpy(potm, font->potm, font->potm->otmSize);
4774 scale_font_metrics(font, &potm->otmTextMetrics);
4775 }
4776 LeaveCriticalSection( &freetype_cs );
4777 return font->potm->otmSize;
4778 }
4779
4780
4781 needed = sizeof(*potm);
4782
4783 lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
4784 family_nameW = strdupW(font->name);
4785
4786 lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
4787 * sizeof(WCHAR);
4788 style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
4789 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
4790 style_nameW, lensty/sizeof(WCHAR));
4791
4792 /* These names should be read from the TT name table */
4793
4794 /* length of otmpFamilyName */
4795 needed += lenfam;
4796
4797 /* length of otmpFaceName */
4798 if(!strcasecmp(ft_face->style_name, "regular")) {
4799 needed += lenfam; /* just the family name */
4800 } else {
4801 needed += lenfam + lensty; /* family + " " + style */
4802 }
4803
4804 /* length of otmpStyleName */
4805 needed += lensty;
4806
4807 /* length of otmpFullName */
4808 needed += lenfam + lensty;
4809
4810
4811 x_scale = ft_face->size->metrics.x_scale;
4812 y_scale = ft_face->size->metrics.y_scale;
4813
4814 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
4815 if(!pOS2) {
4816 FIXME("Can't find OS/2 table - not TT font?\n");
4817 ret = 0;
4818 goto end;
4819 }
4820
4821 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
4822 if(!pHori) {
4823 FIXME("Can't find HHEA table - not TT font?\n");
4824 ret = 0;
4825 goto end;
4826 }
4827
4828 pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
4829
4830 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",
4831 pOS2->usWinAscent, pOS2->usWinDescent,
4832 pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
4833 ft_face->ascender, ft_face->descender, ft_face->height,
4834 pHori->Ascender, pHori->Descender, pHori->Line_Gap,
4835 ft_face->bbox.yMax, ft_face->bbox.yMin);
4836
4837 font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
4838 font->potm->otmSize = needed;
4839
4840 #define TM font->potm->otmTextMetrics
4841
4842 if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
4843 ascent = pHori->Ascender;
4844 descent = -pHori->Descender;
4845 } else {
4846 ascent = pOS2->usWinAscent;
4847 descent = pOS2->usWinDescent;
4848 }
4849
4850 if(font->yMax) {
4851 TM.tmAscent = font->yMax;
4852 TM.tmDescent = -font->yMin;
4853 TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
4854 } else {
4855 TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
4856 TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
4857 TM.tmInternalLeading = (pFT_MulFix(ascent + descent
4858 - ft_face->units_per_EM, y_scale) + 32) >> 6;
4859 }
4860
4861 TM.tmHeight = TM.tmAscent + TM.tmDescent;
4862
4863 /* MSDN says:
4864 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
4865 */
4866 TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
4867 ((ascent + descent) -
4868 (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
4869
4870 TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
4871 if (TM.tmAveCharWidth == 0) {
4872 TM.tmAveCharWidth = 1;
4873 }
4874 TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
4875 TM.tmWeight = font->fake_bold ? FW_BOLD : pOS2->usWeightClass;
4876 TM.tmOverhang = 0;
4877 TM.tmDigitizedAspectX = 300;
4878 TM.tmDigitizedAspectY = 300;
4879 /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
4880 * symbol range to 0 - f0ff
4881 */
4882 if (font->charset == SYMBOL_CHARSET)
4883 TM.tmFirstChar = 0;
4884 else
4885 TM.tmFirstChar = pOS2->usFirstCharIndex;
4886 TM.tmLastChar = pOS2->usLastCharIndex;
4887 TM.tmDefaultChar = pOS2->usDefaultChar ? pOS2->usDefaultChar : 0x1f;
4888 TM.tmBreakChar = pOS2->usBreakChar ? pOS2->usBreakChar : ' ';
4889 TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
4890 TM.tmUnderlined = font->underline;
4891 TM.tmStruckOut = font->strikeout;
4892
4893 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
4894 if(!FT_IS_FIXED_WIDTH(ft_face) &&
4895 (pOS2->version == 0xFFFFU ||
4896 pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
4897 TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
4898 else
4899 TM.tmPitchAndFamily = 0;
4900
4901 switch(pOS2->panose[PAN_FAMILYTYPE_INDEX]) {
4902 case PAN_FAMILY_SCRIPT:
4903 TM.tmPitchAndFamily |= FF_SCRIPT;
4904 break;
4905 case PAN_FAMILY_DECORATIVE:
4906 case PAN_FAMILY_PICTORIAL:
4907 TM.tmPitchAndFamily |= FF_DECORATIVE;
4908 break;
4909 case PAN_FAMILY_TEXT_DISPLAY:
4910 if(TM.tmPitchAndFamily == 0) /* fixed */
4911 TM.tmPitchAndFamily = FF_MODERN;
4912 else {
4913 switch(pOS2->panose[PAN_SERIFSTYLE_INDEX]) {
4914 case PAN_SERIF_NORMAL_SANS:
4915 case PAN_SERIF_OBTUSE_SANS:
4916 case PAN_SERIF_PERP_SANS:
4917 TM.tmPitchAndFamily |= FF_SWISS;
4918 break;
4919 default:
4920 TM.tmPitchAndFamily |= FF_ROMAN;
4921 }
4922 }
4923 break;
4924 default:
4925 TM.tmPitchAndFamily |= FF_DONTCARE;
4926 }
4927
4928 if(FT_IS_SCALABLE(ft_face))
4929 TM.tmPitchAndFamily |= TMPF_VECTOR;
4930
4931 if(FT_IS_SFNT(ft_face))
4932 {
4933 if (font->ntmFlags & NTM_PS_OPENTYPE)
4934 TM.tmPitchAndFamily |= TMPF_DEVICE;
4935 else
4936 TM.tmPitchAndFamily |= TMPF_TRUETYPE;
4937 }
4938
4939 TM.tmCharSet = font->charset;
4940 #undef TM
4941
4942 font->potm->otmFiller = 0;
4943 memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
4944 font->potm->otmfsSelection = pOS2->fsSelection;
4945 font->potm->otmfsType = pOS2->fsType;
4946 font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
4947 font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
4948 font->potm->otmItalicAngle = 0; /* POST table */
4949 font->potm->otmEMSquare = ft_face->units_per_EM;
4950 font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
4951 font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
4952 font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
4953 font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
4954 font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
4955 font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
4956 font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
4957 font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
4958 font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
4959 font->potm->otmMacAscent = 0; /* where do these come from ? */
4960 font->potm->otmMacDescent = 0;
4961 font->potm->otmMacLineGap = 0;
4962 font->potm->otmusMinimumPPEM = 0; /* TT Header */
4963 font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
4964 font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
4965 font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
4966 font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
4967 font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
4968 font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
4969 font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
4970 font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
4971 font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
4972 font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
4973 if(!pPost) {
4974 font->potm->otmsUnderscoreSize = 0;
4975 font->potm->otmsUnderscorePosition = 0;
4976 } else {
4977 font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
4978 font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
4979 }
4980
4981 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
4982 cp = (char*)font->potm + sizeof(*font->potm);
4983 font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
4984 strcpyW((WCHAR*)cp, family_nameW);
4985 cp += lenfam;
4986 font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
4987 strcpyW((WCHAR*)cp, style_nameW);
4988 cp += lensty;
4989 font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
4990 strcpyW((WCHAR*)cp, family_nameW);
4991 if(strcasecmp(ft_face->style_name, "regular")) {
4992 strcatW((WCHAR*)cp, spaceW);
4993 strcatW((WCHAR*)cp, style_nameW);
4994 cp += lenfam + lensty;
4995 } else
4996 cp += lenfam;
4997 font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
4998 strcpyW((WCHAR*)cp, family_nameW);
4999 strcatW((WCHAR*)cp, spaceW);
5000 strcatW((WCHAR*)cp, style_nameW);
5001 ret = needed;
5002
5003 if(potm && needed <= cbSize)
5004 {
5005 memcpy(potm, font->potm, font->potm->otmSize);
5006 scale_font_metrics(font, &potm->otmTextMetrics);
5007 }
5008
5009 end:
5010 HeapFree(GetProcessHeap(), 0, style_nameW);
5011 HeapFree(GetProcessHeap(), 0, family_nameW);
5012
5013 LeaveCriticalSection( &freetype_cs );
5014 return ret;
5015 }
5016
5017 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
5018 {
5019 HFONTLIST *hfontlist;
5020 child->font = alloc_font();
5021 child->font->ft_face = OpenFontFace(child->font, child->face, 0, -font->ppem);
5022 if(!child->font->ft_face)
5023 {
5024 free_font(child->font);
5025 child->font = NULL;
5026 return FALSE;
5027 }
5028
5029 child->font->ntmFlags = child->face->ntmFlags;
5030 child->font->orientation = font->orientation;
5031 child->font->scale_y = font->scale_y;
5032 hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
5033 hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
5034 list_add_head(&child->font->hfontlist, &hfontlist->entry);
5035 child->font->base_font = font;
5036 list_add_head(&child_font_list, &child->font->entry);
5037 TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
5038 return TRUE;
5039 }
5040
5041 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
5042 {
5043 FT_UInt g;
5044 CHILD_FONT *child_font;
5045
5046 if(font->base_font)
5047 font = font->base_font;
5048
5049 *linked_font = font;
5050
5051 if((*glyph = get_glyph_index(font, c)))
5052 return TRUE;
5053
5054 LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
5055 {
5056 if(!child_font->font)
5057 if(!load_child_font(font, child_font))
5058 continue;
5059
5060 if(!child_font->font->ft_face)
5061 continue;
5062 g = get_glyph_index(child_font->font, c);
5063 if(g)
5064 {
5065 *glyph = g;
5066 *linked_font = child_font->font;
5067 return TRUE;
5068 }
5069 }
5070 return FALSE;
5071 }
5072
5073 /*************************************************************
5074 * WineEngGetCharWidth
5075 *
5076 */
5077 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
5078 LPINT buffer)
5079 {
5080 UINT c;
5081 GLYPHMETRICS gm;
5082 FT_UInt glyph_index;
5083 GdiFont *linked_font;
5084
5085 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
5086
5087 EnterCriticalSection( &freetype_cs );
5088 for(c = firstChar; c <= lastChar; c++) {
5089 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
5090 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5091 &gm, 0, NULL, NULL);
5092 buffer[c - firstChar] = FONT_GM(linked_font,glyph_index)->adv;
5093 }
5094 LeaveCriticalSection( &freetype_cs );
5095 return TRUE;
5096 }
5097
5098 /*************************************************************
5099 * WineEngGetCharABCWidths
5100 *
5101 */
5102 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
5103 LPABC buffer)
5104 {
5105 UINT c;
5106 GLYPHMETRICS gm;
5107 FT_UInt glyph_index;
5108 GdiFont *linked_font;
5109
5110 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
5111
5112 if(!FT_IS_SCALABLE(font->ft_face))
5113 return FALSE;
5114
5115 EnterCriticalSection( &freetype_cs );
5116
5117 for(c = firstChar; c <= lastChar; c++) {
5118 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
5119 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5120 &gm, 0, NULL, NULL);
5121 buffer[c - firstChar].abcA = FONT_GM(linked_font,glyph_index)->lsb;
5122 buffer[c - firstChar].abcB = FONT_GM(linked_font,glyph_index)->bbx;
5123 buffer[c - firstChar].abcC = FONT_GM(linked_font,glyph_index)->adv - FONT_GM(linked_font,glyph_index)->lsb -
5124 FONT_GM(linked_font,glyph_index)->bbx;
5125 }
5126 LeaveCriticalSection( &freetype_cs );
5127 return TRUE;
5128 }
5129
5130 /*************************************************************
5131 * WineEngGetCharABCWidthsI
5132 *
5133 */
5134 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
5135 LPABC buffer)
5136 {
5137 UINT c;
5138 GLYPHMETRICS gm;
5139 FT_UInt glyph_index;
5140 GdiFont *linked_font;
5141
5142 if(!FT_HAS_HORIZONTAL(font->ft_face))
5143 return FALSE;
5144
5145 EnterCriticalSection( &freetype_cs );
5146
5147 get_glyph_index_linked(font, 'a', &linked_font, &glyph_index);
5148 if (!pgi)
5149 for(c = firstChar; c < firstChar+count; c++) {
5150 WineEngGetGlyphOutline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
5151 &gm, 0, NULL, NULL);
5152 buffer[c - firstChar].abcA = FONT_GM(linked_font,c)->lsb;
5153 buffer[c - firstChar].abcB = FONT_GM(linked_font,c)->bbx;
5154 buffer[c - firstChar].abcC = FONT_GM(linked_font,c)->adv - FONT_GM(linked_font,c)->lsb
5155 - FONT_GM(linked_font,c)->bbx;
5156 }
5157 else
5158 for(c = 0; c < count; c++) {
5159 WineEngGetGlyphOutline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
5160 &gm, 0, NULL, NULL);
5161 buffer[c].abcA = FONT_GM(linked_font,pgi[c])->lsb;
5162 buffer[c].abcB = FONT_GM(linked_font,pgi[c])->bbx;
5163 buffer[c].abcC = FONT_GM(linked_font,pgi[c])->adv
5164 - FONT_GM(linked_font,pgi[c])->lsb - FONT_GM(linked_font,pgi[c])->bbx;
5165 }
5166
5167 LeaveCriticalSection( &freetype_cs );
5168 return TRUE;
5169 }
5170
5171 /*************************************************************
5172 * WineEngGetTextExtentExPoint
5173 *
5174 */
5175 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
5176 INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
5177 {
5178 INT idx;
5179 INT nfit = 0, ext;
5180 GLYPHMETRICS gm;
5181 TEXTMETRICW tm;
5182 FT_UInt glyph_index;
5183 GdiFont *linked_font;
5184
5185 TRACE("%p, %s, %d, %d, %p\n", font, debugstr_wn(wstr, count), count,
5186 max_ext, size);
5187
5188 EnterCriticalSection( &freetype_cs );
5189
5190 size->cx = 0;
5191 WineEngGetTextMetrics(font, &tm);
5192 size->cy = tm.tmHeight;
5193
5194 for(idx = 0; idx < count; idx++) {
5195 get_glyph_index_linked(font, wstr[idx], &linked_font, &glyph_index);
5196 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5197 &gm, 0, NULL, NULL);
5198 size->cx += FONT_GM(linked_font,glyph_index)->adv;
5199 ext = size->cx;
5200 if (! pnfit || ext <= max_ext) {
5201 ++nfit;
5202 if (dxs)
5203 dxs[idx] = ext;
5204 }
5205 }
5206
5207 if (pnfit)
5208 *pnfit = nfit;
5209
5210 LeaveCriticalSection( &freetype_cs );
5211 TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
5212 return TRUE;
5213 }
5214
5215 /*************************************************************
5216 * WineEngGetTextExtentExPointI
5217 *
5218 */
5219 BOOL WineEngGetTextExtentExPointI(GdiFont *font, const WORD *indices, INT count,
5220 INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
5221 {
5222 INT idx;
5223 INT nfit = 0, ext;
5224 GLYPHMETRICS gm;
5225 TEXTMETRICW tm;
5226
5227 TRACE("%p, %p, %d, %d, %p\n", font, indices, count, max_ext, size);
5228
5229 EnterCriticalSection( &freetype_cs );
5230
5231 size->cx = 0;
5232 WineEngGetTextMetrics(font, &tm);
5233 size->cy = tm.tmHeight;
5234
5235 for(idx = 0; idx < count; idx++) {
5236 WineEngGetGlyphOutline(font, indices[idx],
5237 GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL,
5238 NULL);
5239 size->cx += FONT_GM(font,indices[idx])->adv;
5240 ext = size->cx;
5241 if (! pnfit || ext <= max_ext) {
5242 ++nfit;
5243 if (dxs)
5244 dxs[idx] = ext;
5245 }
5246 }
5247
5248 if (pnfit)
5249 *pnfit = nfit;
5250
5251 LeaveCriticalSection( &freetype_cs );
5252 TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
5253 return TRUE;
5254 }
5255
5256 /*************************************************************
5257 * WineEngGetFontData
5258 *
5259 */
5260 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
5261 DWORD cbData)
5262 {
5263 FT_Face ft_face = font->ft_face;
5264 FT_ULong len;
5265 FT_Error err;
5266
5267 TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
5268 font, LOBYTE(LOWORD(table)), HIBYTE(LOWORD(table)),
5269 LOBYTE(HIWORD(table)), HIBYTE(HIWORD(table)), offset, buf, cbData);
5270
5271 if(!FT_IS_SFNT(ft_face))
5272 return GDI_ERROR;
5273
5274 if(!buf || !cbData)
5275 len = 0;
5276 else
5277 len = cbData;
5278
5279 if(table) { /* MS tags differ in endianness from FT ones */
5280 table = table >> 24 | table << 24 |
5281 (table >> 8 & 0xff00) | (table << 8 & 0xff0000);
5282 }
5283
5284 /* make sure value of len is the value freetype says it needs */
5285 if(buf && len)
5286 {
5287 FT_ULong needed = 0;
5288 err = load_sfnt_table(ft_face, table, offset, NULL, &needed);
5289 if( !err && needed < len) len = needed;
5290 }
5291 err = load_sfnt_table(ft_face, table, offset, buf, &len);
5292
5293 if(err) {
5294 TRACE("Can't find table %c%c%c%c\n",
5295 /* bytes were reversed */
5296 HIBYTE(HIWORD(table)), LOBYTE(HIWORD(table)),
5297 HIBYTE(LOWORD(table)), LOBYTE(LOWORD(table)));
5298 return GDI_ERROR;
5299 }
5300 return len;
5301 }
5302
5303 /*************************************************************
5304 * WineEngGetTextFace
5305 *
5306 */
5307 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
5308 {
5309 if(str) {
5310 lstrcpynW(str, font->name, count);
5311 return strlenW(font->name);
5312 } else
5313 return strlenW(font->name) + 1;
5314 }
5315
5316 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
5317 {
5318 if (fs) *fs = font->fs;
5319 return font->charset;
5320 }
5321
5322 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
5323 {
5324 GdiFont *font = dc->gdiFont, *linked_font;
5325 struct list *first_hfont;
5326 BOOL ret;
5327
5328 EnterCriticalSection( &freetype_cs );
5329 ret = get_glyph_index_linked(font, c, &linked_font, glyph);
5330 TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
5331 if(font == linked_font)
5332 *new_hfont = dc->hFont;
5333 else
5334 {
5335 first_hfont = list_head(&linked_font->hfontlist);
5336 *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
5337 }
5338 LeaveCriticalSection( &freetype_cs );
5339 return ret;
5340 }
5341
5342 /* Retrieve a list of supported Unicode ranges for a given font.
5343 * Can be called with NULL gs to calculate the buffer size. Returns
5344 * the number of ranges found.
5345 */
5346 static DWORD get_font_unicode_ranges(FT_Face face, GLYPHSET *gs)
5347 {
5348 DWORD num_ranges = 0;
5349
5350 if (face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
5351 {
5352 FT_UInt glyph_code;
5353 FT_ULong char_code, char_code_prev;
5354
5355 glyph_code = 0;
5356 char_code_prev = char_code = pFT_Get_First_Char(face, &glyph_code);
5357
5358 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
5359 face->num_glyphs, glyph_code, char_code);
5360
5361 if (!glyph_code) return 0;
5362
5363 if (gs)
5364 {
5365 gs->ranges[0].wcLow = (USHORT)char_code;
5366 gs->ranges[0].cGlyphs = 0;
5367 gs->cGlyphsSupported = 0;
5368 }
5369
5370 num_ranges = 1;
5371 while (glyph_code)
5372 {
5373 if (char_code < char_code_prev)
5374 {
5375 ERR("expected increasing char code from FT_Get_Next_Char\n");
5376 return 0;
5377 }
5378 if (char_code - char_code_prev > 1)
5379 {
5380 num_ranges++;
5381 if (gs)
5382 {
5383 gs->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
5384 gs->ranges[num_ranges - 1].cGlyphs = 1;
5385 gs->cGlyphsSupported++;
5386 }
5387 }
5388 else if (gs)
5389 {
5390 gs->ranges[num_ranges - 1].cGlyphs++;
5391 gs->cGlyphsSupported++;
5392 }
5393 char_code_prev = char_code;
5394 char_code = pFT_Get_Next_Char(face, char_code, &glyph_code);
5395 }
5396 }
5397 else
5398 FIXME("encoding %u not supported\n", face->charmap->encoding);
5399
5400 return num_ranges;
5401 }
5402
5403 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
5404 {
5405 DWORD size = 0;
5406 DWORD num_ranges = get_font_unicode_ranges(font->ft_face, glyphset);
5407
5408 size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
5409 if (glyphset)
5410 {
5411 glyphset->cbThis = size;
5412 glyphset->cRanges = num_ranges;
5413 }
5414 return size;
5415 }
5416
5417 /*************************************************************
5418 * FontIsLinked
5419 */
5420 BOOL WineEngFontIsLinked(GdiFont *font)
5421 {
5422 BOOL ret;
5423 EnterCriticalSection( &freetype_cs );
5424 ret = !list_empty(&font->child_fonts);
5425 LeaveCriticalSection( &freetype_cs );
5426 return ret;
5427 }
5428
5429 static BOOL is_hinting_enabled(void)
5430 {
5431 /* Use the >= 2.2.0 function if available */
5432 if(pFT_Get_TrueType_Engine_Type)
5433 {
5434 FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
5435 return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
5436 }
5437 #ifdef FT_DRIVER_HAS_HINTER
5438 else
5439 {
5440 FT_Module mod;
5441
5442 /* otherwise if we've been compiled with < 2.2.0 headers
5443 use the internal macro */
5444 mod = pFT_Get_Module(library, "truetype");
5445 if(mod && FT_DRIVER_HAS_HINTER(mod))
5446 return TRUE;
5447 }
5448 #endif
5449
5450 return FALSE;
5451 }
5452
5453 /*************************************************************************
5454 * GetRasterizerCaps (GDI32.@)
5455 */
5456 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
5457 {
5458 static int hinting = -1;
5459
5460 if(hinting == -1)
5461 {
5462 hinting = is_hinting_enabled();
5463 TRACE("hinting is %senabled\n", hinting ? "" : "NOT ");
5464 }
5465
5466 lprs->nSize = sizeof(RASTERIZER_STATUS);
5467 lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
5468 lprs->nLanguageID = 0;
5469 return TRUE;
5470 }
5471
5472 /*************************************************************************
5473 * Kerning support for TrueType fonts
5474 */
5475 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
5476
5477 struct TT_kern_table
5478 {
5479 USHORT version;
5480 USHORT nTables;
5481 };
5482
5483 struct TT_kern_subtable
5484 {
5485 USHORT version;
5486 USHORT length;
5487 union
5488 {
5489 USHORT word;
5490 struct
5491 {
5492 USHORT horizontal : 1;
5493 USHORT minimum : 1;
5494 USHORT cross_stream: 1;
5495 USHORT override : 1;
5496 USHORT reserved1 : 4;
5497 USHORT format : 8;
5498 } bits;
5499 } coverage;
5500 };
5501
5502 struct TT_format0_kern_subtable
5503 {
5504 USHORT nPairs;
5505 USHORT searchRange;
5506 USHORT entrySelector;
5507 USHORT rangeShift;
5508 };
5509
5510 struct TT_kern_pair
5511 {
5512 USHORT left;
5513 USHORT right;
5514 short value;
5515 };
5516
5517 static DWORD parse_format0_kern_subtable(GdiFont *font,
5518 const struct TT_format0_kern_subtable *tt_f0_ks,
5519 const USHORT *glyph_to_char,
5520 KERNINGPAIR *kern_pair, DWORD cPairs)
5521 {
5522 USHORT i, nPairs;
5523 const struct TT_kern_pair *tt_kern_pair;
5524
5525 TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
5526
5527 nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
5528
5529 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
5530 nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
5531 GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
5532
5533 if (!kern_pair || !cPairs)
5534 return nPairs;
5535
5536 tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
5537
5538 nPairs = min(nPairs, cPairs);
5539
5540 for (i = 0; i < nPairs; i++)
5541 {
5542 kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
5543 kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
5544 /* this algorithm appears to better match what Windows does */
5545 kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
5546 if (kern_pair->iKernAmount < 0)
5547 {
5548 kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
5549 kern_pair->iKernAmount -= font->ppem;
5550 }
5551 else if (kern_pair->iKernAmount > 0)
5552 {
5553 kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
5554 kern_pair->iKernAmount += font->ppem;
5555 }
5556 kern_pair->iKernAmount /= font->ft_face->units_per_EM;
5557
5558 TRACE("left %u right %u value %d\n",
5559 kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
5560
5561 kern_pair++;
5562 }
5563 TRACE("copied %u entries\n", nPairs);
5564 return nPairs;
5565 }
5566
5567 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
5568 {
5569 DWORD length;
5570 void *buf;
5571 const struct TT_kern_table *tt_kern_table;
5572 const struct TT_kern_subtable *tt_kern_subtable;
5573 USHORT i, nTables;
5574 USHORT *glyph_to_char;
5575
5576 EnterCriticalSection( &freetype_cs );
5577 if (font->total_kern_pairs != (DWORD)-1)
5578 {
5579 if (cPairs && kern_pair)
5580 {
5581 cPairs = min(cPairs, font->total_kern_pairs);
5582 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
5583 LeaveCriticalSection( &freetype_cs );
5584 return cPairs;
5585 }
5586 LeaveCriticalSection( &freetype_cs );
5587 return font->total_kern_pairs;
5588 }
5589
5590 font->total_kern_pairs = 0;
5591
5592 length = WineEngGetFontData(font, MS_KERN_TAG, 0, NULL, 0);
5593
5594 if (length == GDI_ERROR)
5595 {
5596 TRACE("no kerning data in the font\n");
5597 LeaveCriticalSection( &freetype_cs );
5598 return 0;
5599 }
5600
5601 buf = HeapAlloc(GetProcessHeap(), 0, length);
5602 if (!buf)
5603 {
5604 WARN("Out of memory\n");
5605 LeaveCriticalSection( &freetype_cs );
5606 return 0;
5607 }
5608
5609 WineEngGetFontData(font, MS_KERN_TAG, 0, buf, length);
5610
5611 /* build a glyph index to char code map */
5612 glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
5613 if (!glyph_to_char)
5614 {
5615 WARN("Out of memory allocating a glyph index to char code map\n");
5616 HeapFree(GetProcessHeap(), 0, buf);
5617 LeaveCriticalSection( &freetype_cs );
5618 return 0;
5619 }
5620
5621 if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
5622 {
5623 FT_UInt glyph_code;
5624 FT_ULong char_code;
5625
5626 glyph_code = 0;
5627 char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
5628
5629 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
5630 font->ft_face->num_glyphs, glyph_code, char_code);
5631
5632 while (glyph_code)
5633 {
5634 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
5635
5636 /* FIXME: This doesn't match what Windows does: it does some fancy
5637 * things with duplicate glyph index to char code mappings, while
5638 * we just avoid overriding existing entries.
5639 */
5640 if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
5641 glyph_to_char[glyph_code] = (USHORT)char_code;
5642
5643 char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
5644 }
5645 }
5646 else
5647 {
5648 ULONG n;
5649
5650 FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
5651 for (n = 0; n <= 65535; n++)
5652 glyph_to_char[n] = (USHORT)n;
5653 }
5654
5655 tt_kern_table = buf;
5656 nTables = GET_BE_WORD(tt_kern_table->nTables);
5657 TRACE("version %u, nTables %u\n",
5658 GET_BE_WORD(tt_kern_table->version), nTables);
5659
5660 tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
5661
5662 for (i = 0; i < nTables; i++)
5663 {
5664 struct TT_kern_subtable tt_kern_subtable_copy;
5665
5666 tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
5667 tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
5668 tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
5669
5670 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
5671 tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
5672 tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
5673
5674 /* According to the TrueType specification this is the only format
5675 * that will be properly interpreted by Windows and OS/2
5676 */
5677 if (tt_kern_subtable_copy.coverage.bits.format == 0)
5678 {
5679 DWORD new_chunk, old_total = font->total_kern_pairs;
5680
5681 new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
5682 glyph_to_char, NULL, 0);
5683 font->total_kern_pairs += new_chunk;
5684
5685 if (!font->kern_pairs)
5686 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
5687 font->total_kern_pairs * sizeof(*font->kern_pairs));
5688 else
5689 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
5690 font->total_kern_pairs * sizeof(*font->kern_pairs));
5691
5692 parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
5693 glyph_to_char, font->kern_pairs + old_total, new_chunk);
5694 }
5695 else
5696 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
5697
5698 tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
5699 }
5700
5701 HeapFree(GetProcessHeap(), 0, glyph_to_char);
5702 HeapFree(GetProcessHeap(), 0, buf);
5703
5704 if (cPairs && kern_pair)
5705 {
5706 cPairs = min(cPairs, font->total_kern_pairs);
5707 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
5708 LeaveCriticalSection( &freetype_cs );
5709 return cPairs;
5710 }
5711 LeaveCriticalSection( &freetype_cs );
5712 return font->total_kern_pairs;
5713 }
5714
5715 #else /* HAVE_FREETYPE */
5716
5717 /*************************************************************************/
5718
5719 BOOL WineEngInit(void)
5720 {
5721 return FALSE;
5722 }
5723 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
5724 {
5725 return NULL;
5726 }
5727 BOOL WineEngDestroyFontInstance(HFONT hfont)
5728 {
5729 return FALSE;
5730 }
5731
5732 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
5733 {
5734 return 1;
5735 }
5736
5737 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
5738 LPWORD pgi, DWORD flags)
5739 {
5740 return GDI_ERROR;
5741 }
5742
5743 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
5744 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
5745 const MAT2* lpmat)
5746 {
5747 ERR("called but we don't have FreeType\n");
5748 return GDI_ERROR;
5749 }
5750
5751 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
5752 {
5753 ERR("called but we don't have FreeType\n");
5754 return FALSE;
5755 }
5756
5757 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
5758 OUTLINETEXTMETRICW *potm)
5759 {
5760 ERR("called but we don't have FreeType\n");
5761 return 0;
5762 }
5763
5764 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
5765 LPINT buffer)
5766 {
5767 ERR("called but we don't have FreeType\n");
5768 return FALSE;
5769 }
5770
5771 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
5772 LPABC buffer)
5773 {
5774 ERR("called but we don't have FreeType\n");
5775 return FALSE;
5776 }
5777
5778 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
5779 LPABC buffer)
5780 {
5781 ERR("called but we don't have FreeType\n");
5782 return FALSE;
5783 }
5784
5785 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
5786 INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
5787 {
5788 ERR("called but we don't have FreeType\n");
5789 return FALSE;
5790 }
5791
5792 BOOL WineEngGetTextExtentExPointI(GdiFont *font, const WORD *indices, INT count,
5793 INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
5794 {
5795 ERR("called but we don't have FreeType\n");
5796 return FALSE;
5797 }
5798
5799 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
5800 DWORD cbData)
5801 {
5802 ERR("called but we don't have FreeType\n");
5803 return GDI_ERROR;
5804 }
5805
5806 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
5807 {
5808 ERR("called but we don't have FreeType\n");
5809 return 0;
5810 }
5811
5812 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
5813 {
5814 FIXME(":stub\n");
5815 return 1;
5816 }
5817
5818 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
5819 {
5820 FIXME(":stub\n");
5821 return TRUE;
5822 }
5823
5824 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
5825 {
5826 FIXME(":stub\n");
5827 return NULL;
5828 }
5829
5830 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
5831 {
5832 FIXME(":stub\n");
5833 return DEFAULT_CHARSET;
5834 }
5835
5836 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
5837 {
5838 return FALSE;
5839 }
5840
5841 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
5842 {
5843 FIXME("(%p, %p): stub\n", font, glyphset);
5844 return 0;
5845 }
5846
5847 BOOL WineEngFontIsLinked(GdiFont *font)
5848 {
5849 return FALSE;
5850 }
5851
5852 /*************************************************************************
5853 * GetRasterizerCaps (GDI32.@)
5854 */
5855 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
5856 {
5857 lprs->nSize = sizeof(RASTERIZER_STATUS);
5858 lprs->wFlags = 0;
5859 lprs->nLanguageID = 0;
5860 return TRUE;
5861 }
5862
5863 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
5864 {
5865 ERR("called but we don't have FreeType\n");
5866 return 0;
5867 }
5868
5869 #endif /* HAVE_FREETYPE */
Maarten's multimedia branch