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