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