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