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