?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usp10: Free default_language items when freeing script cache.
[wine.git] / dlls / gdi32 / freetype.c
blobb977b0d1fa20da60059958af8852d430f01430e7
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/library.h"
88 #include "wine/unicode.h"
89 #include "wine/debug.h"
90 #include "wine/list.h"
91
92 #include "resource.h"
93
94 WINE_DEFAULT_DEBUG_CHANNEL(font);
95
96 #ifdef HAVE_FREETYPE
97
98 #ifdef HAVE_FT2BUILD_H
99 #include <ft2build.h>
100 #endif
101 #ifdef HAVE_FREETYPE_FREETYPE_H
102 #include <freetype/freetype.h>
103 #endif
104 #ifdef HAVE_FREETYPE_FTGLYPH_H
105 #include <freetype/ftglyph.h>
106 #endif
107 #ifdef HAVE_FREETYPE_TTTABLES_H
108 #include <freetype/tttables.h>
109 #endif
110 #ifdef HAVE_FREETYPE_FTTYPES_H
111 #include <freetype/fttypes.h>
112 #endif
113 #ifdef HAVE_FREETYPE_FTSNAMES_H
114 #include <freetype/ftsnames.h>
115 #endif
116 #ifdef HAVE_FREETYPE_TTNAMEID_H
117 #include <freetype/ttnameid.h>
118 #endif
119 #ifdef HAVE_FREETYPE_FTOUTLN_H
120 #include <freetype/ftoutln.h>
121 #endif
122 #ifdef HAVE_FREETYPE_FTTRIGON_H
123 #include <freetype/fttrigon.h>
124 #endif
125 #ifdef HAVE_FREETYPE_FTWINFNT_H
126 #include <freetype/ftwinfnt.h>
127 #endif
128 #ifdef HAVE_FREETYPE_FTMODAPI_H
129 #include <freetype/ftmodapi.h>
130 #endif
131 #ifdef HAVE_FREETYPE_FTLCDFIL_H
132 #include <freetype/ftlcdfil.h>
133 #endif
134
135 #ifndef HAVE_FT_TRUETYPEENGINETYPE
136 typedef enum
137 {
138 FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
139 FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
140 FT_TRUETYPE_ENGINE_TYPE_PATENTED
141 } FT_TrueTypeEngineType;
142 #endif
143
144 static FT_Library library = 0;
145 typedef struct
146 {
147 FT_Int major;
148 FT_Int minor;
149 FT_Int patch;
150 } FT_Version_t;
151 static FT_Version_t FT_Version;
152 static DWORD FT_SimpleVersion;
153
154 static void *ft_handle = NULL;
155
156 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
157 MAKE_FUNCPTR(FT_Done_Face);
158 MAKE_FUNCPTR(FT_Get_Char_Index);
159 MAKE_FUNCPTR(FT_Get_First_Char);
160 MAKE_FUNCPTR(FT_Get_Module);
161 MAKE_FUNCPTR(FT_Get_Next_Char);
162 MAKE_FUNCPTR(FT_Get_Sfnt_Name);
163 MAKE_FUNCPTR(FT_Get_Sfnt_Name_Count);
164 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
165 MAKE_FUNCPTR(FT_Get_WinFNT_Header);
166 MAKE_FUNCPTR(FT_Init_FreeType);
167 MAKE_FUNCPTR(FT_Library_Version);
168 MAKE_FUNCPTR(FT_Load_Glyph);
169 MAKE_FUNCPTR(FT_Load_Sfnt_Table);
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_Render_Glyph);
182 MAKE_FUNCPTR(FT_Select_Charmap);
183 MAKE_FUNCPTR(FT_Set_Charmap);
184 MAKE_FUNCPTR(FT_Set_Pixel_Sizes);
185 MAKE_FUNCPTR(FT_Vector_Transform);
186 MAKE_FUNCPTR(FT_Vector_Unit);
187 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type)(FT_Library);
188 #ifdef HAVE_FREETYPE_FTLCDFIL_H
189 static FT_Error (*pFT_Library_SetLcdFilter)(FT_Library, FT_LcdFilter);
190 #endif
191
192 #ifdef SONAME_LIBFONTCONFIG
193 #include <fontconfig/fontconfig.h>
194 MAKE_FUNCPTR(FcConfigSubstitute);
195 MAKE_FUNCPTR(FcFontList);
196 MAKE_FUNCPTR(FcFontSetDestroy);
197 MAKE_FUNCPTR(FcInit);
198 MAKE_FUNCPTR(FcObjectSetAdd);
199 MAKE_FUNCPTR(FcObjectSetCreate);
200 MAKE_FUNCPTR(FcObjectSetDestroy);
201 MAKE_FUNCPTR(FcPatternCreate);
202 MAKE_FUNCPTR(FcPatternDestroy);
203 MAKE_FUNCPTR(FcPatternGetBool);
204 MAKE_FUNCPTR(FcPatternGetInteger);
205 MAKE_FUNCPTR(FcPatternGetString);
206 #endif
207
208 #undef MAKE_FUNCPTR
209
210 #ifndef FT_MAKE_TAG
211 #define FT_MAKE_TAG( ch0, ch1, ch2, ch3 ) \
212 ( ((DWORD)(BYTE)(ch0) << 24) | ((DWORD)(BYTE)(ch1) << 16) | \
213 ((DWORD)(BYTE)(ch2) << 8) | (DWORD)(BYTE)(ch3) )
214 #endif
215
216 #ifndef ft_encoding_none
217 #define FT_ENCODING_NONE ft_encoding_none
218 #endif
219 #ifndef ft_encoding_ms_symbol
220 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
221 #endif
222 #ifndef ft_encoding_unicode
223 #define FT_ENCODING_UNICODE ft_encoding_unicode
224 #endif
225 #ifndef ft_encoding_apple_roman
226 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
227 #endif
228
229 #ifdef WORDS_BIGENDIAN
230 #define GET_BE_WORD(x) (x)
231 #else
232 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
233 #endif
234
235 /* This is basically a copy of FT_Bitmap_Size with an extra element added */
236 typedef struct {
237 FT_Short height;
238 FT_Short width;
239 FT_Pos size;
240 FT_Pos x_ppem;
241 FT_Pos y_ppem;
242 FT_Short internal_leading;
243 } Bitmap_Size;
244
245 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
246 So to let this compile on older versions of FreeType we'll define the
247 new structure here. */
248 typedef struct {
249 FT_Short height, width;
250 FT_Pos size, x_ppem, y_ppem;
251 } My_FT_Bitmap_Size;
252
253 struct enum_data
254 {
255 ENUMLOGFONTEXW elf;
256 NEWTEXTMETRICEXW ntm;
257 DWORD type;
258 };
259
260 typedef struct tagFace {
261 struct list entry;
262 unsigned int refcount;
263 WCHAR *StyleName;
264 WCHAR *FullName;
265 WCHAR *file;
266 void *font_data_ptr;
267 DWORD font_data_size;
268 FT_Long face_index;
269 FONTSIGNATURE fs;
270 DWORD ntmFlags;
271 FT_Fixed font_version;
272 BOOL scalable;
273 Bitmap_Size size; /* set if face is a bitmap */
274 DWORD flags; /* ADDFONT flags */
275 struct tagFamily *family;
276 /* Cached data for Enum */
277 struct enum_data *cached_enum_data;
278 } Face;
279
280 #define ADDFONT_EXTERNAL_FONT 0x01
281 #define ADDFONT_ALLOW_BITMAP 0x02
282 #define ADDFONT_ADD_TO_CACHE 0x04
283 #define ADDFONT_ADD_RESOURCE 0x08 /* added through AddFontResource */
284 #define ADDFONT_VERTICAL_FONT 0x10
285 #define ADDFONT_AA_FLAGS(flags) ((flags) << 16)
286
287 typedef struct tagFamily {
288 struct list entry;
289 unsigned int refcount;
290 WCHAR *FamilyName;
291 WCHAR *EnglishName;
292 struct list faces;
293 struct list *replacement;
294 } Family;
295
296 typedef struct {
297 GLYPHMETRICS gm;
298 ABC abc; /* metrics of the unrotated char */
299 BOOL init;
300 } GM;
301
302 typedef struct {
303 FLOAT eM11, eM12;
304 FLOAT eM21, eM22;
305 } FMAT2;
306
307 typedef struct {
308 DWORD hash;
309 LOGFONTW lf;
310 FMAT2 matrix;
311 BOOL can_use_bitmap;
312 } FONT_DESC;
313
314 typedef struct tagGdiFont GdiFont;
315
316 typedef struct {
317 struct list entry;
318 Face *face;
319 GdiFont *font;
320 } CHILD_FONT;
321
322 struct tagGdiFont {
323 struct list entry;
324 struct list unused_entry;
325 unsigned int refcount;
326 GM **gm;
327 DWORD gmsize;
328 OUTLINETEXTMETRICW *potm;
329 DWORD total_kern_pairs;
330 KERNINGPAIR *kern_pairs;
331 struct list child_fonts;
332
333 /* the following members can be accessed without locking, they are never modified after creation */
334 FT_Face ft_face;
335 struct font_mapping *mapping;
336 LPWSTR name;
337 int charset;
338 int codepage;
339 BOOL fake_italic;
340 BOOL fake_bold;
341 BYTE underline;
342 BYTE strikeout;
343 INT orientation;
344 FONT_DESC font_desc;
345 LONG aveWidth, ppem;
346 double scale_y;
347 SHORT yMax;
348 SHORT yMin;
349 DWORD ntmFlags;
350 DWORD aa_flags;
351 UINT ntmCellHeight, ntmAvgWidth;
352 FONTSIGNATURE fs;
353 GdiFont *base_font;
354 VOID *GSUB_Table;
355 DWORD cache_num;
356 };
357
358 typedef struct {
359 struct list entry;
360 const WCHAR *font_name;
361 FONTSIGNATURE fs;
362 struct list links;
363 } SYSTEM_LINKS;
364
365 struct enum_charset_element {
366 DWORD mask;
367 DWORD charset;
368 WCHAR name[LF_FACESIZE];
369 };
370
371 struct enum_charset_list {
372 DWORD total;
373 struct enum_charset_element element[32];
374 };
375
376 #define GM_BLOCK_SIZE 128
377 #define FONT_GM(font,idx) (&(font)->gm[(idx) / GM_BLOCK_SIZE][(idx) % GM_BLOCK_SIZE])
378
379 static struct list gdi_font_list = LIST_INIT(gdi_font_list);
380 static struct list unused_gdi_font_list = LIST_INIT(unused_gdi_font_list);
381 static unsigned int unused_font_count;
382 #define UNUSED_CACHE_SIZE 10
383 static struct list system_links = LIST_INIT(system_links);
384
385 static struct list font_subst_list = LIST_INIT(font_subst_list);
386
387 static struct list font_list = LIST_INIT(font_list);
388
389 struct freetype_physdev
390 {
391 struct gdi_physdev dev;
392 GdiFont *font;
393 };
394
395 static inline struct freetype_physdev *get_freetype_dev( PHYSDEV dev )
396 {
397 return (struct freetype_physdev *)dev;
398 }
399
400 static const struct gdi_dc_funcs freetype_funcs;
401
402 static const WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
403 static const WCHAR defSans[] = {'A','r','i','a','l','\0'};
404 static const WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
405
406 static const WCHAR fontsW[] = {'\\','f','o','n','t','s','\0'};
407 static const WCHAR win9x_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
408 'W','i','n','d','o','w','s','\\',
409 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
410 'F','o','n','t','s','\0'};
411
412 static const WCHAR winnt_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
413 'W','i','n','d','o','w','s',' ','N','T','\\',
414 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
415 'F','o','n','t','s','\0'};
416
417 static const WCHAR system_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
418 static const WCHAR FixedSys_Value[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
419 static const WCHAR System_Value[] = {'F','O','N','T','S','.','F','O','N','\0'};
420 static const WCHAR OEMFont_Value[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
421
422 static const WCHAR * const SystemFontValues[] = {
423 System_Value,
424 OEMFont_Value,
425 FixedSys_Value,
426 NULL
427 };
428
429 static const WCHAR external_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
430 'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
431
432 /* Interesting and well-known (frequently-assumed!) font names */
433 static const WCHAR Lucida_Sans_Unicode[] = {'L','u','c','i','d','a',' ','S','a','n','s',' ','U','n','i','c','o','d','e',0};
434 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 };
435 static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
436 static const WCHAR MS_UI_Gothic[] = {'M','S',' ','U','I',' ','G','o','t','h','i','c',0};
437 static const WCHAR SimSun[] = {'S','i','m','S','u','n',0};
438 static const WCHAR Gulim[] = {'G','u','l','i','m',0};
439 static const WCHAR PMingLiU[] = {'P','M','i','n','g','L','i','U',0};
440 static const WCHAR Batang[] = {'B','a','t','a','n','g',0};
441
442 static const WCHAR arial[] = {'A','r','i','a','l',0};
443 static const WCHAR bitstream_vera_sans[] = {'B','i','t','s','t','r','e','a','m',' ','V','e','r','a',' ','S','a','n','s',0};
444 static const WCHAR bitstream_vera_sans_mono[] = {'B','i','t','s','t','r','e','a','m',' ','V','e','r','a',' ','S','a','n','s',' ','M','o','n','o',0};
445 static const WCHAR bitstream_vera_serif[] = {'B','i','t','s','t','r','e','a','m',' ','V','e','r','a',' ','S','e','r','i','f',0};
446 static const WCHAR courier_new[] = {'C','o','u','r','i','e','r',' ','N','e','w',0};
447 static const WCHAR liberation_mono[] = {'L','i','b','e','r','a','t','i','o','n',' ','M','o','n','o',0};
448 static const WCHAR liberation_sans[] = {'L','i','b','e','r','a','t','i','o','n',' ','S','a','n','s',0};
449 static const WCHAR liberation_serif[] = {'L','i','b','e','r','a','t','i','o','n',' ','S','e','r','i','f',0};
450 static const WCHAR times_new_roman[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n',0};
451 static const WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
452
453 static const WCHAR *default_serif_list[] =
454 {
455 times_new_roman,
456 liberation_serif,
457 bitstream_vera_serif,
458 NULL
459 };
460
461 static const WCHAR *default_fixed_list[] =
462 {
463 courier_new,
464 liberation_mono,
465 bitstream_vera_sans_mono,
466 NULL
467 };
468
469 static const WCHAR *default_sans_list[] =
470 {
471 arial,
472 liberation_sans,
473 bitstream_vera_sans,
474 NULL
475 };
476
477 typedef struct {
478 WCHAR *name;
479 INT charset;
480 } NameCs;
481
482 typedef struct tagFontSubst {
483 struct list entry;
484 NameCs from;
485 NameCs to;
486 } FontSubst;
487
488 /* Registry font cache key and value names */
489 static const WCHAR wine_fonts_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
490 'F','o','n','t','s',0};
491 static const WCHAR wine_fonts_cache_key[] = {'C','a','c','h','e',0};
492 static const WCHAR english_name_value[] = {'E','n','g','l','i','s','h',' ','N','a','m','e',0};
493 static const WCHAR face_index_value[] = {'I','n','d','e','x',0};
494 static const WCHAR face_ntmflags_value[] = {'N','t','m','f','l','a','g','s',0};
495 static const WCHAR face_version_value[] = {'V','e','r','s','i','o','n',0};
496 static const WCHAR face_height_value[] = {'H','e','i','g','h','t',0};
497 static const WCHAR face_width_value[] = {'W','i','d','t','h',0};
498 static const WCHAR face_size_value[] = {'S','i','z','e',0};
499 static const WCHAR face_x_ppem_value[] = {'X','p','p','e','m',0};
500 static const WCHAR face_y_ppem_value[] = {'Y','p','p','e','m',0};
501 static const WCHAR face_flags_value[] = {'F','l','a','g','s',0};
502 static const WCHAR face_internal_leading_value[] = {'I','n','t','e','r','n','a','l',' ','L','e','a','d','i','n','g',0};
503 static const WCHAR face_font_sig_value[] = {'F','o','n','t',' ','S','i','g','n','a','t','u','r','e',0};
504 static const WCHAR face_file_name_value[] = {'F','i','l','e',' ','N','a','m','e','\0'};
505 static const WCHAR face_full_name_value[] = {'F','u','l','l',' ','N','a','m','e','\0'};
506
507
508 struct font_mapping
509 {
510 struct list entry;
511 int refcount;
512 dev_t dev;
513 ino_t ino;
514 void *data;
515 size_t size;
516 };
517
518 static struct list mappings_list = LIST_INIT( mappings_list );
519
520 static UINT default_aa_flags;
521 static HKEY hkey_font_cache;
522
523 static CRITICAL_SECTION freetype_cs;
524 static CRITICAL_SECTION_DEBUG critsect_debug =
525 {
526 0, 0, &freetype_cs,
527 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
528 0, 0, { (DWORD_PTR)(__FILE__ ": freetype_cs") }
529 };
530 static CRITICAL_SECTION freetype_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
531
532 static const WCHAR font_mutex_nameW[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
533
534 static const WCHAR szDefaultFallbackLink[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0};
535 static BOOL use_default_fallback = FALSE;
536
537 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph);
538 static BOOL get_outline_text_metrics(GdiFont *font);
539 static BOOL get_text_metrics(GdiFont *font, LPTEXTMETRICW ptm);
540 static void remove_face_from_cache( Face *face );
541
542 static const WCHAR system_link[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
543 'W','i','n','d','o','w','s',' ','N','T','\\',
544 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
545 'S','y','s','t','e','m','L','i','n','k',0};
546
547 static const WCHAR internal_system_link[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
548 'F','o','n','t','L','i','n','k','\\',
549 'S','y','s','t','e','m','L','i','n','k',0};
550
551 /****************************************
552 * Notes on .fon files
553 *
554 * The fonts System, FixedSys and Terminal are special. There are typically multiple
555 * versions installed for different resolutions and codepages. Windows stores which one to use
556 * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
557 * Key Meaning
558 * FIXEDFON.FON FixedSys
559 * FONTS.FON System
560 * OEMFONT.FON Terminal
561 * LogPixels Current dpi set by the display control panel applet
562 * (HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontDPI
563 * also has a LogPixels value that appears to mirror this)
564 *
565 * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
566 * (vgaoem.fon would be your oemfont.fon if you have a US setup).
567 * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
568 * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
569 * so that makes sense.
570 *
571 * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
572 * to be mapped into the registry on Windows 2000 at least).
573 * I have
574 * woafont=app850.fon
575 * ega80woa.fon=ega80850.fon
576 * ega40woa.fon=ega40850.fon
577 * cga80woa.fon=cga80850.fon
578 * cga40woa.fon=cga40850.fon
579 */
580
581 /* These are all structures needed for the GSUB table */
582
583 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
584 #define TATEGAKI_LOWER_BOUND 0x02F1
585
586 typedef struct {
587 DWORD version;
588 WORD ScriptList;
589 WORD FeatureList;
590 WORD LookupList;
591 } GSUB_Header;
592
593 typedef struct {
594 CHAR ScriptTag[4];
595 WORD Script;
596 } GSUB_ScriptRecord;
597
598 typedef struct {
599 WORD ScriptCount;
600 GSUB_ScriptRecord ScriptRecord[1];
601 } GSUB_ScriptList;
602
603 typedef struct {
604 CHAR LangSysTag[4];
605 WORD LangSys;
606 } GSUB_LangSysRecord;
607
608 typedef struct {
609 WORD DefaultLangSys;
610 WORD LangSysCount;
611 GSUB_LangSysRecord LangSysRecord[1];
612 } GSUB_Script;
613
614 typedef struct {
615 WORD LookupOrder; /* Reserved */
616 WORD ReqFeatureIndex;
617 WORD FeatureCount;
618 WORD FeatureIndex[1];
619 } GSUB_LangSys;
620
621 typedef struct {
622 CHAR FeatureTag[4];
623 WORD Feature;
624 } GSUB_FeatureRecord;
625
626 typedef struct {
627 WORD FeatureCount;
628 GSUB_FeatureRecord FeatureRecord[1];
629 } GSUB_FeatureList;
630
631 typedef struct {
632 WORD FeatureParams; /* Reserved */
633 WORD LookupCount;
634 WORD LookupListIndex[1];
635 } GSUB_Feature;
636
637 typedef struct {
638 WORD LookupCount;
639 WORD Lookup[1];
640 } GSUB_LookupList;
641
642 typedef struct {
643 WORD LookupType;
644 WORD LookupFlag;
645 WORD SubTableCount;
646 WORD SubTable[1];
647 } GSUB_LookupTable;
648
649 typedef struct {
650 WORD CoverageFormat;
651 WORD GlyphCount;
652 WORD GlyphArray[1];
653 } GSUB_CoverageFormat1;
654
655 typedef struct {
656 WORD Start;
657 WORD End;
658 WORD StartCoverageIndex;
659 } GSUB_RangeRecord;
660
661 typedef struct {
662 WORD CoverageFormat;
663 WORD RangeCount;
664 GSUB_RangeRecord RangeRecord[1];
665 } GSUB_CoverageFormat2;
666
667 typedef struct {
668 WORD SubstFormat; /* = 1 */
669 WORD Coverage;
670 WORD DeltaGlyphID;
671 } GSUB_SingleSubstFormat1;
672
673 typedef struct {
674 WORD SubstFormat; /* = 2 */
675 WORD Coverage;
676 WORD GlyphCount;
677 WORD Substitute[1];
678 }GSUB_SingleSubstFormat2;
679
680 #ifdef HAVE_CARBON_CARBON_H
681 static char *find_cache_dir(void)
682 {
683 FSRef ref;
684 OSErr err;
685 static char cached_path[MAX_PATH];
686 static const char *wine = "/Wine", *fonts = "/Fonts";
687
688 if(*cached_path) return cached_path;
689
690 err = FSFindFolder(kUserDomain, kCachedDataFolderType, kCreateFolder, &ref);
691 if(err != noErr)
692 {
693 WARN("can't create cached data folder\n");
694 return NULL;
695 }
696 err = FSRefMakePath(&ref, (unsigned char*)cached_path, sizeof(cached_path));
697 if(err != noErr)
698 {
699 WARN("can't create cached data path\n");
700 *cached_path = '\0';
701 return NULL;
702 }
703 if(strlen(cached_path) + strlen(wine) + strlen(fonts) + 1 > sizeof(cached_path))
704 {
705 ERR("Could not create full path\n");
706 *cached_path = '\0';
707 return NULL;
708 }
709 strcat(cached_path, wine);
710
711 if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
712 {
713 WARN("Couldn't mkdir %s\n", cached_path);
714 *cached_path = '\0';
715 return NULL;
716 }
717 strcat(cached_path, fonts);
718 if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
719 {
720 WARN("Couldn't mkdir %s\n", cached_path);
721 *cached_path = '\0';
722 return NULL;
723 }
724 return cached_path;
725 }
726
727 /******************************************************************
728 * expand_mac_font
729 *
730 * Extracts individual TrueType font files from a Mac suitcase font
731 * and saves them into the user's caches directory (see
732 * find_cache_dir()).
733 * Returns a NULL terminated array of filenames.
734 *
735 * We do this because they are apps that try to read ttf files
736 * themselves and they don't like Mac suitcase files.
737 */
738 static char **expand_mac_font(const char *path)
739 {
740 FSRef ref;
741 SInt16 res_ref;
742 OSStatus s;
743 unsigned int idx;
744 const char *out_dir;
745 const char *filename;
746 int output_len;
747 struct {
748 char **array;
749 unsigned int size, max_size;
750 } ret;
751
752 TRACE("path %s\n", path);
753
754 s = FSPathMakeRef((unsigned char*)path, &ref, FALSE);
755 if(s != noErr)
756 {
757 WARN("failed to get ref\n");
758 return NULL;
759 }
760
761 s = FSOpenResourceFile(&ref, 0, NULL, fsRdPerm, &res_ref);
762 if(s != noErr)
763 {
764 TRACE("no data fork, so trying resource fork\n");
765 res_ref = FSOpenResFile(&ref, fsRdPerm);
766 if(res_ref == -1)
767 {
768 TRACE("unable to open resource fork\n");
769 return NULL;
770 }
771 }
772
773 ret.size = 0;
774 ret.max_size = 10;
775 ret.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.max_size * sizeof(*ret.array));
776 if(!ret.array)
777 {
778 CloseResFile(res_ref);
779 return NULL;
780 }
781
782 out_dir = find_cache_dir();
783
784 filename = strrchr(path, '/');
785 if(!filename) filename = path;
786 else filename++;
787
788 /* output filename has the form out_dir/filename_%04x.ttf */
789 output_len = strlen(out_dir) + 1 + strlen(filename) + 5 + 5;
790
791 UseResFile(res_ref);
792 idx = 1;
793 while(1)
794 {
795 FamRec *fam_rec;
796 unsigned short *num_faces_ptr, num_faces, face;
797 AsscEntry *assoc;
798 Handle fond;
799 ResType fond_res = FT_MAKE_TAG('F','O','N','D');
800
801 fond = Get1IndResource(fond_res, idx);
802 if(!fond) break;
803 TRACE("got fond resource %d\n", idx);
804 HLock(fond);
805
806 fam_rec = *(FamRec**)fond;
807 num_faces_ptr = (unsigned short *)(fam_rec + 1);
808 num_faces = GET_BE_WORD(*num_faces_ptr);
809 num_faces++;
810 assoc = (AsscEntry*)(num_faces_ptr + 1);
811 TRACE("num faces %04x\n", num_faces);
812 for(face = 0; face < num_faces; face++, assoc++)
813 {
814 Handle sfnt;
815 ResType sfnt_res = FT_MAKE_TAG('s','f','n','t');
816 unsigned short size, font_id;
817 char *output;
818
819 size = GET_BE_WORD(assoc->fontSize);
820 font_id = GET_BE_WORD(assoc->fontID);
821 if(size != 0)
822 {
823 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id, size);
824 continue;
825 }
826
827 TRACE("trying to load sfnt id %04x\n", font_id);
828 sfnt = GetResource(sfnt_res, font_id);
829 if(!sfnt)
830 {
831 TRACE("can't get sfnt resource %04x\n", font_id);
832 continue;
833 }
834
835 output = HeapAlloc(GetProcessHeap(), 0, output_len);
836 if(output)
837 {
838 int fd;
839
840 sprintf(output, "%s/%s_%04x.ttf", out_dir, filename, font_id);
841
842 fd = open(output, O_CREAT | O_EXCL | O_WRONLY, 0600);
843 if(fd != -1 || errno == EEXIST)
844 {
845 if(fd != -1)
846 {
847 unsigned char *sfnt_data;
848
849 HLock(sfnt);
850 sfnt_data = *(unsigned char**)sfnt;
851 write(fd, sfnt_data, GetHandleSize(sfnt));
852 HUnlock(sfnt);
853 close(fd);
854 }
855 if(ret.size >= ret.max_size - 1) /* Always want the last element to be NULL */
856 {
857 ret.max_size *= 2;
858 ret.array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.array, ret.max_size * sizeof(*ret.array));
859 }
860 ret.array[ret.size++] = output;
861 }
862 else
863 {
864 WARN("unable to create %s\n", output);
865 HeapFree(GetProcessHeap(), 0, output);
866 }
867 }
868 ReleaseResource(sfnt);
869 }
870 HUnlock(fond);
871 ReleaseResource(fond);
872 idx++;
873 }
874 CloseResFile(res_ref);
875
876 return ret.array;
877 }
878
879 #endif /* HAVE_CARBON_CARBON_H */
880
881 static inline BOOL is_win9x(void)
882 {
883 return GetVersion() & 0x80000000;
884 }
885 /*
886 This function builds an FT_Fixed from a double. It fails if the absolute
887 value of the float number is greater than 32768.
888 */
889 static inline FT_Fixed FT_FixedFromFloat(double f)
890 {
891 return f * 0x10000;
892 }
893
894 /*
895 This function builds an FT_Fixed from a FIXED. It simply put f.value
896 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
897 */
898 static inline FT_Fixed FT_FixedFromFIXED(FIXED f)
899 {
900 return (FT_Fixed)((int)f.value << 16 | (unsigned int)f.fract);
901 }
902
903 static BOOL is_hinting_enabled(void)
904 {
905 static int enabled = -1;
906
907 if (enabled == -1)
908 {
909 /* Use the >= 2.2.0 function if available */
910 if (pFT_Get_TrueType_Engine_Type)
911 {
912 FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
913 enabled = (type == FT_TRUETYPE_ENGINE_TYPE_PATENTED);
914 }
915 #ifdef FT_DRIVER_HAS_HINTER
916 else
917 {
918 /* otherwise if we've been compiled with < 2.2.0 headers use the internal macro */
919 FT_Module mod = pFT_Get_Module(library, "truetype");
920 enabled = (mod && FT_DRIVER_HAS_HINTER(mod));
921 }
922 #endif
923 else enabled = FALSE;
924 TRACE("hinting is %senabled\n", enabled ? "" : "NOT ");
925 }
926 return enabled;
927 }
928
929 static BOOL is_subpixel_rendering_enabled( void )
930 {
931 #ifdef HAVE_FREETYPE_FTLCDFIL_H
932 static int enabled = -1;
933 if (enabled == -1)
934 {
935 enabled = (pFT_Library_SetLcdFilter &&
936 pFT_Library_SetLcdFilter( NULL, 0 ) != FT_Err_Unimplemented_Feature);
937 TRACE("subpixel rendering is %senabled\n", enabled ? "" : "NOT ");
938 }
939 return enabled;
940 #else
941 return FALSE;
942 #endif
943 }
944
945
946 static const struct list *get_face_list_from_family(const Family *family)
947 {
948 if (!list_empty(&family->faces))
949 return &family->faces;
950 else
951 return family->replacement;
952 }
953
954 static Face *find_face_from_filename(const WCHAR *file_name, const WCHAR *face_name)
955 {
956 Family *family;
957 Face *face;
958 const WCHAR *file;
959
960 TRACE("looking for file %s name %s\n", debugstr_w(file_name), debugstr_w(face_name));
961
962 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
963 {
964 const struct list *face_list;
965 if(face_name && strcmpiW(face_name, family->FamilyName))
966 continue;
967 face_list = get_face_list_from_family(family);
968 LIST_FOR_EACH_ENTRY(face, face_list, Face, entry)
969 {
970 if (!face->file)
971 continue;
972 file = strrchrW(face->file, '/');
973 if(!file)
974 file = face->file;
975 else
976 file++;
977 if(strcmpiW(file, file_name)) continue;
978 face->refcount++;
979 return face;
980 }
981 }
982 return NULL;
983 }
984
985 static Family *find_family_from_name(const WCHAR *name)
986 {
987 Family *family;
988
989 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
990 {
991 if(!strcmpiW(family->FamilyName, name))
992 return family;
993 }
994
995 return NULL;
996 }
997
998 static Family *find_family_from_any_name(const WCHAR *name)
999 {
1000 Family *family;
1001
1002 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
1003 {
1004 if(!strcmpiW(family->FamilyName, name))
1005 return family;
1006 if(family->EnglishName && !strcmpiW(family->EnglishName, name))
1007 return family;
1008 }
1009
1010 return NULL;
1011 }
1012
1013 static void DumpSubstList(void)
1014 {
1015 FontSubst *psub;
1016
1017 LIST_FOR_EACH_ENTRY(psub, &font_subst_list, FontSubst, entry)
1018 {
1019 if(psub->from.charset != -1 || psub->to.charset != -1)
1020 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
1021 psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
1022 else
1023 TRACE("%s -> %s\n", debugstr_w(psub->from.name),
1024 debugstr_w(psub->to.name));
1025 }
1026 return;
1027 }
1028
1029 static LPWSTR strdupW(LPCWSTR p)
1030 {
1031 LPWSTR ret;
1032 DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
1033 ret = HeapAlloc(GetProcessHeap(), 0, len);
1034 memcpy(ret, p, len);
1035 return ret;
1036 }
1037
1038 static FontSubst *get_font_subst(const struct list *subst_list, const WCHAR *from_name,
1039 INT from_charset)
1040 {
1041 FontSubst *element;
1042
1043 LIST_FOR_EACH_ENTRY(element, subst_list, FontSubst, entry)
1044 {
1045 if(!strcmpiW(element->from.name, from_name) &&
1046 (element->from.charset == from_charset ||
1047 element->from.charset == -1))
1048 return element;
1049 }
1050
1051 return NULL;
1052 }
1053
1054 #define ADD_FONT_SUBST_FORCE 1
1055
1056 static BOOL add_font_subst(struct list *subst_list, FontSubst *subst, INT flags)
1057 {
1058 FontSubst *from_exist, *to_exist;
1059
1060 from_exist = get_font_subst(subst_list, subst->from.name, subst->from.charset);
1061
1062 if(from_exist && (flags & ADD_FONT_SUBST_FORCE))
1063 {
1064 list_remove(&from_exist->entry);
1065 HeapFree(GetProcessHeap(), 0, from_exist->from.name);
1066 HeapFree(GetProcessHeap(), 0, from_exist->to.name);
1067 HeapFree(GetProcessHeap(), 0, from_exist);
1068 from_exist = NULL;
1069 }
1070
1071 if(!from_exist)
1072 {
1073 to_exist = get_font_subst(subst_list, subst->to.name, subst->to.charset);
1074
1075 if(to_exist)
1076 {
1077 HeapFree(GetProcessHeap(), 0, subst->to.name);
1078 subst->to.name = strdupW(to_exist->to.name);
1079 }
1080
1081 list_add_tail(subst_list, &subst->entry);
1082
1083 return TRUE;
1084 }
1085
1086 HeapFree(GetProcessHeap(), 0, subst->from.name);
1087 HeapFree(GetProcessHeap(), 0, subst->to.name);
1088 HeapFree(GetProcessHeap(), 0, subst);
1089 return FALSE;
1090 }
1091
1092 static WCHAR *towstr(UINT cp, const char *str)
1093 {
1094 int len;
1095 WCHAR *wstr;
1096
1097 len = MultiByteToWideChar(cp, 0, str, -1, NULL, 0);
1098 wstr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1099 MultiByteToWideChar(cp, 0, str, -1, wstr, len);
1100 return wstr;
1101 }
1102
1103 static char *strWtoA(UINT cp, const WCHAR *str)
1104 {
1105 int len = WideCharToMultiByte( cp, 0, str, -1, NULL, 0, NULL, NULL );
1106 char *ret = HeapAlloc( GetProcessHeap(), 0, len );
1107 WideCharToMultiByte( cp, 0, str, -1, ret, len, NULL, NULL );
1108 return ret;
1109 }
1110
1111 static void split_subst_info(NameCs *nc, LPSTR str)
1112 {
1113 CHAR *p = strrchr(str, ',');
1114
1115 nc->charset = -1;
1116 if(p && *(p+1)) {
1117 nc->charset = strtol(p+1, NULL, 10);
1118 *p = '\0';
1119 }
1120 nc->name = towstr(CP_ACP, str);
1121 }
1122
1123 static void LoadSubstList(void)
1124 {
1125 FontSubst *psub;
1126 HKEY hkey;
1127 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1128 LPSTR value;
1129 LPVOID data;
1130
1131 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
1132 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
1133 &hkey) == ERROR_SUCCESS) {
1134
1135 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1136 &valuelen, &datalen, NULL, NULL);
1137
1138 valuelen++; /* returned value doesn't include room for '\0' */
1139 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
1140 data = HeapAlloc(GetProcessHeap(), 0, datalen);
1141
1142 dlen = datalen;
1143 vlen = valuelen;
1144 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
1145 &dlen) == ERROR_SUCCESS) {
1146 TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
1147
1148 psub = HeapAlloc(GetProcessHeap(), 0, sizeof(*psub));
1149 split_subst_info(&psub->from, value);
1150 split_subst_info(&psub->to, data);
1151
1152 /* Win 2000 doesn't allow mapping between different charsets
1153 or mapping of DEFAULT_CHARSET */
1154 if ((psub->from.charset && psub->to.charset != psub->from.charset) ||
1155 psub->to.charset == DEFAULT_CHARSET) {
1156 HeapFree(GetProcessHeap(), 0, psub->to.name);
1157 HeapFree(GetProcessHeap(), 0, psub->from.name);
1158 HeapFree(GetProcessHeap(), 0, psub);
1159 } else {
1160 add_font_subst(&font_subst_list, psub, 0);
1161 }
1162 /* reset dlen and vlen */
1163 dlen = datalen;
1164 vlen = valuelen;
1165 }
1166 HeapFree(GetProcessHeap(), 0, data);
1167 HeapFree(GetProcessHeap(), 0, value);
1168 RegCloseKey(hkey);
1169 }
1170 }
1171
1172
1173 /*****************************************************************
1174 * get_name_table_entry
1175 *
1176 * Supply the platform, encoding, language and name ids in req
1177 * and if the name exists the function will fill in the string
1178 * and string_len members. The string is owned by FreeType so
1179 * don't free it. Returns TRUE if the name is found else FALSE.
1180 */
1181 static BOOL get_name_table_entry(FT_Face ft_face, FT_SfntName *req)
1182 {
1183 FT_SfntName name;
1184 FT_UInt num_names, name_index;
1185
1186 if(FT_IS_SFNT(ft_face))
1187 {
1188 num_names = pFT_Get_Sfnt_Name_Count(ft_face);
1189
1190 for(name_index = 0; name_index < num_names; name_index++)
1191 {
1192 if(!pFT_Get_Sfnt_Name(ft_face, name_index, &name))
1193 {
1194 if((name.platform_id == req->platform_id) &&
1195 ((name.encoding_id == TT_MS_ID_UNICODE_CS) || (name.encoding_id == TT_MS_ID_SYMBOL_CS)) &&
1196 (name.language_id == req->language_id) &&
1197 (name.name_id == req->name_id))
1198 {
1199 req->string = name.string;
1200 req->string_len = name.string_len;
1201 return TRUE;
1202 }
1203 }
1204 }
1205 }
1206 req->string = NULL;
1207 req->string_len = 0;
1208 return FALSE;
1209 }
1210
1211 static WCHAR *get_face_name(FT_Face ft_face, FT_UShort name_id, FT_UShort language_id)
1212 {
1213 WCHAR *ret = NULL;
1214 FT_SfntName name;
1215
1216 name.platform_id = TT_PLATFORM_MICROSOFT;
1217 name.language_id = language_id;
1218 name.name_id = name_id;
1219
1220 if(get_name_table_entry(ft_face, &name))
1221 {
1222 FT_UInt i;
1223
1224 /* String is not nul terminated and string_len is a byte length. */
1225 ret = HeapAlloc(GetProcessHeap(), 0, name.string_len + 2);
1226 for(i = 0; i < name.string_len / 2; i++)
1227 {
1228 WORD *tmp = (WORD *)&name.string[i * 2];
1229 ret[i] = GET_BE_WORD(*tmp);
1230 }
1231 ret[i] = 0;
1232 TRACE("Got localised name %s\n", debugstr_w(ret));
1233 }
1234
1235 return ret;
1236 }
1237
1238 static inline BOOL faces_equal( const Face *f1, const Face *f2 )
1239 {
1240 if (strcmpiW( f1->StyleName, f2->StyleName )) return FALSE;
1241 if (f1->scalable) return TRUE;
1242 if (f1->size.y_ppem != f2->size.y_ppem) return FALSE;
1243 return !memcmp( &f1->fs, &f2->fs, sizeof(f1->fs) );
1244 }
1245
1246 static void release_family( Family *family )
1247 {
1248 if (--family->refcount) return;
1249 assert( list_empty( &family->faces ));
1250 list_remove( &family->entry );
1251 HeapFree( GetProcessHeap(), 0, family->FamilyName );
1252 HeapFree( GetProcessHeap(), 0, family->EnglishName );
1253 HeapFree( GetProcessHeap(), 0, family );
1254 }
1255
1256 static void release_face( Face *face )
1257 {
1258 if (--face->refcount) return;
1259 if (face->family)
1260 {
1261 if (face->flags & ADDFONT_ADD_TO_CACHE) remove_face_from_cache( face );
1262 list_remove( &face->entry );
1263 release_family( face->family );
1264 }
1265 HeapFree( GetProcessHeap(), 0, face->file );
1266 HeapFree( GetProcessHeap(), 0, face->StyleName );
1267 HeapFree( GetProcessHeap(), 0, face->FullName );
1268 HeapFree( GetProcessHeap(), 0, face->cached_enum_data );
1269 HeapFree( GetProcessHeap(), 0, face );
1270 }
1271
1272 static inline int style_order(const Face *face)
1273 {
1274 switch (face->ntmFlags & (NTM_REGULAR | NTM_BOLD | NTM_ITALIC))
1275 {
1276 case NTM_REGULAR:
1277 return 0;
1278 case NTM_BOLD:
1279 return 1;
1280 case NTM_ITALIC:
1281 return 2;
1282 case NTM_BOLD | NTM_ITALIC:
1283 return 3;
1284 default:
1285 WARN("Don't know how to order font %s %s with flags 0x%08x\n",
1286 debugstr_w(face->family->FamilyName),
1287 debugstr_w(face->StyleName),
1288 face->ntmFlags);
1289 return 9999;
1290 }
1291 }
1292
1293 static BOOL insert_face_in_family_list( Face *face, Family *family )
1294 {
1295 Face *cursor;
1296
1297 LIST_FOR_EACH_ENTRY( cursor, &family->faces, Face, entry )
1298 {
1299 if (faces_equal( face, cursor ))
1300 {
1301 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1302 debugstr_w(family->FamilyName), debugstr_w(face->StyleName),
1303 cursor->font_version, face->font_version);
1304
1305 if (face->font_version <= cursor->font_version)
1306 {
1307 TRACE("Original font %s is newer so skipping %s\n",
1308 debugstr_w(cursor->file), debugstr_w(face->file));
1309 return FALSE;
1310 }
1311 else
1312 {
1313 TRACE("Replacing original %s with %s\n",
1314 debugstr_w(cursor->file), debugstr_w(face->file));
1315 list_add_before( &cursor->entry, &face->entry );
1316 face->family = family;
1317 family->refcount++;
1318 face->refcount++;
1319 release_face( cursor );
1320 return TRUE;
1321 }
1322 }
1323 else
1324 TRACE("Adding new %s\n", debugstr_w(face->file));
1325
1326 if (style_order( face ) < style_order( cursor )) break;
1327 }
1328
1329 list_add_before( &cursor->entry, &face->entry );
1330 face->family = family;
1331 family->refcount++;
1332 face->refcount++;
1333 return TRUE;
1334 }
1335
1336 /****************************************************************
1337 * NB This function stores the ptrs to the strings to save copying.
1338 * Don't free them after calling.
1339 */
1340 static Family *create_family( WCHAR *name, WCHAR *english_name )
1341 {
1342 Family * const family = HeapAlloc( GetProcessHeap(), 0, sizeof(*family) );
1343 family->refcount = 1;
1344 family->FamilyName = name;
1345 family->EnglishName = english_name;
1346 list_init( &family->faces );
1347 family->replacement = &family->faces;
1348 list_add_tail( &font_list, &family->entry );
1349
1350 return family;
1351 }
1352
1353 static LONG reg_load_dword(HKEY hkey, const WCHAR *value, DWORD *data)
1354 {
1355 DWORD type, size = sizeof(DWORD);
1356
1357 if (RegQueryValueExW(hkey, value, NULL, &type, (BYTE *)data, &size) ||
1358 type != REG_DWORD || size != sizeof(DWORD))
1359 {
1360 *data = 0;
1361 return ERROR_BAD_CONFIGURATION;
1362 }
1363 return ERROR_SUCCESS;
1364 }
1365
1366 static inline LONG reg_save_dword(HKEY hkey, const WCHAR *value, DWORD data)
1367 {
1368 return RegSetValueExW(hkey, value, 0, REG_DWORD, (BYTE*)&data, sizeof(DWORD));
1369 }
1370
1371 static void load_face(HKEY hkey_face, WCHAR *face_name, Family *family, void *buffer, DWORD buffer_size)
1372 {
1373 DWORD needed, strike_index = 0;
1374 HKEY hkey_strike;
1375
1376 /* If we have a File Name key then this is a real font, not just the parent
1377 key of a bunch of non-scalable strikes */
1378 needed = buffer_size;
1379 if (RegQueryValueExW(hkey_face, face_file_name_value, NULL, NULL, buffer, &needed) == ERROR_SUCCESS)
1380 {
1381 Face *face;
1382 face = HeapAlloc(GetProcessHeap(), 0, sizeof(*face));
1383 face->cached_enum_data = NULL;
1384 face->family = NULL;
1385
1386 face->refcount = 1;
1387 face->file = strdupW( buffer );
1388 face->StyleName = strdupW(face_name);
1389
1390 needed = buffer_size;
1391 if(RegQueryValueExW(hkey_face, face_full_name_value, NULL, NULL, buffer, &needed) == ERROR_SUCCESS)
1392 face->FullName = strdupW( buffer );
1393 else
1394 face->FullName = NULL;
1395
1396 reg_load_dword(hkey_face, face_index_value, (DWORD*)&face->face_index);
1397 reg_load_dword(hkey_face, face_ntmflags_value, &face->ntmFlags);
1398 reg_load_dword(hkey_face, face_version_value, (DWORD*)&face->font_version);
1399 reg_load_dword(hkey_face, face_flags_value, (DWORD*)&face->flags);
1400
1401 needed = sizeof(face->fs);
1402 RegQueryValueExW(hkey_face, face_font_sig_value, NULL, NULL, (BYTE*)&face->fs, &needed);
1403
1404 if(reg_load_dword(hkey_face, face_height_value, (DWORD*)&face->size.height) != ERROR_SUCCESS)
1405 {
1406 face->scalable = TRUE;
1407 memset(&face->size, 0, sizeof(face->size));
1408 }
1409 else
1410 {
1411 face->scalable = FALSE;
1412 reg_load_dword(hkey_face, face_width_value, (DWORD*)&face->size.width);
1413 reg_load_dword(hkey_face, face_size_value, (DWORD*)&face->size.size);
1414 reg_load_dword(hkey_face, face_x_ppem_value, (DWORD*)&face->size.x_ppem);
1415 reg_load_dword(hkey_face, face_y_ppem_value, (DWORD*)&face->size.y_ppem);
1416 reg_load_dword(hkey_face, face_internal_leading_value, (DWORD*)&face->size.internal_leading);
1417
1418 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1419 face->size.height, face->size.width, face->size.size >> 6,
1420 face->size.x_ppem >> 6, face->size.y_ppem >> 6);
1421 }
1422
1423 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1424 face->fs.fsCsb[0], face->fs.fsCsb[1],
1425 face->fs.fsUsb[0], face->fs.fsUsb[1],
1426 face->fs.fsUsb[2], face->fs.fsUsb[3]);
1427
1428 if (insert_face_in_family_list(face, family))
1429 TRACE("Added font %s %s\n", debugstr_w(family->FamilyName), debugstr_w(face->StyleName));
1430
1431 release_face( face );
1432 }
1433
1434 /* load bitmap strikes */
1435
1436 needed = buffer_size;
1437 while (!RegEnumKeyExW(hkey_face, strike_index++, buffer, &needed, NULL, NULL, NULL, NULL))
1438 {
1439 if (!RegOpenKeyExW(hkey_face, buffer, 0, KEY_ALL_ACCESS, &hkey_strike))
1440 {
1441 load_face(hkey_strike, face_name, family, buffer, buffer_size);
1442 RegCloseKey(hkey_strike);
1443 }
1444 needed = buffer_size;
1445 }
1446 }
1447
1448 static void load_font_list_from_cache(HKEY hkey_font_cache)
1449 {
1450 DWORD size, family_index = 0;
1451 Family *family;
1452 HKEY hkey_family;
1453 WCHAR buffer[4096];
1454
1455 size = sizeof(buffer);
1456 while (!RegEnumKeyExW(hkey_font_cache, family_index++, buffer, &size, NULL, NULL, NULL, NULL))
1457 {
1458 WCHAR *english_family = NULL;
1459 WCHAR *family_name = strdupW( buffer );
1460 DWORD face_index = 0;
1461
1462 RegOpenKeyExW(hkey_font_cache, family_name, 0, KEY_ALL_ACCESS, &hkey_family);
1463 TRACE("opened family key %s\n", debugstr_w(family_name));
1464 size = sizeof(buffer);
1465 if (!RegQueryValueExW(hkey_family, english_name_value, NULL, NULL, (BYTE *)buffer, &size))
1466 english_family = strdupW( buffer );
1467
1468 family = create_family(family_name, english_family);
1469
1470 if(english_family)
1471 {
1472 FontSubst *subst = HeapAlloc(GetProcessHeap(), 0, sizeof(*subst));
1473 subst->from.name = strdupW(english_family);
1474 subst->from.charset = -1;
1475 subst->to.name = strdupW(family_name);
1476 subst->to.charset = -1;
1477 add_font_subst(&font_subst_list, subst, 0);
1478 }
1479
1480 size = sizeof(buffer);
1481 while (!RegEnumKeyExW(hkey_family, face_index++, buffer, &size, NULL, NULL, NULL, NULL))
1482 {
1483 WCHAR *face_name = strdupW( buffer );
1484 HKEY hkey_face;
1485
1486 if (!RegOpenKeyExW(hkey_family, face_name, 0, KEY_ALL_ACCESS, &hkey_face))
1487 {
1488 load_face(hkey_face, face_name, family, buffer, sizeof(buffer));
1489 RegCloseKey(hkey_face);
1490 }
1491 HeapFree( GetProcessHeap(), 0, face_name );
1492 size = sizeof(buffer);
1493 }
1494 RegCloseKey(hkey_family);
1495 release_family( family );
1496 size = sizeof(buffer);
1497 }
1498 }
1499
1500 static LONG create_font_cache_key(HKEY *hkey, DWORD *disposition)
1501 {
1502 LONG ret;
1503 HKEY hkey_wine_fonts;
1504
1505 /* We don't want to create the fonts key as volatile, so open this first */
1506 ret = RegCreateKeyExW(HKEY_CURRENT_USER, wine_fonts_key, 0, NULL, 0,
1507 KEY_ALL_ACCESS, NULL, &hkey_wine_fonts, NULL);
1508 if(ret != ERROR_SUCCESS)
1509 {
1510 WARN("Can't create %s\n", debugstr_w(wine_fonts_key));
1511 return ret;
1512 }
1513
1514 ret = RegCreateKeyExW(hkey_wine_fonts, wine_fonts_cache_key, 0, NULL, REG_OPTION_VOLATILE,
1515 KEY_ALL_ACCESS, NULL, hkey, disposition);
1516 RegCloseKey(hkey_wine_fonts);
1517 return ret;
1518 }
1519
1520 static void add_face_to_cache(Face *face)
1521 {
1522 HKEY hkey_family, hkey_face;
1523 WCHAR *face_key_name;
1524
1525 RegCreateKeyExW(hkey_font_cache, face->family->FamilyName, 0,
1526 NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey_family, NULL);
1527 if(face->family->EnglishName)
1528 RegSetValueExW(hkey_family, english_name_value, 0, REG_SZ, (BYTE*)face->family->EnglishName,
1529 (strlenW(face->family->EnglishName) + 1) * sizeof(WCHAR));
1530
1531 if(face->scalable)
1532 face_key_name = face->StyleName;
1533 else
1534 {
1535 static const WCHAR fmtW[] = {'%','s','\\','%','d',0};
1536 face_key_name = HeapAlloc(GetProcessHeap(), 0, (strlenW(face->StyleName) + 10) * sizeof(WCHAR));
1537 sprintfW(face_key_name, fmtW, face->StyleName, face->size.y_ppem);
1538 }
1539 RegCreateKeyExW(hkey_family, face_key_name, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL,
1540 &hkey_face, NULL);
1541 if(!face->scalable)
1542 HeapFree(GetProcessHeap(), 0, face_key_name);
1543
1544 RegSetValueExW(hkey_face, face_file_name_value, 0, REG_SZ, (BYTE *)face->file,
1545 (strlenW(face->file) + 1) * sizeof(WCHAR));
1546 if (face->FullName)
1547 RegSetValueExW(hkey_face, face_full_name_value, 0, REG_SZ, (BYTE*)face->FullName,
1548 (strlenW(face->FullName) + 1) * sizeof(WCHAR));
1549
1550 reg_save_dword(hkey_face, face_index_value, face->face_index);
1551 reg_save_dword(hkey_face, face_ntmflags_value, face->ntmFlags);
1552 reg_save_dword(hkey_face, face_version_value, face->font_version);
1553 if (face->flags) reg_save_dword(hkey_face, face_flags_value, face->flags);
1554
1555 RegSetValueExW(hkey_face, face_font_sig_value, 0, REG_BINARY, (BYTE*)&face->fs, sizeof(face->fs));
1556
1557 if(!face->scalable)
1558 {
1559 reg_save_dword(hkey_face, face_height_value, face->size.height);
1560 reg_save_dword(hkey_face, face_width_value, face->size.width);
1561 reg_save_dword(hkey_face, face_size_value, face->size.size);
1562 reg_save_dword(hkey_face, face_x_ppem_value, face->size.x_ppem);
1563 reg_save_dword(hkey_face, face_y_ppem_value, face->size.y_ppem);
1564 reg_save_dword(hkey_face, face_internal_leading_value, face->size.internal_leading);
1565 }
1566 RegCloseKey(hkey_face);
1567 RegCloseKey(hkey_family);
1568 }
1569
1570 static void remove_face_from_cache( Face *face )
1571 {
1572 HKEY hkey_family;
1573
1574 RegOpenKeyExW( hkey_font_cache, face->family->FamilyName, 0, KEY_ALL_ACCESS, &hkey_family );
1575
1576 if (face->scalable)
1577 {
1578 RegDeleteKeyW( hkey_family, face->StyleName );
1579 }
1580 else
1581 {
1582 static const WCHAR fmtW[] = {'%','s','\\','%','d',0};
1583 WCHAR *face_key_name = HeapAlloc(GetProcessHeap(), 0, (strlenW(face->StyleName) + 10) * sizeof(WCHAR));
1584 sprintfW(face_key_name, fmtW, face->StyleName, face->size.y_ppem);
1585 RegDeleteKeyW( hkey_family, face_key_name );
1586 HeapFree(GetProcessHeap(), 0, face_key_name);
1587 }
1588 RegCloseKey(hkey_family);
1589 }
1590
1591 static WCHAR *prepend_at(WCHAR *family)
1592 {
1593 WCHAR *str;
1594
1595 if (!family)
1596 return NULL;
1597
1598 str = HeapAlloc(GetProcessHeap(), 0, sizeof (WCHAR) * (strlenW(family) + 2));
1599 str[0] = '@';
1600 strcpyW(str + 1, family);
1601 HeapFree(GetProcessHeap(), 0, family);
1602 return str;
1603 }
1604
1605 static void get_family_names( FT_Face ft_face, WCHAR **name, WCHAR **english, BOOL vertical )
1606 {
1607 *english = get_face_name( ft_face, TT_NAME_ID_FONT_FAMILY, TT_MS_LANGID_ENGLISH_UNITED_STATES );
1608 if (!*english) *english = towstr( CP_ACP, ft_face->family_name );
1609
1610 *name = get_face_name( ft_face, TT_NAME_ID_FONT_FAMILY, GetSystemDefaultLCID() );
1611 if (!*name)
1612 {
1613 *name = *english;
1614 *english = NULL;
1615 }
1616 else if (!strcmpiW( *name, *english ))
1617 {
1618 HeapFree( GetProcessHeap(), 0, *english );
1619 *english = NULL;
1620 }
1621
1622 if (vertical)
1623 {
1624 *name = prepend_at( *name );
1625 *english = prepend_at( *english );
1626 }
1627 }
1628
1629 static Family *get_family( FT_Face ft_face, BOOL vertical )
1630 {
1631 Family *family;
1632 WCHAR *name, *english_name;
1633
1634 get_family_names( ft_face, &name, &english_name, vertical );
1635
1636 family = find_family_from_name( name );
1637
1638 if (!family)
1639 {
1640 family = create_family( name, english_name );
1641 if (english_name)
1642 {
1643 FontSubst *subst = HeapAlloc( GetProcessHeap(), 0, sizeof(*subst) );
1644 subst->from.name = strdupW( english_name );
1645 subst->from.charset = -1;
1646 subst->to.name = strdupW( name );
1647 subst->to.charset = -1;
1648 add_font_subst( &font_subst_list, subst, 0 );
1649 }
1650 }
1651 else
1652 {
1653 HeapFree( GetProcessHeap(), 0, name );
1654 HeapFree( GetProcessHeap(), 0, english_name );
1655 family->refcount++;
1656 }
1657
1658 return family;
1659 }
1660
1661 static inline FT_Fixed get_font_version( FT_Face ft_face )
1662 {
1663 FT_Fixed version = 0;
1664 TT_Header *header;
1665
1666 header = pFT_Get_Sfnt_Table( ft_face, ft_sfnt_head );
1667 if (header) version = header->Font_Revision;
1668
1669 return version;
1670 }
1671
1672 static inline DWORD get_ntm_flags( FT_Face ft_face )
1673 {
1674 DWORD flags = 0;
1675 FT_ULong table_size = 0;
1676
1677 if (ft_face->style_flags & FT_STYLE_FLAG_ITALIC) flags |= NTM_ITALIC;
1678 if (ft_face->style_flags & FT_STYLE_FLAG_BOLD) flags |= NTM_BOLD;
1679 if (flags == 0) flags = NTM_REGULAR;
1680
1681 if (!pFT_Load_Sfnt_Table( ft_face, FT_MAKE_TAG( 'C','F','F',' ' ), 0, NULL, &table_size ))
1682 flags |= NTM_PS_OPENTYPE;
1683
1684 return flags;
1685 }
1686
1687 static inline int get_bitmap_internal_leading( FT_Face ft_face )
1688 {
1689 int internal_leading = 0;
1690 FT_WinFNT_HeaderRec winfnt_header;
1691
1692 if (!pFT_Get_WinFNT_Header( ft_face, &winfnt_header ))
1693 internal_leading = winfnt_header.internal_leading;
1694
1695 return internal_leading;
1696 }
1697
1698 static inline void get_fontsig( FT_Face ft_face, FONTSIGNATURE *fs )
1699 {
1700 TT_OS2 *os2;
1701 FT_UInt dummy;
1702 CHARSETINFO csi;
1703 FT_WinFNT_HeaderRec winfnt_header;
1704 int i;
1705
1706 memset( fs, 0, sizeof(*fs) );
1707
1708 os2 = pFT_Get_Sfnt_Table( ft_face, ft_sfnt_os2 );
1709 if (os2)
1710 {
1711 fs->fsUsb[0] = os2->ulUnicodeRange1;
1712 fs->fsUsb[1] = os2->ulUnicodeRange2;
1713 fs->fsUsb[2] = os2->ulUnicodeRange3;
1714 fs->fsUsb[3] = os2->ulUnicodeRange4;
1715
1716 if (os2->version == 0)
1717 {
1718 if (pFT_Get_First_Char( ft_face, &dummy ) < 0x100)
1719 fs->fsCsb[0] = FS_LATIN1;
1720 else
1721 fs->fsCsb[0] = FS_SYMBOL;
1722 }
1723 else
1724 {
1725 fs->fsCsb[0] = os2->ulCodePageRange1;
1726 fs->fsCsb[1] = os2->ulCodePageRange2;
1727 }
1728 }
1729 else
1730 {
1731 if (!pFT_Get_WinFNT_Header( ft_face, &winfnt_header ))
1732 {
1733 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header.pixel_height, winfnt_header.charset,
1734 winfnt_header.vertical_resolution,winfnt_header.horizontal_resolution, winfnt_header.nominal_point_size);
1735 if (TranslateCharsetInfo( (DWORD*)(UINT_PTR)winfnt_header.charset, &csi, TCI_SRCCHARSET ))
1736 *fs = csi.fs;
1737 }
1738 }
1739
1740 if (fs->fsCsb[0] == 0)
1741 {
1742 /* let's see if we can find any interesting cmaps */
1743 for (i = 0; i < ft_face->num_charmaps; i++)
1744 {
1745 switch (ft_face->charmaps[i]->encoding)
1746 {
1747 case FT_ENCODING_UNICODE:
1748 case FT_ENCODING_APPLE_ROMAN:
1749 fs->fsCsb[0] |= FS_LATIN1;
1750 break;
1751 case FT_ENCODING_MS_SYMBOL:
1752 fs->fsCsb[0] |= FS_SYMBOL;
1753 break;
1754 default:
1755 break;
1756 }
1757 }
1758 }
1759 }
1760
1761 static Face *create_face( FT_Face ft_face, FT_Long face_index, const char *file, void *font_data_ptr, DWORD font_data_size,
1762 DWORD flags )
1763 {
1764 Face *face = HeapAlloc( GetProcessHeap(), 0, sizeof(*face) );
1765 My_FT_Bitmap_Size *size = (My_FT_Bitmap_Size *)ft_face->available_sizes;
1766
1767 face->refcount = 1;
1768 face->StyleName = get_face_name( ft_face, TT_NAME_ID_FONT_SUBFAMILY, GetSystemDefaultLangID() );
1769 if (!face->StyleName)
1770 face->StyleName = get_face_name( ft_face, TT_NAME_ID_FONT_SUBFAMILY, TT_MS_LANGID_ENGLISH_UNITED_STATES );
1771 if (!face->StyleName)
1772 {
1773 face->StyleName = towstr( CP_ACP, ft_face->style_name );
1774 }
1775
1776 face->FullName = get_face_name( ft_face, TT_NAME_ID_FULL_NAME, GetSystemDefaultLangID() );
1777 if (!face->FullName)
1778 face->FullName = get_face_name( ft_face, TT_NAME_ID_FULL_NAME, TT_MS_LANGID_ENGLISH_UNITED_STATES );
1779 if (flags & ADDFONT_VERTICAL_FONT)
1780 face->FullName = prepend_at( face->FullName );
1781
1782 if (file)
1783 {
1784 face->file = towstr( CP_UNIXCP, file );
1785 face->font_data_ptr = NULL;
1786 face->font_data_size = 0;
1787 }
1788 else
1789 {
1790 face->file = NULL;
1791 face->font_data_ptr = font_data_ptr;
1792 face->font_data_size = font_data_size;
1793 }
1794
1795 face->face_index = face_index;
1796 get_fontsig( ft_face, &face->fs );
1797 face->ntmFlags = get_ntm_flags( ft_face );
1798 face->font_version = get_font_version( ft_face );
1799
1800 if (FT_IS_SCALABLE( ft_face ))
1801 {
1802 memset( &face->size, 0, sizeof(face->size) );
1803 face->scalable = TRUE;
1804 }
1805 else
1806 {
1807 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1808 size->height, size->width, size->size >> 6,
1809 size->x_ppem >> 6, size->y_ppem >> 6);
1810 face->size.height = size->height;
1811 face->size.width = size->width;
1812 face->size.size = size->size;
1813 face->size.x_ppem = size->x_ppem;
1814 face->size.y_ppem = size->y_ppem;
1815 face->size.internal_leading = get_bitmap_internal_leading( ft_face );
1816 face->scalable = FALSE;
1817 }
1818
1819 if (!HIWORD( flags )) flags |= ADDFONT_AA_FLAGS( default_aa_flags );
1820 face->flags = flags;
1821 face->family = NULL;
1822 face->cached_enum_data = NULL;
1823
1824 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1825 face->fs.fsCsb[0], face->fs.fsCsb[1],
1826 face->fs.fsUsb[0], face->fs.fsUsb[1],
1827 face->fs.fsUsb[2], face->fs.fsUsb[3]);
1828
1829 return face;
1830 }
1831
1832 static void AddFaceToList(FT_Face ft_face, const char *file, void *font_data_ptr, DWORD font_data_size,
1833 FT_Long face_index, DWORD flags )
1834 {
1835 Face *face;
1836 Family *family;
1837
1838 face = create_face( ft_face, face_index, file, font_data_ptr, font_data_size, flags );
1839 family = get_family( ft_face, flags & ADDFONT_VERTICAL_FONT );
1840 if (insert_face_in_family_list( face, family ))
1841 {
1842 if (flags & ADDFONT_ADD_TO_CACHE)
1843 add_face_to_cache( face );
1844
1845 TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
1846 debugstr_w(face->StyleName));
1847 }
1848 release_face( face );
1849 release_family( family );
1850 }
1851
1852 static FT_Face new_ft_face( const char *file, void *font_data_ptr, DWORD font_data_size,
1853 FT_Long face_index, BOOL allow_bitmap )
1854 {
1855 FT_Error err;
1856 TT_OS2 *pOS2;
1857 FT_Face ft_face;
1858
1859 if (file)
1860 {
1861 TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
1862 err = pFT_New_Face(library, file, face_index, &ft_face);
1863 }
1864 else
1865 {
1866 TRACE("Loading font from ptr %p size %d, index %ld\n", font_data_ptr, font_data_size, face_index);
1867 err = pFT_New_Memory_Face(library, font_data_ptr, font_data_size, face_index, &ft_face);
1868 }
1869
1870 if (err != 0)
1871 {
1872 WARN("Unable to load font %s/%p err = %x\n", debugstr_a(file), font_data_ptr, err);
1873 return NULL;
1874 }
1875
1876 /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1877 if (!FT_IS_SCALABLE( ft_face ) && FT_SimpleVersion < ((2 << 16) | (1 << 8) | (9 << 0)))
1878 {
1879 WARN("FreeType version < 2.1.9, skipping bitmap font %s/%p\n", debugstr_a(file), font_data_ptr);
1880 goto fail;
1881 }
1882
1883 if (!FT_IS_SFNT( ft_face ))
1884 {
1885 if (FT_IS_SCALABLE( ft_face ) || !allow_bitmap )
1886 {
1887 WARN("Ignoring font %s/%p\n", debugstr_a(file), font_data_ptr);
1888 goto fail;
1889 }
1890 }
1891 else
1892 {
1893 if (!(pOS2 = pFT_Get_Sfnt_Table( ft_face, ft_sfnt_os2 )) ||
1894 !pFT_Get_Sfnt_Table( ft_face, ft_sfnt_hhea ) ||
1895 !pFT_Get_Sfnt_Table( ft_face, ft_sfnt_head ))
1896 {
1897 TRACE("Font %s/%p lacks either an OS2, HHEA or HEAD table.\n"
1898 "Skipping this font.\n", debugstr_a(file), font_data_ptr);
1899 goto fail;
1900 }
1901
1902 /* Wine uses ttfs as an intermediate step in building its bitmap fonts;
1903 we don't want to load these. */
1904 if (!memcmp( pOS2->achVendID, "Wine", sizeof(pOS2->achVendID) ))
1905 {
1906 FT_ULong len = 0;
1907
1908 if (!pFT_Load_Sfnt_Table( ft_face, FT_MAKE_TAG('E','B','S','C'), 0, NULL, &len ))
1909 {
1910 TRACE("Skipping Wine bitmap-only TrueType font %s\n", debugstr_a(file));
1911 goto fail;
1912 }
1913 }
1914 }
1915
1916 if (!ft_face->family_name || !ft_face->style_name)
1917 {
1918 TRACE("Font %s/%p lacks either a family or style name\n", debugstr_a(file), font_data_ptr);
1919 goto fail;
1920 }
1921
1922 return ft_face;
1923 fail:
1924 pFT_Done_Face( ft_face );
1925 return NULL;
1926 }
1927
1928 static INT AddFontToList(const char *file, void *font_data_ptr, DWORD font_data_size, DWORD flags)
1929 {
1930 FT_Face ft_face;
1931 FT_Long face_index = 0, num_faces;
1932 INT ret = 0;
1933
1934 /* we always load external fonts from files - otherwise we would get a crash in update_reg_entries */
1935 assert(file || !(flags & ADDFONT_EXTERNAL_FONT));
1936
1937 #ifdef HAVE_CARBON_CARBON_H
1938 if(file)
1939 {
1940 char **mac_list = expand_mac_font(file);
1941 if(mac_list)
1942 {
1943 BOOL had_one = FALSE;
1944 char **cursor;
1945 for(cursor = mac_list; *cursor; cursor++)
1946 {
1947 had_one = TRUE;
1948 AddFontToList(*cursor, NULL, 0, flags);
1949 HeapFree(GetProcessHeap(), 0, *cursor);
1950 }
1951 HeapFree(GetProcessHeap(), 0, mac_list);
1952 if(had_one)
1953 return 1;
1954 }
1955 }
1956 #endif /* HAVE_CARBON_CARBON_H */
1957
1958 do {
1959 ft_face = new_ft_face( file, font_data_ptr, font_data_size, face_index, flags & ADDFONT_ALLOW_BITMAP );
1960 if (!ft_face) return 0;
1961
1962 if(ft_face->family_name[0] == '.') /* Ignore fonts with names beginning with a dot */
1963 {
1964 TRACE("Ignoring %s since its family name begins with a dot\n", debugstr_a(file));
1965 pFT_Done_Face(ft_face);
1966 return 0;
1967 }
1968
1969 AddFaceToList(ft_face, file, font_data_ptr, font_data_size, face_index, flags);
1970 ++ret;
1971
1972 if (FT_HAS_VERTICAL(ft_face))
1973 {
1974 AddFaceToList(ft_face, file, font_data_ptr, font_data_size, face_index,
1975 flags | ADDFONT_VERTICAL_FONT);
1976 ++ret;
1977 }
1978
1979 num_faces = ft_face->num_faces;
1980 pFT_Done_Face(ft_face);
1981 } while(num_faces > ++face_index);
1982 return ret;
1983 }
1984
1985 static int remove_font_resource( const char *file, DWORD flags )
1986 {
1987 Family *family, *family_next;
1988 Face *face, *face_next;
1989 char *filename;
1990 struct stat st, st2;
1991 int count = 0;
1992
1993 if (stat( file, &st ) == -1) return 0;
1994 LIST_FOR_EACH_ENTRY_SAFE( family, family_next, &font_list, Family, entry )
1995 {
1996 family->refcount++;
1997 LIST_FOR_EACH_ENTRY_SAFE( face, face_next, &family->faces, Face, entry )
1998 {
1999 if (!face->file) continue;
2000 if (LOWORD(face->flags) != LOWORD(flags)) continue;
2001 filename = strWtoA( CP_UNIXCP, face->file );
2002 if (!stat( filename, &st2 ) && st.st_dev == st2.st_dev && st.st_ino == st2.st_ino)
2003 {
2004 TRACE( "removing matching face %s\n", debugstr_w(face->file) );
2005 release_face( face );
2006 count++;
2007 }
2008 HeapFree( GetProcessHeap(), 0, filename );
2009 }
2010 release_family( family );
2011 }
2012 return count;
2013 }
2014
2015 static void DumpFontList(void)
2016 {
2017 Family *family;
2018 Face *face;
2019
2020 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
2021 TRACE("Family: %s\n", debugstr_w(family->FamilyName));
2022 LIST_FOR_EACH_ENTRY( face, &family->faces, Face, entry ) {
2023 TRACE("\t%s\t%08x", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
2024 if(!face->scalable)
2025 TRACE(" %d", face->size.height);
2026 TRACE("\n");
2027 }
2028 }
2029 return;
2030 }
2031
2032 /***********************************************************
2033 * The replacement list is a way to map an entire font
2034 * family onto another family. For example adding
2035 *
2036 * [HKCU\Software\Wine\Fonts\Replacements]
2037 * "Wingdings"="Winedings"
2038 *
2039 * would enumerate the Winedings font both as Winedings and
2040 * Wingdings. However if a real Wingdings font is present the
2041 * replacement does not take place.
2042 *
2043 */
2044 static void LoadReplaceList(void)
2045 {
2046 HKEY hkey;
2047 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
2048 LPWSTR value;
2049 LPVOID data;
2050
2051 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
2052 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
2053 {
2054 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2055 &valuelen, &datalen, NULL, NULL);
2056
2057 valuelen++; /* returned value doesn't include room for '\0' */
2058 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2059 data = HeapAlloc(GetProcessHeap(), 0, datalen);
2060
2061 dlen = datalen;
2062 vlen = valuelen;
2063 while(RegEnumValueW(hkey, i++, value, &vlen, NULL, &type, data,
2064 &dlen) == ERROR_SUCCESS) {
2065 TRACE("Got %s=%s\n", debugstr_w(value), debugstr_w(data));
2066 /* "NewName"="Oldname" */
2067 if(!find_family_from_any_name(value))
2068 {
2069 Family * const family = find_family_from_any_name(data);
2070 if (family != NULL)
2071 {
2072 Family * const new_family = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_family));
2073 if (new_family != NULL)
2074 {
2075 TRACE("mapping %s to %s\n", debugstr_w(data), debugstr_w(value));
2076 new_family->FamilyName = strdupW(value);
2077 new_family->EnglishName = NULL;
2078 list_init(&new_family->faces);
2079 new_family->replacement = &family->faces;
2080 list_add_tail(&font_list, &new_family->entry);
2081 }
2082 }
2083 else
2084 {
2085 TRACE("%s is not available. Skip this replacement.\n", debugstr_w(data));
2086 }
2087 }
2088 else
2089 {
2090 TRACE("%s is available. Skip this replacement.\n", debugstr_w(value));
2091 }
2092 /* reset dlen and vlen */
2093 dlen = datalen;
2094 vlen = valuelen;
2095 }
2096 HeapFree(GetProcessHeap(), 0, data);
2097 HeapFree(GetProcessHeap(), 0, value);
2098 RegCloseKey(hkey);
2099 }
2100 }
2101
2102 static const WCHAR *font_links_list[] =
2103 {
2104 Lucida_Sans_Unicode,
2105 Microsoft_Sans_Serif,
2106 Tahoma
2107 };
2108
2109 static const struct font_links_defaults_list
2110 {
2111 /* Keyed off substitution for "MS Shell Dlg" */
2112 const WCHAR *shelldlg;
2113 /* Maximum of four substitutes, plus terminating NULL pointer */
2114 const WCHAR *substitutes[5];
2115 } font_links_defaults_list[] =
2116 {
2117 /* Non East-Asian */
2118 { Tahoma, /* FIXME unverified ordering */
2119 { MS_UI_Gothic, SimSun, Gulim, PMingLiU, NULL }
2120 },
2121 /* Below lists are courtesy of
2122 * http://blogs.msdn.com/michkap/archive/2005/06/18/430507.aspx
2123 */
2124 /* Japanese */
2125 { MS_UI_Gothic,
2126 { MS_UI_Gothic, PMingLiU, SimSun, Gulim, NULL }
2127 },
2128 /* Chinese Simplified */
2129 { SimSun,
2130 { SimSun, PMingLiU, MS_UI_Gothic, Batang, NULL }
2131 },
2132 /* Korean */
2133 { Gulim,
2134 { Gulim, PMingLiU, MS_UI_Gothic, SimSun, NULL }
2135 },
2136 /* Chinese Traditional */
2137 { PMingLiU,
2138 { PMingLiU, SimSun, MS_UI_Gothic, Batang, NULL }
2139 }
2140 };
2141
2142
2143 static SYSTEM_LINKS *find_font_link(const WCHAR *name)
2144 {
2145 SYSTEM_LINKS *font_link;
2146
2147 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2148 {
2149 if(!strcmpiW(font_link->font_name, name))
2150 return font_link;
2151 }
2152
2153 return NULL;
2154 }
2155
2156 static void populate_system_links(const WCHAR *name, const WCHAR *const *values)
2157 {
2158 const WCHAR *value;
2159 int i;
2160 FontSubst *psub;
2161 Family *family;
2162 Face *face;
2163 const WCHAR *file;
2164
2165 if (values)
2166 {
2167 SYSTEM_LINKS *font_link;
2168
2169 psub = get_font_subst(&font_subst_list, name, -1);
2170 /* Don't store fonts that are only substitutes for other fonts */
2171 if(psub)
2172 {
2173 TRACE("%s: Internal SystemLink entry for substituted font, ignoring\n", debugstr_w(name));
2174 return;
2175 }
2176
2177 font_link = find_font_link(name);
2178 if (font_link == NULL)
2179 {
2180 font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
2181 font_link->font_name = strdupW(name);
2182 list_init(&font_link->links);
2183 list_add_tail(&system_links, &font_link->entry);
2184 }
2185
2186 memset(&font_link->fs, 0, sizeof font_link->fs);
2187 for (i = 0; values[i] != NULL; i++)
2188 {
2189 const struct list *face_list;
2190 CHILD_FONT *child_font;
2191
2192 value = values[i];
2193 if (!strcmpiW(name,value))
2194 continue;
2195 psub = get_font_subst(&font_subst_list, value, -1);
2196 if(psub)
2197 value = psub->to.name;
2198 family = find_family_from_name(value);
2199 if (!family)
2200 continue;
2201 file = NULL;
2202 /* Use first extant filename for this Family */
2203 face_list = get_face_list_from_family(family);
2204 LIST_FOR_EACH_ENTRY(face, face_list, Face, entry)
2205 {
2206 if (!face->file)
2207 continue;
2208 file = strrchrW(face->file, '/');
2209 if (!file)
2210 file = face->file;
2211 else
2212 file++;
2213 break;
2214 }
2215 if (!file)
2216 continue;
2217 face = find_face_from_filename(file, value);
2218 if(!face)
2219 {
2220 TRACE("Unable to find file %s face name %s\n", debugstr_w(file), debugstr_w(value));
2221 continue;
2222 }
2223
2224 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2225 child_font->face = face;
2226 child_font->font = NULL;
2227 font_link->fs.fsCsb[0] |= face->fs.fsCsb[0];
2228 font_link->fs.fsCsb[1] |= face->fs.fsCsb[1];
2229 TRACE("Adding file %s index %ld\n", debugstr_w(child_font->face->file),
2230 child_font->face->face_index);
2231 list_add_tail(&font_link->links, &child_font->entry);
2232
2233 TRACE("added internal SystemLink for %s to %s in %s\n", debugstr_w(name), debugstr_w(value),debugstr_w(file));
2234 }
2235 }
2236 }
2237
2238
2239 /*************************************************************
2240 * init_system_links
2241 */
2242 static BOOL init_system_links(void)
2243 {
2244 HKEY hkey;
2245 BOOL ret = FALSE;
2246 DWORD type, max_val, max_data, val_len, data_len, index;
2247 WCHAR *value, *data;
2248 WCHAR *entry, *next;
2249 SYSTEM_LINKS *font_link, *system_font_link;
2250 CHILD_FONT *child_font;
2251 static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
2252 static const WCHAR System[] = {'S','y','s','t','e','m',0};
2253 static const WCHAR MS_Shell_Dlg[] = {'M','S',' ','S','h','e','l','l',' ','D','l','g',0};
2254 Face *face;
2255 FontSubst *psub;
2256 UINT i, j;
2257
2258 if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
2259 {
2260 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
2261 value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
2262 data = HeapAlloc(GetProcessHeap(), 0, max_data);
2263 val_len = max_val + 1;
2264 data_len = max_data;
2265 index = 0;
2266 while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
2267 {
2268 psub = get_font_subst(&font_subst_list, value, -1);
2269 /* Don't store fonts that are only substitutes for other fonts */
2270 if(psub)
2271 {
2272 TRACE("%s: SystemLink entry for substituted font, ignoring\n", debugstr_w(value));
2273 goto next;
2274 }
2275 font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
2276 font_link->font_name = strdupW(value);
2277 memset(&font_link->fs, 0, sizeof font_link->fs);
2278 list_init(&font_link->links);
2279 for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
2280 {
2281 WCHAR *face_name;
2282 CHILD_FONT *child_font;
2283
2284 TRACE("%s: %s\n", debugstr_w(value), debugstr_w(entry));
2285
2286 next = entry + strlenW(entry) + 1;
2287
2288 face_name = strchrW(entry, ',');
2289 if(face_name)
2290 {
2291 *face_name++ = 0;
2292 while(isspaceW(*face_name))
2293 face_name++;
2294
2295 psub = get_font_subst(&font_subst_list, face_name, -1);
2296 if(psub)
2297 face_name = psub->to.name;
2298 }
2299 face = find_face_from_filename(entry, face_name);
2300 if(!face)
2301 {
2302 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
2303 continue;
2304 }
2305
2306 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2307 child_font->face = face;
2308 child_font->font = NULL;
2309 font_link->fs.fsCsb[0] |= face->fs.fsCsb[0];
2310 font_link->fs.fsCsb[1] |= face->fs.fsCsb[1];
2311 TRACE("Adding file %s index %ld\n",
2312 debugstr_w(child_font->face->file), child_font->face->face_index);
2313 list_add_tail(&font_link->links, &child_font->entry);
2314 }
2315 list_add_tail(&system_links, &font_link->entry);
2316 next:
2317 val_len = max_val + 1;
2318 data_len = max_data;
2319 }
2320
2321 HeapFree(GetProcessHeap(), 0, value);
2322 HeapFree(GetProcessHeap(), 0, data);
2323 RegCloseKey(hkey);
2324 }
2325
2326
2327 psub = get_font_subst(&font_subst_list, MS_Shell_Dlg, -1);
2328 if (!psub) {
2329 WARN("could not find FontSubstitute for MS Shell Dlg\n");
2330 goto skip_internal;
2331 }
2332
2333 for (i = 0; i < sizeof(font_links_defaults_list)/sizeof(font_links_defaults_list[0]); i++)
2334 {
2335 const FontSubst *psub2;
2336 psub2 = get_font_subst(&font_subst_list, font_links_defaults_list[i].shelldlg, -1);
2337
2338 if ((!strcmpiW(font_links_defaults_list[i].shelldlg, psub->to.name) || (psub2 && !strcmpiW(psub2->to.name,psub->to.name))))
2339 {
2340 for (j = 0; j < sizeof(font_links_list)/sizeof(font_links_list[0]); j++)
2341 populate_system_links(font_links_list[j], font_links_defaults_list[i].substitutes);
2342
2343 if (!strcmpiW(psub->to.name, font_links_defaults_list[i].substitutes[0]))
2344 populate_system_links(psub->to.name, font_links_defaults_list[i].substitutes);
2345 }
2346 else if (strcmpiW(psub->to.name, font_links_defaults_list[i].substitutes[0]))
2347 {
2348 populate_system_links(font_links_defaults_list[i].substitutes[0], NULL);
2349 }
2350 }
2351
2352 skip_internal:
2353
2354 /* Explicitly add an entry for the system font, this links to Tahoma and any links
2355 that Tahoma has */
2356
2357 system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
2358 system_font_link->font_name = strdupW(System);
2359 memset(&system_font_link->fs, 0, sizeof system_font_link->fs);
2360 list_init(&system_font_link->links);
2361
2362 face = find_face_from_filename(tahoma_ttf, Tahoma);
2363 if(face)
2364 {
2365 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2366 child_font->face = face;
2367 child_font->font = NULL;
2368 system_font_link->fs.fsCsb[0] |= face->fs.fsCsb[0];
2369 system_font_link->fs.fsCsb[1] |= face->fs.fsCsb[1];
2370 TRACE("Found Tahoma in %s index %ld\n",
2371 debugstr_w(child_font->face->file), child_font->face->face_index);
2372 list_add_tail(&system_font_link->links, &child_font->entry);
2373 }
2374 font_link = find_font_link(Tahoma);
2375 if (font_link != NULL)
2376 {
2377 CHILD_FONT *font_link_entry;
2378 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2379 {
2380 CHILD_FONT *new_child;
2381 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
2382 new_child->face = font_link_entry->face;
2383 new_child->font = NULL;
2384 new_child->face->refcount++;
2385 system_font_link->fs.fsCsb[0] |= font_link_entry->face->fs.fsCsb[0];
2386 system_font_link->fs.fsCsb[1] |= font_link_entry->face->fs.fsCsb[1];
2387 list_add_tail(&system_font_link->links, &new_child->entry);
2388 }
2389 }
2390 list_add_tail(&system_links, &system_font_link->entry);
2391 return ret;
2392 }
2393
2394 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
2395 {
2396 DIR *dir;
2397 struct dirent *dent;
2398 char path[MAX_PATH];
2399
2400 TRACE("Loading fonts from %s\n", debugstr_a(dirname));
2401
2402 dir = opendir(dirname);
2403 if(!dir) {
2404 WARN("Can't open directory %s\n", debugstr_a(dirname));
2405 return FALSE;
2406 }
2407 while((dent = readdir(dir)) != NULL) {
2408 struct stat statbuf;
2409
2410 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
2411 continue;
2412
2413 TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
2414
2415 sprintf(path, "%s/%s", dirname, dent->d_name);
2416
2417 if(stat(path, &statbuf) == -1)
2418 {
2419 WARN("Can't stat %s\n", debugstr_a(path));
2420 continue;
2421 }
2422 if(S_ISDIR(statbuf.st_mode))
2423 ReadFontDir(path, external_fonts);
2424 else
2425 {
2426 DWORD addfont_flags = ADDFONT_ADD_TO_CACHE;
2427 if(external_fonts) addfont_flags |= ADDFONT_EXTERNAL_FONT;
2428 AddFontToList(path, NULL, 0, addfont_flags);
2429 }
2430 }
2431 closedir(dir);
2432 return TRUE;
2433 }
2434
2435 #ifdef SONAME_LIBFONTCONFIG
2436
2437 static BOOL fontconfig_enabled;
2438
2439 static UINT parse_aa_pattern( FcPattern *pattern )
2440 {
2441 FcBool antialias;
2442 int rgba;
2443 UINT aa_flags = 0;
2444
2445 if (pFcPatternGetBool( pattern, FC_ANTIALIAS, 0, &antialias ) == FcResultMatch)
2446 aa_flags = antialias ? GGO_GRAY4_BITMAP : GGO_BITMAP;
2447
2448 if (pFcPatternGetInteger( pattern, FC_RGBA, 0, &rgba ) == FcResultMatch)
2449 {
2450 switch (rgba)
2451 {
2452 case FC_RGBA_RGB: aa_flags = WINE_GGO_HRGB_BITMAP; break;
2453 case FC_RGBA_BGR: aa_flags = WINE_GGO_HBGR_BITMAP; break;
2454 case FC_RGBA_VRGB: aa_flags = WINE_GGO_VRGB_BITMAP; break;
2455 case FC_RGBA_VBGR: aa_flags = WINE_GGO_VBGR_BITMAP; break;
2456 case FC_RGBA_NONE: aa_flags = GGO_GRAY4_BITMAP; break;
2457 }
2458 }
2459 return aa_flags;
2460 }
2461
2462 static void init_fontconfig(void)
2463 {
2464 void *fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
2465
2466 if (!fc_handle)
2467 {
2468 TRACE("Wine cannot find the fontconfig library (%s).\n", SONAME_LIBFONTCONFIG);
2469 return;
2470 }
2471
2472 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(fc_handle, #f, NULL, 0)) == NULL){WARN("Can't find symbol %s\n", #f); return;}
2473 LOAD_FUNCPTR(FcConfigSubstitute);
2474 LOAD_FUNCPTR(FcFontList);
2475 LOAD_FUNCPTR(FcFontSetDestroy);
2476 LOAD_FUNCPTR(FcInit);
2477 LOAD_FUNCPTR(FcObjectSetAdd);
2478 LOAD_FUNCPTR(FcObjectSetCreate);
2479 LOAD_FUNCPTR(FcObjectSetDestroy);
2480 LOAD_FUNCPTR(FcPatternCreate);
2481 LOAD_FUNCPTR(FcPatternDestroy);
2482 LOAD_FUNCPTR(FcPatternGetBool);
2483 LOAD_FUNCPTR(FcPatternGetInteger);
2484 LOAD_FUNCPTR(FcPatternGetString);
2485 #undef LOAD_FUNCPTR
2486
2487 if (pFcInit())
2488 {
2489 FcPattern *pattern = pFcPatternCreate();
2490 pFcConfigSubstitute( NULL, pattern, FcMatchFont );
2491 default_aa_flags = parse_aa_pattern( pattern );
2492 pFcPatternDestroy( pattern );
2493 TRACE( "enabled, default flags = %x\n", default_aa_flags );
2494 fontconfig_enabled = TRUE;
2495 }
2496 }
2497
2498 static void load_fontconfig_fonts(void)
2499 {
2500 FcPattern *pat;
2501 FcObjectSet *os;
2502 FcFontSet *fontset;
2503 int i, len;
2504 char *file;
2505 const char *ext;
2506
2507 if (!fontconfig_enabled) return;
2508
2509 pat = pFcPatternCreate();
2510 os = pFcObjectSetCreate();
2511 pFcObjectSetAdd(os, FC_FILE);
2512 pFcObjectSetAdd(os, FC_SCALABLE);
2513 pFcObjectSetAdd(os, FC_ANTIALIAS);
2514 pFcObjectSetAdd(os, FC_RGBA);
2515 fontset = pFcFontList(NULL, pat, os);
2516 if(!fontset) return;
2517 for(i = 0; i < fontset->nfont; i++) {
2518 FcBool scalable;
2519 DWORD aa_flags;
2520
2521 if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
2522 continue;
2523
2524 pFcConfigSubstitute( NULL, fontset->fonts[i], FcMatchFont );
2525
2526 /* We're just interested in OT/TT fonts for now, so this hack just
2527 picks up the scalable fonts without extensions .pf[ab] to save time
2528 loading every other font */
2529
2530 if(pFcPatternGetBool(fontset->fonts[i], FC_SCALABLE, 0, &scalable) == FcResultMatch && !scalable)
2531 {
2532 TRACE("not scalable\n");
2533 continue;
2534 }
2535
2536 aa_flags = parse_aa_pattern( fontset->fonts[i] );
2537 TRACE("fontconfig: %s aa %x\n", file, aa_flags);
2538
2539 len = strlen( file );
2540 if(len < 4) continue;
2541 ext = &file[ len - 3 ];
2542 if(strcasecmp(ext, "pfa") && strcasecmp(ext, "pfb"))
2543 AddFontToList(file, NULL, 0,
2544 ADDFONT_EXTERNAL_FONT | ADDFONT_ADD_TO_CACHE | ADDFONT_AA_FLAGS(aa_flags) );
2545 }
2546 pFcFontSetDestroy(fontset);
2547 pFcObjectSetDestroy(os);
2548 pFcPatternDestroy(pat);
2549 }
2550
2551 #elif defined(HAVE_CARBON_CARBON_H)
2552
2553 static void load_mac_font_callback(const void *value, void *context)
2554 {
2555 CFStringRef pathStr = value;
2556 CFIndex len;
2557 char* path;
2558
2559 len = CFStringGetMaximumSizeOfFileSystemRepresentation(pathStr);
2560 path = HeapAlloc(GetProcessHeap(), 0, len);
2561 if (path && CFStringGetFileSystemRepresentation(pathStr, path, len))
2562 {
2563 TRACE("font file %s\n", path);
2564 AddFontToList(path, NULL, 0, ADDFONT_EXTERNAL_FONT | ADDFONT_ADD_TO_CACHE);
2565 }
2566 HeapFree(GetProcessHeap(), 0, path);
2567 }
2568
2569 static void load_mac_fonts(void)
2570 {
2571 CFStringRef removeDupesKey;
2572 CFBooleanRef removeDupesValue;
2573 CFDictionaryRef options;
2574 CTFontCollectionRef col;
2575 CFArrayRef descs;
2576 CFMutableSetRef paths;
2577 CFIndex i;
2578
2579 removeDupesKey = kCTFontCollectionRemoveDuplicatesOption;
2580 removeDupesValue = kCFBooleanTrue;
2581 options = CFDictionaryCreate(NULL, (const void**)&removeDupesKey, (const void**)&removeDupesValue, 1,
2582 &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
2583 col = CTFontCollectionCreateFromAvailableFonts(options);
2584 if (options) CFRelease(options);
2585 if (!col)
2586 {
2587 WARN("CTFontCollectionCreateFromAvailableFonts failed\n");
2588 return;
2589 }
2590
2591 descs = CTFontCollectionCreateMatchingFontDescriptors(col);
2592 CFRelease(col);
2593 if (!descs)
2594 {
2595 WARN("CTFontCollectionCreateMatchingFontDescriptors failed\n");
2596 return;
2597 }
2598
2599 paths = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
2600 if (!paths)
2601 {
2602 WARN("CFSetCreateMutable failed\n");
2603 CFRelease(descs);
2604 return;
2605 }
2606
2607 for (i = 0; i < CFArrayGetCount(descs); i++)
2608 {
2609 CTFontDescriptorRef desc;
2610 CTFontRef font;
2611 ATSFontRef atsFont;
2612 OSStatus status;
2613 FSRef fsref;
2614 CFURLRef url;
2615 CFStringRef ext;
2616 CFStringRef path;
2617
2618 desc = CFArrayGetValueAtIndex(descs, i);
2619
2620 /* CTFontDescriptor doesn't support kCTFontURLAttribute until 10.6, so
2621 we have to go CFFontDescriptor -> CTFont -> ATSFont -> FSRef -> CFURL. */
2622 font = CTFontCreateWithFontDescriptor(desc, 0, NULL);
2623 if (!font) continue;
2624
2625 atsFont = CTFontGetPlatformFont(font, NULL);
2626 if (!atsFont)
2627 {
2628 CFRelease(font);
2629 continue;
2630 }
2631
2632 status = ATSFontGetFileReference(atsFont, &fsref);
2633 CFRelease(font);
2634 if (status != noErr) continue;
2635
2636 url = CFURLCreateFromFSRef(NULL, &fsref);
2637 if (!url) continue;
2638
2639 ext = CFURLCopyPathExtension(url);
2640 if (ext)
2641 {
2642 BOOL skip = (CFStringCompare(ext, CFSTR("pfa"), kCFCompareCaseInsensitive) == kCFCompareEqualTo ||
2643 CFStringCompare(ext, CFSTR("pfb"), kCFCompareCaseInsensitive) == kCFCompareEqualTo);
2644 CFRelease(ext);
2645 if (skip)
2646 {
2647 CFRelease(url);
2648 continue;
2649 }
2650 }
2651
2652 path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
2653 CFRelease(url);
2654 if (!path) continue;
2655
2656 CFSetAddValue(paths, path);
2657 CFRelease(path);
2658 }
2659
2660 CFRelease(descs);
2661
2662 CFSetApplyFunction(paths, load_mac_font_callback, NULL);
2663 CFRelease(paths);
2664 }
2665
2666 #endif
2667
2668 static char *get_data_dir_path( LPCWSTR file )
2669 {
2670 char *unix_name = NULL;
2671 const char *data_dir = wine_get_data_dir();
2672
2673 if (!data_dir) data_dir = wine_get_build_dir();
2674
2675 if (data_dir)
2676 {
2677 INT len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
2678
2679 unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
2680 strcpy(unix_name, data_dir);
2681 strcat(unix_name, "/fonts/");
2682
2683 WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
2684 }
2685 return unix_name;
2686 }
2687
2688 static BOOL load_font_from_data_dir(LPCWSTR file)
2689 {
2690 BOOL ret = FALSE;
2691 char *unix_name = get_data_dir_path( file );
2692
2693 if (unix_name)
2694 {
2695 EnterCriticalSection( &freetype_cs );
2696 ret = AddFontToList(unix_name, NULL, 0, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_TO_CACHE);
2697 LeaveCriticalSection( &freetype_cs );
2698 HeapFree(GetProcessHeap(), 0, unix_name);
2699 }
2700 return ret;
2701 }
2702
2703 static char *get_winfonts_dir_path(LPCWSTR file)
2704 {
2705 static const WCHAR slashW[] = {'\\','\0'};
2706 WCHAR windowsdir[MAX_PATH];
2707
2708 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2709 strcatW(windowsdir, fontsW);
2710 strcatW(windowsdir, slashW);
2711 strcatW(windowsdir, file);
2712 return wine_get_unix_file_name( windowsdir );
2713 }
2714
2715 static void load_system_fonts(void)
2716 {
2717 HKEY hkey;
2718 WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
2719 const WCHAR * const *value;
2720 DWORD dlen, type;
2721 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
2722 char *unixname;
2723
2724 if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
2725 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2726 strcatW(windowsdir, fontsW);
2727 for(value = SystemFontValues; *value; value++) {
2728 dlen = sizeof(data);
2729 if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
2730 type == REG_SZ) {
2731 BOOL added = FALSE;
2732
2733 sprintfW(pathW, fmtW, windowsdir, data);
2734 if((unixname = wine_get_unix_file_name(pathW))) {
2735 added = AddFontToList(unixname, NULL, 0, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_TO_CACHE);
2736 HeapFree(GetProcessHeap(), 0, unixname);
2737 }
2738 if (!added)
2739 load_font_from_data_dir(data);
2740 }
2741 }
2742 RegCloseKey(hkey);
2743 }
2744 }
2745
2746 /*************************************************************
2747 *
2748 * This adds registry entries for any externally loaded fonts
2749 * (fonts from fontconfig or FontDirs). It also deletes entries
2750 * of no longer existing fonts.
2751 *
2752 */
2753 static void update_reg_entries(void)
2754 {
2755 HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
2756 LPWSTR valueW;
2757 DWORD len;
2758 Family *family;
2759 Face *face;
2760 WCHAR *file, *path;
2761 static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
2762
2763 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
2764 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
2765 ERR("Can't create Windows font reg key\n");
2766 goto end;
2767 }
2768
2769 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
2770 0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
2771 ERR("Can't create Windows font reg key\n");
2772 goto end;
2773 }
2774
2775 if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
2776 0, NULL, 0, KEY_ALL_ACCESS, NULL, &external_key, NULL) != ERROR_SUCCESS) {
2777 ERR("Can't create external font reg key\n");
2778 goto end;
2779 }
2780
2781 /* enumerate the fonts and add external ones to the two keys */
2782
2783 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
2784 LIST_FOR_EACH_ENTRY( face, &family->faces, Face, entry ) {
2785 char *buffer;
2786 if (!(face->flags & ADDFONT_EXTERNAL_FONT)) continue;
2787
2788 if(face->FullName)
2789 {
2790 len = strlenW(face->FullName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
2791 valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2792 strcpyW(valueW, face->FullName);
2793 }
2794 else
2795 {
2796 len = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
2797 valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2798 strcpyW(valueW, family->FamilyName);
2799 }
2800
2801 buffer = strWtoA( CP_UNIXCP, face->file );
2802 path = wine_get_dos_file_name( buffer );
2803 HeapFree( GetProcessHeap(), 0, buffer );
2804
2805 if (path)
2806 file = path;
2807 else if ((file = strrchrW(face->file, '/')))
2808 file++;
2809 else
2810 file = face->file;
2811
2812 len = strlenW(file) + 1;
2813 RegSetValueExW(winnt_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2814 RegSetValueExW(win9x_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2815 RegSetValueExW(external_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2816
2817 HeapFree(GetProcessHeap(), 0, path);
2818 HeapFree(GetProcessHeap(), 0, valueW);
2819 }
2820 }
2821 end:
2822 if(external_key) RegCloseKey(external_key);
2823 if(win9x_key) RegCloseKey(win9x_key);
2824 if(winnt_key) RegCloseKey(winnt_key);
2825 return;
2826 }
2827
2828 static void delete_external_font_keys(void)
2829 {
2830 HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
2831 DWORD dlen, vlen, datalen, valuelen, i, type;
2832 LPWSTR valueW;
2833 LPVOID data;
2834
2835 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
2836 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
2837 ERR("Can't create Windows font reg key\n");
2838 goto end;
2839 }
2840
2841 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
2842 0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
2843 ERR("Can't create Windows font reg key\n");
2844 goto end;
2845 }
2846
2847 if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &external_key) != ERROR_SUCCESS) {
2848 ERR("Can't create external font reg key\n");
2849 goto end;
2850 }
2851
2852 /* Delete all external fonts added last time */
2853
2854 RegQueryInfoKeyW(external_key, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2855 &valuelen, &datalen, NULL, NULL);
2856 valuelen++; /* returned value doesn't include room for '\0' */
2857 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2858 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
2859
2860 dlen = datalen * sizeof(WCHAR);
2861 vlen = valuelen;
2862 i = 0;
2863 while(RegEnumValueW(external_key, i++, valueW, &vlen, NULL, &type, data,
2864 &dlen) == ERROR_SUCCESS) {
2865
2866 RegDeleteValueW(winnt_key, valueW);
2867 RegDeleteValueW(win9x_key, valueW);
2868 /* reset dlen and vlen */
2869 dlen = datalen;
2870 vlen = valuelen;
2871 }
2872 HeapFree(GetProcessHeap(), 0, data);
2873 HeapFree(GetProcessHeap(), 0, valueW);
2874
2875 /* Delete the old external fonts key */
2876 RegCloseKey(external_key);
2877 RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
2878
2879 end:
2880 if(win9x_key) RegCloseKey(win9x_key);
2881 if(winnt_key) RegCloseKey(winnt_key);
2882 }
2883
2884 /*************************************************************
2885 * WineEngAddFontResourceEx
2886 *
2887 */
2888 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2889 {
2890 INT ret = 0;
2891
2892 GDI_CheckNotLock();
2893
2894 if (ft_handle) /* do it only if we have freetype up and running */
2895 {
2896 char *unixname;
2897
2898 EnterCriticalSection( &freetype_cs );
2899
2900 if((unixname = wine_get_unix_file_name(file)))
2901 {
2902 DWORD addfont_flags = ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE;
2903
2904 if(!(flags & FR_PRIVATE)) addfont_flags |= ADDFONT_ADD_TO_CACHE;
2905 ret = AddFontToList(unixname, NULL, 0, addfont_flags);
2906 HeapFree(GetProcessHeap(), 0, unixname);
2907 }
2908 if (!ret && !strchrW(file, '\\')) {
2909 /* Try in %WINDIR%/fonts, needed for Fotobuch Designer */
2910 if ((unixname = get_winfonts_dir_path( file )))
2911 {
2912 ret = AddFontToList(unixname, NULL, 0, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE);
2913 HeapFree(GetProcessHeap(), 0, unixname);
2914 }
2915 /* Try in datadir/fonts (or builddir/fonts), needed for Magic the Gathering Online */
2916 if (!ret && (unixname = get_data_dir_path( file )))
2917 {
2918 ret = AddFontToList(unixname, NULL, 0, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE);
2919 HeapFree(GetProcessHeap(), 0, unixname);
2920 }
2921 }
2922
2923 LeaveCriticalSection( &freetype_cs );
2924 }
2925 return ret;
2926 }
2927
2928 /*************************************************************
2929 * WineEngAddFontMemResourceEx
2930 *
2931 */
2932 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
2933 {
2934 GDI_CheckNotLock();
2935
2936 if (ft_handle) /* do it only if we have freetype up and running */
2937 {
2938 PVOID pFontCopy = HeapAlloc(GetProcessHeap(), 0, cbFont);
2939
2940 TRACE("Copying %d bytes of data from %p to %p\n", cbFont, pbFont, pFontCopy);
2941 memcpy(pFontCopy, pbFont, cbFont);
2942
2943 EnterCriticalSection( &freetype_cs );
2944 *pcFonts = AddFontToList(NULL, pFontCopy, cbFont, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE);
2945 LeaveCriticalSection( &freetype_cs );
2946
2947 if (*pcFonts == 0)
2948 {
2949 TRACE("AddFontToList failed\n");
2950 HeapFree(GetProcessHeap(), 0, pFontCopy);
2951 return 0;
2952 }
2953 /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
2954 * For now return something unique but quite random
2955 */
2956 TRACE("Returning handle %lx\n", ((INT_PTR)pFontCopy)^0x87654321);
2957 return (HANDLE)(((INT_PTR)pFontCopy)^0x87654321);
2958 }
2959
2960 *pcFonts = 0;
2961 return 0;
2962 }
2963
2964 /*************************************************************
2965 * WineEngRemoveFontResourceEx
2966 *
2967 */
2968 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2969 {
2970 INT ret = 0;
2971
2972 GDI_CheckNotLock();
2973
2974 if (ft_handle) /* do it only if we have freetype up and running */
2975 {
2976 char *unixname;
2977
2978 EnterCriticalSection( &freetype_cs );
2979
2980 if ((unixname = wine_get_unix_file_name(file)))
2981 {
2982 DWORD addfont_flags = ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE;
2983
2984 if(!(flags & FR_PRIVATE)) addfont_flags |= ADDFONT_ADD_TO_CACHE;
2985 ret = remove_font_resource( unixname, addfont_flags );
2986 HeapFree(GetProcessHeap(), 0, unixname);
2987 }
2988 if (!ret && !strchrW(file, '\\'))
2989 {
2990 if ((unixname = get_winfonts_dir_path( file )))
2991 {
2992 ret = remove_font_resource( unixname, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE );
2993 HeapFree(GetProcessHeap(), 0, unixname);
2994 }
2995 if (!ret && (unixname = get_data_dir_path( file )))
2996 {
2997 ret = remove_font_resource( unixname, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_RESOURCE );
2998 HeapFree(GetProcessHeap(), 0, unixname);
2999 }
3000 }
3001
3002 LeaveCriticalSection( &freetype_cs );
3003 }
3004 return ret;
3005 }
3006
3007 static char *get_ttf_file_name( LPCWSTR font_file, LPCWSTR font_path )
3008 {
3009 WCHAR *fullname;
3010 char *unix_name;
3011 int file_len;
3012
3013 if (!font_file) return NULL;
3014
3015 file_len = strlenW( font_file );
3016
3017 if (font_path && font_path[0])
3018 {
3019 int path_len = strlenW( font_path );
3020 fullname = HeapAlloc( GetProcessHeap(), 0, (file_len + path_len + 2) * sizeof(WCHAR) );
3021 if (!fullname) return NULL;
3022 memcpy( fullname, font_path, path_len * sizeof(WCHAR) );
3023 fullname[path_len] = '\\';
3024 memcpy( fullname + path_len + 1, font_file, (file_len + 1) * sizeof(WCHAR) );
3025 }
3026 else
3027 {
3028 int len = GetFullPathNameW( font_file, 0, NULL, NULL );
3029 if (!len) return NULL;
3030 fullname = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3031 if (!fullname) return NULL;
3032 GetFullPathNameW( font_file, len, fullname, NULL );
3033 }
3034
3035 unix_name = wine_get_unix_file_name( fullname );
3036 HeapFree( GetProcessHeap(), 0, fullname );
3037 return unix_name;
3038 }
3039
3040 #include <pshpack1.h>
3041 struct fontdir
3042 {
3043 WORD num_of_resources;
3044 WORD res_id;
3045 WORD dfVersion;
3046 DWORD dfSize;
3047 CHAR dfCopyright[60];
3048 WORD dfType;
3049 WORD dfPoints;
3050 WORD dfVertRes;
3051 WORD dfHorizRes;
3052 WORD dfAscent;
3053 WORD dfInternalLeading;
3054 WORD dfExternalLeading;
3055 BYTE dfItalic;
3056 BYTE dfUnderline;
3057 BYTE dfStrikeOut;
3058 WORD dfWeight;
3059 BYTE dfCharSet;
3060 WORD dfPixWidth;
3061 WORD dfPixHeight;
3062 BYTE dfPitchAndFamily;
3063 WORD dfAvgWidth;
3064 WORD dfMaxWidth;
3065 BYTE dfFirstChar;
3066 BYTE dfLastChar;
3067 BYTE dfDefaultChar;
3068 BYTE dfBreakChar;
3069 WORD dfWidthBytes;
3070 DWORD dfDevice;
3071 DWORD dfFace;
3072 DWORD dfReserved;
3073 CHAR szFaceName[LF_FACESIZE];
3074 };
3075
3076 #include <poppack.h>
3077
3078 static void GetEnumStructs(Face *face, const WCHAR *family_name, LPENUMLOGFONTEXW pelf,
3079 NEWTEXTMETRICEXW *pntm, LPDWORD ptype);
3080
3081 static BOOL get_fontdir( const char *unix_name, struct fontdir *fd )
3082 {
3083 FT_Face ft_face = new_ft_face( unix_name, NULL, 0, 0, FALSE );
3084 Face *face;
3085 WCHAR *name, *english_name;
3086 ENUMLOGFONTEXW elf;
3087 NEWTEXTMETRICEXW ntm;
3088 DWORD type;
3089
3090 if (!ft_face) return FALSE;
3091 face = create_face( ft_face, 0, unix_name, NULL, 0, 0 );
3092 get_family_names( ft_face, &name, &english_name, FALSE );
3093 pFT_Done_Face( ft_face );
3094
3095 GetEnumStructs( face, name, &elf, &ntm, &type );
3096 release_face( face );
3097 HeapFree( GetProcessHeap(), 0, name );
3098 HeapFree( GetProcessHeap(), 0, english_name );
3099
3100 if ((type & TRUETYPE_FONTTYPE) == 0) return FALSE;
3101
3102 memset( fd, 0, sizeof(*fd) );
3103
3104 fd->num_of_resources = 1;
3105 fd->res_id = 0;
3106 fd->dfVersion = 0x200;
3107 fd->dfSize = sizeof(*fd);
3108 strcpy( fd->dfCopyright, "Wine fontdir" );
3109 fd->dfType = 0x4003; /* 0x0080 set if private */
3110 fd->dfPoints = ntm.ntmTm.ntmSizeEM;
3111 fd->dfVertRes = 72;
3112 fd->dfHorizRes = 72;
3113 fd->dfAscent = ntm.ntmTm.tmAscent;
3114 fd->dfInternalLeading = ntm.ntmTm.tmInternalLeading;
3115 fd->dfExternalLeading = ntm.ntmTm.tmExternalLeading;
3116 fd->dfItalic = ntm.ntmTm.tmItalic;
3117 fd->dfUnderline = ntm.ntmTm.tmUnderlined;
3118 fd->dfStrikeOut = ntm.ntmTm.tmStruckOut;
3119 fd->dfWeight = ntm.ntmTm.tmWeight;
3120 fd->dfCharSet = ntm.ntmTm.tmCharSet;
3121 fd->dfPixWidth = 0;
3122 fd->dfPixHeight = ntm.ntmTm.tmHeight;
3123 fd->dfPitchAndFamily = ntm.ntmTm.tmPitchAndFamily;
3124 fd->dfAvgWidth = ntm.ntmTm.tmAveCharWidth;
3125 fd->dfMaxWidth = ntm.ntmTm.tmMaxCharWidth;
3126 fd->dfFirstChar = ntm.ntmTm.tmFirstChar;
3127 fd->dfLastChar = ntm.ntmTm.tmLastChar;
3128 fd->dfDefaultChar = ntm.ntmTm.tmDefaultChar;
3129 fd->dfBreakChar = ntm.ntmTm.tmBreakChar;
3130 fd->dfWidthBytes = 0;
3131 fd->dfDevice = 0;
3132 fd->dfFace = FIELD_OFFSET( struct fontdir, szFaceName );
3133 fd->dfReserved = 0;
3134 WideCharToMultiByte( CP_ACP, 0, elf.elfLogFont.lfFaceName, -1, fd->szFaceName, LF_FACESIZE, NULL, NULL );
3135
3136 return TRUE;
3137 }
3138
3139 #define NE_FFLAGS_LIBMODULE 0x8000
3140 #define NE_OSFLAGS_WINDOWS 0x02
3141
3142 static const char dos_string[0x40] = "This is a TrueType resource file";
3143 static const char FONTRES[] = {'F','O','N','T','R','E','S',':'};
3144
3145 #include <pshpack2.h>
3146
3147 struct ne_typeinfo
3148 {
3149 WORD type_id;
3150 WORD count;
3151 DWORD res;
3152 };
3153
3154 struct ne_nameinfo
3155 {
3156 WORD off;
3157 WORD len;
3158 WORD flags;
3159 WORD id;
3160 DWORD res;
3161 };
3162
3163 struct rsrc_tab
3164 {
3165 WORD align;
3166 struct ne_typeinfo fontdir_type;
3167 struct ne_nameinfo fontdir_name;
3168 struct ne_typeinfo scalable_type;
3169 struct ne_nameinfo scalable_name;
3170 WORD end_of_rsrc;
3171 BYTE fontdir_res_name[8];
3172 };
3173
3174 #include <poppack.h>
3175
3176 static BOOL create_fot( const WCHAR *resource, const WCHAR *font_file, const struct fontdir *fontdir )
3177 {
3178 BOOL ret = FALSE;
3179 HANDLE file;
3180 DWORD size, written;
3181 BYTE *ptr, *start;
3182 BYTE import_name_len, res_name_len, non_res_name_len, font_file_len;
3183 char *font_fileA, *last_part, *ext;
3184 IMAGE_DOS_HEADER dos;
3185 IMAGE_OS2_HEADER ne =
3186 {
3187 IMAGE_OS2_SIGNATURE, 5, 1, 0, 0, 0, NE_FFLAGS_LIBMODULE, 0,
3188 0, 0, 0, 0, 0, 0,
3189 0, sizeof(ne), sizeof(ne), 0, 0, 0, 0,
3190 0, 4, 2, NE_OSFLAGS_WINDOWS, 0, 0, 0, 0, 0x300
3191 };
3192 struct rsrc_tab rsrc_tab =
3193 {
3194 4,
3195 { 0x8007, 1, 0 },
3196 { 0, 0, 0x0c50, 0x2c, 0 },
3197 { 0x80cc, 1, 0 },
3198 { 0, 0, 0x0c50, 0x8001, 0 },
3199 0,
3200 { 7,'F','O','N','T','D','I','R'}
3201 };
3202
3203 memset( &dos, 0, sizeof(dos) );
3204 dos.e_magic = IMAGE_DOS_SIGNATURE;
3205 dos.e_lfanew = sizeof(dos) + sizeof(dos_string);
3206
3207 /* import name is last part\0, resident name is last part without extension
3208 non-resident name is "FONTRES:" + lfFaceName */
3209
3210 font_file_len = WideCharToMultiByte( CP_ACP, 0, font_file, -1, NULL, 0, NULL, NULL );
3211 font_fileA = HeapAlloc( GetProcessHeap(), 0, font_file_len );
3212 WideCharToMultiByte( CP_ACP, 0, font_file, -1, font_fileA, font_file_len, NULL, NULL );
3213
3214 last_part = strrchr( font_fileA, '\\' );
3215 if (last_part) last_part++;
3216 else last_part = font_fileA;
3217 import_name_len = strlen( last_part ) + 1;
3218
3219 ext = strchr( last_part, '.' );
3220 if (ext) res_name_len = ext - last_part;
3221 else res_name_len = import_name_len - 1;
3222
3223 non_res_name_len = sizeof( FONTRES ) + strlen( fontdir->szFaceName );
3224
3225 ne.ne_cbnrestab = 1 + non_res_name_len + 2 + 1; /* len + string + (WORD) ord_num + 1 byte eod */
3226 ne.ne_restab = ne.ne_rsrctab + sizeof(rsrc_tab);
3227 ne.ne_modtab = ne.ne_imptab = ne.ne_restab + 1 + res_name_len + 2 + 3; /* len + string + (WORD) ord_num + 3 bytes eod */
3228 ne.ne_enttab = ne.ne_imptab + 1 + import_name_len; /* len + string */
3229 ne.ne_cbenttab = 2;
3230 ne.ne_nrestab = ne.ne_enttab + ne.ne_cbenttab + 2 + dos.e_lfanew; /* there are 2 bytes of 0 after entry tab */
3231
3232 rsrc_tab.scalable_name.off = (ne.ne_nrestab + ne.ne_cbnrestab + 0xf) >> 4;
3233 rsrc_tab.scalable_name.len = (font_file_len + 0xf) >> 4;
3234 rsrc_tab.fontdir_name.off = rsrc_tab.scalable_name.off + rsrc_tab.scalable_name.len;
3235 rsrc_tab.fontdir_name.len = (fontdir->dfSize + 0xf) >> 4;
3236
3237 size = (rsrc_tab.fontdir_name.off + rsrc_tab.fontdir_name.len) << 4;
3238 start = ptr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
3239
3240 if (!ptr)
3241 {
3242 HeapFree( GetProcessHeap(), 0, font_fileA );
3243 return FALSE;
3244 }
3245
3246 memcpy( ptr, &dos, sizeof(dos) );
3247 memcpy( ptr + sizeof(dos), dos_string, sizeof(dos_string) );
3248 memcpy( ptr + dos.e_lfanew, &ne, sizeof(ne) );
3249
3250 ptr = start + dos.e_lfanew + ne.ne_rsrctab;
3251 memcpy( ptr, &rsrc_tab, sizeof(rsrc_tab) );
3252
3253 ptr = start + dos.e_lfanew + ne.ne_restab;
3254 *ptr++ = res_name_len;
3255 memcpy( ptr, last_part, res_name_len );
3256
3257 ptr = start + dos.e_lfanew + ne.ne_imptab;
3258 *ptr++ = import_name_len;
3259 memcpy( ptr, last_part, import_name_len );
3260
3261 ptr = start + ne.ne_nrestab;
3262 *ptr++ = non_res_name_len;
3263 memcpy( ptr, FONTRES, sizeof(FONTRES) );
3264 memcpy( ptr + sizeof(FONTRES), fontdir->szFaceName, strlen( fontdir->szFaceName ) );
3265
3266 ptr = start + (rsrc_tab.scalable_name.off << 4);
3267 memcpy( ptr, font_fileA, font_file_len );
3268
3269 ptr = start + (rsrc_tab.fontdir_name.off << 4);
3270 memcpy( ptr, fontdir, fontdir->dfSize );
3271
3272 file = CreateFileW( resource, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL );
3273 if (file != INVALID_HANDLE_VALUE)
3274 {
3275 if (WriteFile( file, start, size, &written, NULL ) && written == size)
3276 ret = TRUE;
3277 CloseHandle( file );
3278 }
3279
3280 HeapFree( GetProcessHeap(), 0, start );
3281 HeapFree( GetProcessHeap(), 0, font_fileA );
3282
3283 return ret;
3284 }
3285
3286 /*************************************************************
3287 * WineEngCreateScalableFontResource
3288 *
3289 */
3290 BOOL WineEngCreateScalableFontResource( DWORD hidden, LPCWSTR resource,
3291 LPCWSTR font_file, LPCWSTR font_path )
3292 {
3293 char *unix_name = get_ttf_file_name( font_file, font_path );
3294 struct fontdir fontdir;
3295 BOOL ret = FALSE;
3296
3297 if (!unix_name || !get_fontdir( unix_name, &fontdir ))
3298 SetLastError( ERROR_INVALID_PARAMETER );
3299 else
3300 {
3301 if (hidden) fontdir.dfType |= 0x80;
3302 ret = create_fot( resource, font_file, &fontdir );
3303 }
3304
3305 HeapFree( GetProcessHeap(), 0, unix_name );
3306 return ret;
3307 }
3308
3309 static const struct nls_update_font_list
3310 {
3311 UINT ansi_cp, oem_cp;
3312 const char *oem, *fixed, *system;
3313 const char *courier, *serif, *small, *sserif_96, *sserif_120;
3314 /* these are for font substitutes */
3315 const char *shelldlg, *tmsrmn;
3316 const char *fixed_0, *system_0, *courier_0, *serif_0, *small_0, *sserif_0,
3317 *helv_0, *tmsrmn_0;
3318 const struct subst
3319 {
3320 const char *from, *to;
3321 } arial_0, courier_new_0, times_new_roman_0;
3322 } nls_update_font_list[] =
3323 {
3324 /* Latin 1 (United States) */
3325 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
3326 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon", "sseriff.fon",
3327 "Tahoma","Times New Roman",
3328 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3329 { 0 }, { 0 }, { 0 }
3330 },
3331 /* Latin 1 (Multilingual) */
3332 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
3333 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon", "sseriff.fon",
3334 "Tahoma","Times New Roman", /* FIXME unverified */
3335 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3336 { 0 }, { 0 }, { 0 }
3337 },
3338 /* Eastern Europe */
3339 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
3340 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon", "sseriffe.fon",
3341 "Tahoma","Times New Roman", /* FIXME unverified */
3342 "Fixedsys,238", "System,238",
3343 "Courier New,238", "MS Serif,238", "Small Fonts,238",
3344 "MS Sans Serif,238", "MS Sans Serif,238", "MS Serif,238",
3345 { "Arial CE,0", "Arial,238" },
3346 { "Courier New CE,0", "Courier New,238" },
3347 { "Times New Roman CE,0", "Times New Roman,238" }
3348 },
3349 /* Cyrillic */
3350 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
3351 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon", "sseriffr.fon",
3352 "Tahoma","Times New Roman", /* FIXME unverified */
3353 "Fixedsys,204", "System,204",
3354 "Courier New,204", "MS Serif,204", "Small Fonts,204",
3355 "MS Sans Serif,204", "MS Sans Serif,204", "MS Serif,204",
3356 { "Arial Cyr,0", "Arial,204" },
3357 { "Courier New Cyr,0", "Courier New,204" },
3358 { "Times New Roman Cyr,0", "Times New Roman,204" }
3359 },
3360 /* Greek */
3361 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
3362 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon", "sseriffg.fon",
3363 "Tahoma","Times New Roman", /* FIXME unverified */
3364 "Fixedsys,161", "System,161",
3365 "Courier New,161", "MS Serif,161", "Small Fonts,161",
3366 "MS Sans Serif,161", "MS Sans Serif,161", "MS Serif,161",
3367 { "Arial Greek,0", "Arial,161" },
3368 { "Courier New Greek,0", "Courier New,161" },
3369 { "Times New Roman Greek,0", "Times New Roman,161" }
3370 },
3371 /* Turkish */
3372 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
3373 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon", "sserifft.fon",
3374 "Tahoma","Times New Roman", /* FIXME unverified */
3375 "Fixedsys,162", "System,162",
3376 "Courier New,162", "MS Serif,162", "Small Fonts,162",
3377 "MS Sans Serif,162", "MS Sans Serif,162", "MS Serif,162",
3378 { "Arial Tur,0", "Arial,162" },
3379 { "Courier New Tur,0", "Courier New,162" },
3380 { "Times New Roman Tur,0", "Times New Roman,162" }
3381 },
3382 /* Hebrew */
3383 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
3384 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon", "ssef1255.fon",
3385 "Tahoma","Times New Roman", /* FIXME unverified */
3386 "Fixedsys,177", "System,177",
3387 "Courier New,177", "MS Serif,177", "Small Fonts,177",
3388 "MS Sans Serif,177", "MS Sans Serif,177", "MS Serif,177",
3389 { 0 }, { 0 }, { 0 }
3390 },
3391 /* Arabic */
3392 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
3393 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon", "ssef1256.fon",
3394 "Tahoma","Times New Roman", /* FIXME unverified */
3395 "Fixedsys,178", "System,178",
3396 "Courier New,178", "MS Serif,178", "Small Fonts,178",
3397 "MS Sans Serif,178", "MS Sans Serif,178", "MS Serif,178",
3398 { 0 }, { 0 }, { 0 }
3399 },
3400 /* Baltic */
3401 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
3402 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon", "ssef1257.fon",
3403 "Tahoma","Times New Roman", /* FIXME unverified */
3404 "Fixedsys,186", "System,186",
3405 "Courier New,186", "MS Serif,186", "Small Fonts,186",
3406 "MS Sans Serif,186", "MS Sans Serif,186", "MS Serif,186",
3407 { "Arial Baltic,0", "Arial,186" },
3408 { "Courier New Baltic,0", "Courier New,186" },
3409 { "Times New Roman Baltic,0", "Times New Roman,186" }
3410 },
3411 /* Vietnamese */
3412 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
3413 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon", "sseriff.fon",
3414 "Tahoma","Times New Roman", /* FIXME unverified */
3415 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3416 { 0 }, { 0 }, { 0 }
3417 },
3418 /* Thai */
3419 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
3420 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon", "ssef874.fon",
3421 "Tahoma","Times New Roman", /* FIXME unverified */
3422 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3423 { 0 }, { 0 }, { 0 }
3424 },
3425 /* Japanese */
3426 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
3427 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon", "sseriff.fon",
3428 "MS UI Gothic","MS Serif",
3429 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3430 { 0 }, { 0 }, { 0 }
3431 },
3432 /* Chinese Simplified */
3433 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
3434 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon", "sseriff.fon",
3435 "SimSun", "NSimSun",
3436 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3437 { 0 }, { 0 }, { 0 }
3438 },
3439 /* Korean */
3440 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
3441 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon", "sseriff.fon",
3442 "Gulim", "Batang",
3443 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3444 { 0 }, { 0 }, { 0 }
3445 },
3446 /* Chinese Traditional */
3447 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
3448 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon", "sseriff.fon",
3449 "PMingLiU", "MingLiU",
3450 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3451 { 0 }, { 0 }, { 0 }
3452 }
3453 };
3454
3455 static inline BOOL is_dbcs_ansi_cp(UINT ansi_cp)
3456 {
3457 return ( ansi_cp == 932 /* CP932 for Japanese */
3458 || ansi_cp == 936 /* CP936 for Chinese Simplified */
3459 || ansi_cp == 949 /* CP949 for Korean */
3460 || ansi_cp == 950 ); /* CP950 for Chinese Traditional */
3461 }
3462
3463 static inline HKEY create_fonts_NT_registry_key(void)
3464 {
3465 HKEY hkey = 0;
3466
3467 RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
3468 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
3469 return hkey;
3470 }
3471
3472 static inline HKEY create_fonts_9x_registry_key(void)
3473 {
3474 HKEY hkey = 0;
3475
3476 RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
3477 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
3478 return hkey;
3479 }
3480
3481 static inline HKEY create_config_fonts_registry_key(void)
3482 {
3483 HKEY hkey = 0;
3484
3485 RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
3486 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
3487 return hkey;
3488 }
3489
3490 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl, int dpi)
3491 {
3492 const char *sserif = (dpi <= 108) ? fl->sserif_96 : fl->sserif_120;
3493
3494 RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
3495 RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
3496 RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)sserif, strlen(sserif)+1);
3497 RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
3498 }
3499
3500 static void set_value_key(HKEY hkey, const char *name, const char *value)
3501 {
3502 if (value)
3503 RegSetValueExA(hkey, name, 0, REG_SZ, (const BYTE *)value, strlen(value) + 1);
3504 else if (name)
3505 RegDeleteValueA(hkey, name);
3506 }
3507
3508 static void update_font_info(void)
3509 {
3510 static const WCHAR logpixels[] = { 'L','o','g','P','i','x','e','l','s',0 };
3511 char buf[40], cpbuf[40];
3512 DWORD len, type;
3513 HKEY hkey = 0;
3514 UINT i, ansi_cp = 0, oem_cp = 0;
3515 DWORD screen_dpi = 96, font_dpi = 0;
3516 BOOL done = FALSE;
3517
3518 if (RegOpenKeyA(HKEY_LOCAL_MACHINE,
3519 "System\\CurrentControlSet\\Hardware Profiles\\Current\\Software\\Fonts",
3520 &hkey) == ERROR_SUCCESS)
3521 {
3522 reg_load_dword(hkey, logpixels, &screen_dpi);
3523 RegCloseKey(hkey);
3524 }
3525
3526 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL) != ERROR_SUCCESS)
3527 return;
3528
3529 reg_load_dword(hkey, logpixels, &font_dpi);
3530
3531 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
3532 (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
3533 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
3534 (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
3535 sprintf( cpbuf, "%u,%u", ansi_cp, oem_cp );
3536
3537 /* Setup Default_Fallback usage for DBCS ANSI codepages */
3538 if (is_dbcs_ansi_cp(ansi_cp))
3539 use_default_fallback = TRUE;
3540
3541 len = sizeof(buf);
3542 if (RegQueryValueExA(hkey, "Codepages", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
3543 {
3544 if (!strcmp( buf, cpbuf ) && screen_dpi == font_dpi) /* already set correctly */
3545 {
3546 RegCloseKey(hkey);
3547 return;
3548 }
3549 TRACE("updating registry, codepages/logpixels changed %s/%u -> %u,%u/%u\n",
3550 buf, font_dpi, ansi_cp, oem_cp, screen_dpi);
3551 }
3552 else TRACE("updating registry, codepages/logpixels changed none -> %u,%u/%u\n",
3553 ansi_cp, oem_cp, screen_dpi);
3554
3555 RegSetValueExA(hkey, "Codepages", 0, REG_SZ, (const BYTE *)cpbuf, strlen(cpbuf)+1);
3556 RegSetValueExW(hkey, logpixels, 0, REG_DWORD, (const BYTE *)&screen_dpi, sizeof(screen_dpi));
3557 RegCloseKey(hkey);
3558
3559 for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
3560 {
3561 HKEY hkey;
3562
3563 if (nls_update_font_list[i].ansi_cp == ansi_cp &&
3564 nls_update_font_list[i].oem_cp == oem_cp)
3565 {
3566 hkey = create_config_fonts_registry_key();
3567 RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
3568 RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
3569 RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
3570 RegCloseKey(hkey);
3571
3572 hkey = create_fonts_NT_registry_key();
3573 add_font_list(hkey, &nls_update_font_list[i], screen_dpi);
3574 RegCloseKey(hkey);
3575
3576 hkey = create_fonts_9x_registry_key();
3577 add_font_list(hkey, &nls_update_font_list[i], screen_dpi);
3578 RegCloseKey(hkey);
3579
3580 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
3581 {
3582 RegSetValueExA(hkey, "MS Shell Dlg", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].shelldlg,
3583 strlen(nls_update_font_list[i].shelldlg)+1);
3584 RegSetValueExA(hkey, "Tms Rmn", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].tmsrmn,
3585 strlen(nls_update_font_list[i].tmsrmn)+1);
3586
3587 set_value_key(hkey, "Fixedsys,0", nls_update_font_list[i].fixed_0);
3588 set_value_key(hkey, "System,0", nls_update_font_list[i].system_0);
3589 set_value_key(hkey, "Courier,0", nls_update_font_list[i].courier_0);
3590 set_value_key(hkey, "MS Serif,0", nls_update_font_list[i].serif_0);
3591 set_value_key(hkey, "Small Fonts,0", nls_update_font_list[i].small_0);
3592 set_value_key(hkey, "MS Sans Serif,0", nls_update_font_list[i].sserif_0);
3593 set_value_key(hkey, "Helv,0", nls_update_font_list[i].helv_0);
3594 set_value_key(hkey, "Tms Rmn,0", nls_update_font_list[i].tmsrmn_0);
3595
3596 set_value_key(hkey, nls_update_font_list[i].arial_0.from, nls_update_font_list[i].arial_0.to);
3597 set_value_key(hkey, nls_update_font_list[i].courier_new_0.from, nls_update_font_list[i].courier_new_0.to);
3598 set_value_key(hkey, nls_update_font_list[i].times_new_roman_0.from, nls_update_font_list[i].times_new_roman_0.to);
3599
3600 RegCloseKey(hkey);
3601 }
3602 done = TRUE;
3603 }
3604 else
3605 {
3606 /* Delete the FontSubstitutes from other locales */
3607 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
3608 {
3609 set_value_key(hkey, nls_update_font_list[i].arial_0.from, NULL);
3610 set_value_key(hkey, nls_update_font_list[i].courier_new_0.from, NULL);
3611 set_value_key(hkey, nls_update_font_list[i].times_new_roman_0.from, NULL);
3612 RegCloseKey(hkey);
3613 }
3614 }
3615 }
3616 if (!done)
3617 FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp, oem_cp);
3618 }
3619
3620 static BOOL init_freetype(void)
3621 {
3622 ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
3623 if(!ft_handle) {
3624 WINE_MESSAGE(
3625 "Wine cannot find the FreeType font library. To enable Wine to\n"
3626 "use TrueType fonts please install a version of FreeType greater than\n"
3627 "or equal to 2.0.5.\n"
3628 "http://www.freetype.org\n");
3629 return FALSE;
3630 }
3631
3632 #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;}
3633
3634 LOAD_FUNCPTR(FT_Done_Face)
3635 LOAD_FUNCPTR(FT_Get_Char_Index)
3636 LOAD_FUNCPTR(FT_Get_First_Char)
3637 LOAD_FUNCPTR(FT_Get_Module)
3638 LOAD_FUNCPTR(FT_Get_Next_Char)
3639 LOAD_FUNCPTR(FT_Get_Sfnt_Name)
3640 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
3641 LOAD_FUNCPTR(FT_Get_Sfnt_Table)
3642 LOAD_FUNCPTR(FT_Get_WinFNT_Header)
3643 LOAD_FUNCPTR(FT_Init_FreeType)
3644 LOAD_FUNCPTR(FT_Library_Version)
3645 LOAD_FUNCPTR(FT_Load_Glyph)
3646 LOAD_FUNCPTR(FT_Load_Sfnt_Table)
3647 LOAD_FUNCPTR(FT_Matrix_Multiply)
3648 #ifndef FT_MULFIX_INLINED
3649 LOAD_FUNCPTR(FT_MulFix)
3650 #endif
3651 LOAD_FUNCPTR(FT_New_Face)
3652 LOAD_FUNCPTR(FT_New_Memory_Face)
3653 LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
3654 LOAD_FUNCPTR(FT_Outline_Transform)
3655 LOAD_FUNCPTR(FT_Outline_Translate)
3656 LOAD_FUNCPTR(FT_Render_Glyph)
3657 LOAD_FUNCPTR(FT_Select_Charmap)
3658 LOAD_FUNCPTR(FT_Set_Charmap)
3659 LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
3660 LOAD_FUNCPTR(FT_Vector_Transform)
3661 LOAD_FUNCPTR(FT_Vector_Unit)
3662 #undef LOAD_FUNCPTR
3663 /* Don't warn if these ones are missing */
3664 pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
3665 #ifdef HAVE_FREETYPE_FTLCDFIL_H
3666 pFT_Library_SetLcdFilter = wine_dlsym(ft_handle, "FT_Library_SetLcdFilter", NULL, 0);
3667 #endif
3668
3669 if(pFT_Init_FreeType(&library) != 0) {
3670 ERR("Can't init FreeType library\n");
3671 wine_dlclose(ft_handle, NULL, 0);
3672 ft_handle = NULL;
3673 return FALSE;
3674 }
3675 pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
3676
3677 TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
3678 FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
3679 ((FT_Version.minor << 8) & 0x00ff00) |
3680 ((FT_Version.patch ) & 0x0000ff);
3681
3682 font_driver = &freetype_funcs;
3683 return TRUE;
3684
3685 sym_not_found:
3686 WINE_MESSAGE(
3687 "Wine cannot find certain functions that it needs inside the FreeType\n"
3688 "font library. To enable Wine to use TrueType fonts please upgrade\n"
3689 "FreeType to at least version 2.1.4.\n"
3690 "http://www.freetype.org\n");
3691 wine_dlclose(ft_handle, NULL, 0);
3692 ft_handle = NULL;
3693 return FALSE;
3694 }
3695
3696 static void init_font_list(void)
3697 {
3698 static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
3699 static const WCHAR pathW[] = {'P','a','t','h',0};
3700 HKEY hkey;
3701 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
3702 WCHAR windowsdir[MAX_PATH];
3703 char *unixname;
3704 const char *data_dir;
3705
3706 delete_external_font_keys();
3707
3708 /* load the system bitmap fonts */
3709 load_system_fonts();
3710
3711 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
3712 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
3713 strcatW(windowsdir, fontsW);
3714 if((unixname = wine_get_unix_file_name(windowsdir)))
3715 {
3716 ReadFontDir(unixname, FALSE);
3717 HeapFree(GetProcessHeap(), 0, unixname);
3718 }
3719
3720 /* load the system truetype fonts */
3721 data_dir = wine_get_data_dir();
3722 if (!data_dir) data_dir = wine_get_build_dir();
3723 if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/"))))
3724 {
3725 strcpy(unixname, data_dir);
3726 strcat(unixname, "/fonts/");
3727 ReadFontDir(unixname, TRUE);
3728 HeapFree(GetProcessHeap(), 0, unixname);
3729 }
3730
3731 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
3732 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
3733 full path as the entry. Also look for any .fon fonts, since ReadFontDir
3734 will skip these. */
3735 if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
3736 is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
3737 &hkey) == ERROR_SUCCESS)
3738 {
3739 LPWSTR data, valueW;
3740 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3741 &valuelen, &datalen, NULL, NULL);
3742
3743 valuelen++; /* returned value doesn't include room for '\0' */
3744 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
3745 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
3746 if (valueW && data)
3747 {
3748 dlen = datalen * sizeof(WCHAR);
3749 vlen = valuelen;
3750 while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, (LPBYTE)data,
3751 &dlen) == ERROR_SUCCESS)
3752 {
3753 if(data[0] && (data[1] == ':'))
3754 {
3755 if((unixname = wine_get_unix_file_name(data)))
3756 {
3757 AddFontToList(unixname, NULL, 0, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_TO_CACHE);
3758 HeapFree(GetProcessHeap(), 0, unixname);
3759 }
3760 }
3761 else if(dlen / 2 >= 6 && !strcmpiW(data + dlen / 2 - 5, dot_fonW))
3762 {
3763 WCHAR pathW[MAX_PATH];
3764 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
3765 BOOL added = FALSE;
3766
3767 sprintfW(pathW, fmtW, windowsdir, data);
3768 if((unixname = wine_get_unix_file_name(pathW)))
3769 {
3770 added = AddFontToList(unixname, NULL, 0, ADDFONT_ALLOW_BITMAP | ADDFONT_ADD_TO_CACHE);
3771 HeapFree(GetProcessHeap(), 0, unixname);
3772 }
3773 if (!added)
3774 load_font_from_data_dir(data);
3775 }
3776 /* reset dlen and vlen */
3777 dlen = datalen;
3778 vlen = valuelen;
3779 }
3780 }
3781 HeapFree(GetProcessHeap(), 0, data);
3782 HeapFree(GetProcessHeap(), 0, valueW);
3783 RegCloseKey(hkey);
3784 }
3785
3786 #ifdef SONAME_LIBFONTCONFIG
3787 load_fontconfig_fonts();
3788 #elif defined(HAVE_CARBON_CARBON_H)
3789 load_mac_fonts();
3790 #endif
3791
3792 /* then look in any directories that we've specified in the config file */
3793 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
3794 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
3795 {
3796 DWORD len;
3797 LPWSTR valueW;
3798 LPSTR valueA, ptr;
3799
3800 if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
3801 {
3802 len += sizeof(WCHAR);
3803 valueW = HeapAlloc( GetProcessHeap(), 0, len );
3804 if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
3805 {
3806 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
3807 valueA = HeapAlloc( GetProcessHeap(), 0, len );
3808 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
3809 TRACE( "got font path %s\n", debugstr_a(valueA) );
3810 ptr = valueA;
3811 while (ptr)
3812 {
3813 const char* home;
3814 LPSTR next = strchr( ptr, ':' );
3815 if (next) *next++ = 0;
3816 if (ptr[0] == '~' && ptr[1] == '/' && (home = getenv( "HOME" )) &&
3817 (unixname = HeapAlloc( GetProcessHeap(), 0, strlen(ptr) + strlen(home) )))
3818 {
3819 strcpy( unixname, home );
3820 strcat( unixname, ptr + 1 );
3821 ReadFontDir( unixname, TRUE );
3822 HeapFree( GetProcessHeap(), 0, unixname );
3823 }
3824 else
3825 ReadFontDir( ptr, TRUE );
3826 ptr = next;
3827 }
3828 HeapFree( GetProcessHeap(), 0, valueA );
3829 }
3830 HeapFree( GetProcessHeap(), 0, valueW );
3831 }
3832 RegCloseKey(hkey);
3833 }
3834 }
3835
3836 static BOOL move_to_front(const WCHAR *name)
3837 {
3838 Family *family, *cursor2;
3839 LIST_FOR_EACH_ENTRY_SAFE(family, cursor2, &font_list, Family, entry)
3840 {
3841 if(!strcmpiW(family->FamilyName, name))
3842 {
3843 list_remove(&family->entry);
3844 list_add_head(&font_list, &family->entry);
3845 return TRUE;
3846 }
3847 }
3848 return FALSE;
3849 }
3850
3851 static BOOL set_default(const WCHAR **name_list)
3852 {
3853 while (*name_list)
3854 {
3855 if (move_to_front(*name_list)) return TRUE;
3856 name_list++;
3857 }
3858
3859 return FALSE;
3860 }
3861
3862 static void reorder_font_list(void)
3863 {
3864 set_default( default_serif_list );
3865 set_default( default_fixed_list );
3866 set_default( default_sans_list );
3867 }
3868
3869 /*************************************************************
3870 * WineEngInit
3871 *
3872 * Initialize FreeType library and create a list of available faces
3873 */
3874 BOOL WineEngInit(void)
3875 {
3876 DWORD disposition;
3877 HANDLE font_mutex;
3878
3879 /* update locale dependent font info in registry */
3880 update_font_info();
3881
3882 if(!init_freetype()) return FALSE;
3883
3884 #ifdef SONAME_LIBFONTCONFIG
3885 init_fontconfig();
3886 #endif
3887
3888 if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL)
3889 {
3890 ERR("Failed to create font mutex\n");
3891 return FALSE;
3892 }
3893 WaitForSingleObject(font_mutex, INFINITE);
3894
3895 create_font_cache_key(&hkey_font_cache, &disposition);
3896
3897 if(disposition == REG_CREATED_NEW_KEY)
3898 init_font_list();
3899 else
3900 load_font_list_from_cache(hkey_font_cache);
3901
3902 reorder_font_list();
3903
3904 DumpFontList();
3905 LoadSubstList();
3906 DumpSubstList();
3907 LoadReplaceList();
3908
3909 if(disposition == REG_CREATED_NEW_KEY)
3910 update_reg_entries();
3911
3912 init_system_links();
3913
3914 ReleaseMutex(font_mutex);
3915 return TRUE;
3916 }
3917
3918
3919 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
3920 {
3921 TT_OS2 *pOS2;
3922 TT_HoriHeader *pHori;
3923
3924 LONG ppem;
3925
3926 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
3927 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
3928
3929 if(height == 0) height = 16;
3930
3931 /* Calc. height of EM square:
3932 *
3933 * For +ve lfHeight we have
3934 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
3935 * Re-arranging gives:
3936 * ppem = units_per_em * lfheight / (winAscent + winDescent)
3937 *
3938 * For -ve lfHeight we have
3939 * |lfHeight| = ppem
3940 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
3941 * with il = winAscent + winDescent - units_per_em]
3942 *
3943 */
3944
3945 if(height > 0) {
3946 if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
3947 ppem = MulDiv(ft_face->units_per_EM, height,
3948 pHori->Ascender - pHori->Descender);
3949 else
3950 ppem = MulDiv(ft_face->units_per_EM, height,
3951 pOS2->usWinAscent + pOS2->usWinDescent);
3952 }
3953 else
3954 ppem = -height;
3955
3956 return ppem;
3957 }
3958
3959 static struct font_mapping *map_font_file( const char *name )
3960 {
3961 struct font_mapping *mapping;
3962 struct stat st;
3963 int fd;
3964
3965 if ((fd = open( name, O_RDONLY )) == -1) return NULL;
3966 if (fstat( fd, &st ) == -1) goto error;
3967
3968 LIST_FOR_EACH_ENTRY( mapping, &mappings_list, struct font_mapping, entry )
3969 {
3970 if (mapping->dev == st.st_dev && mapping->ino == st.st_ino)
3971 {
3972 mapping->refcount++;
3973 close( fd );
3974 return mapping;
3975 }
3976 }
3977 if (!(mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping) )))
3978 goto error;
3979
3980 mapping->data = mmap( NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );
3981 close( fd );
3982
3983 if (mapping->data == MAP_FAILED)
3984 {
3985 HeapFree( GetProcessHeap(), 0, mapping );
3986 return NULL;
3987 }
3988 mapping->refcount = 1;
3989 mapping->dev = st.st_dev;
3990 mapping->ino = st.st_ino;
3991 mapping->size = st.st_size;
3992 list_add_tail( &mappings_list, &mapping->entry );
3993 return mapping;
3994
3995 error:
3996 close( fd );
3997 return NULL;
3998 }
3999
4000 static void unmap_font_file( struct font_mapping *mapping )
4001 {
4002 if (!--mapping->refcount)
4003 {
4004 list_remove( &mapping->entry );
4005 munmap( mapping->data, mapping->size );
4006 HeapFree( GetProcessHeap(), 0, mapping );
4007 }
4008 }
4009
4010 static LONG load_VDMX(GdiFont*, LONG);
4011
4012 static FT_Face OpenFontFace(GdiFont *font, Face *face, LONG width, LONG height)
4013 {
4014 FT_Error err;
4015 FT_Face ft_face;
4016 void *data_ptr;
4017 DWORD data_size;
4018
4019 TRACE("%s/%p, %ld, %d x %d\n", debugstr_w(face->file), face->font_data_ptr, face->face_index, width, height);
4020
4021 if (face->file)
4022 {
4023 char *filename = strWtoA( CP_UNIXCP, face->file );
4024 font->mapping = map_font_file( filename );
4025 HeapFree( GetProcessHeap(), 0, filename );
4026 if (!font->mapping)
4027 {
4028 WARN("failed to map %s\n", debugstr_w(face->file));
4029 return 0;
4030 }
4031 data_ptr = font->mapping->data;
4032 data_size = font->mapping->size;
4033 }
4034 else
4035 {
4036 data_ptr = face->font_data_ptr;
4037 data_size = face->font_data_size;
4038 }
4039
4040 err = pFT_New_Memory_Face(library, data_ptr, data_size, face->face_index, &ft_face);
4041 if(err) {
4042 ERR("FT_New_Face rets %d\n", err);
4043 return 0;
4044 }
4045
4046 /* set it here, as load_VDMX needs it */
4047 font->ft_face = ft_face;
4048
4049 if(FT_IS_SCALABLE(ft_face)) {
4050 /* load the VDMX table if we have one */
4051 font->ppem = load_VDMX(font, height);
4052 if(font->ppem == 0)
4053 font->ppem = calc_ppem_for_height(ft_face, height);
4054 TRACE("height %d => ppem %d\n", height, font->ppem);
4055
4056 if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
4057 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font->ppem, err);
4058 } else {
4059 font->ppem = height;
4060 if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
4061 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width, height, err);
4062 }
4063 return ft_face;
4064 }
4065
4066
4067 static int get_nearest_charset(const WCHAR *family_name, Face *face, int *cp)
4068 {
4069 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
4070 a single face with the requested charset. The idea is to check if
4071 the selected font supports the current ANSI codepage, if it does
4072 return the corresponding charset, else return the first charset */
4073
4074 CHARSETINFO csi;
4075 int acp = GetACP(), i;
4076 DWORD fs0;
4077
4078 *cp = acp;
4079 if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
4080 {
4081 const SYSTEM_LINKS *font_link;
4082
4083 if (csi.fs.fsCsb[0] & face->fs.fsCsb[0])
4084 return csi.ciCharset;
4085
4086 font_link = find_font_link(family_name);
4087 if (font_link != NULL && csi.fs.fsCsb[0] & font_link->fs.fsCsb[0])
4088 return csi.ciCharset;
4089 }
4090
4091 for(i = 0; i < 32; i++) {
4092 fs0 = 1L << i;
4093 if(face->fs.fsCsb[0] & fs0) {
4094 if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
4095 *cp = csi.ciACP;
4096 return csi.ciCharset;
4097 }
4098 else
4099 FIXME("TCI failing on %x\n", fs0);
4100 }
4101 }
4102
4103 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
4104 face->fs.fsCsb[0], debugstr_w(face->file));
4105 *cp = acp;
4106 return DEFAULT_CHARSET;
4107 }
4108
4109 static GdiFont *alloc_font(void)
4110 {
4111 GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
4112 ret->refcount = 1;
4113 ret->gmsize = 1;
4114 ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM*));
4115 ret->gm[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
4116 ret->potm = NULL;
4117 ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
4118 ret->total_kern_pairs = (DWORD)-1;
4119 ret->kern_pairs = NULL;
4120 list_init(&ret->child_fonts);
4121 return ret;
4122 }
4123
4124 static void free_font(GdiFont *font)
4125 {
4126 CHILD_FONT *child, *child_next;
4127 DWORD i;
4128
4129 LIST_FOR_EACH_ENTRY_SAFE( child, child_next, &font->child_fonts, CHILD_FONT, entry )
4130 {
4131 list_remove(&child->entry);
4132 if(child->font)
4133 free_font(child->font);
4134 release_face( child->face );
4135 HeapFree(GetProcessHeap(), 0, child);
4136 }
4137
4138 if (font->ft_face) pFT_Done_Face(font->ft_face);
4139 if (font->mapping) unmap_font_file( font->mapping );
4140 HeapFree(GetProcessHeap(), 0, font->kern_pairs);
4141 HeapFree(GetProcessHeap(), 0, font->potm);
4142 HeapFree(GetProcessHeap(), 0, font->name);
4143 for (i = 0; i < font->gmsize; i++)
4144 HeapFree(GetProcessHeap(),0,font->gm[i]);
4145 HeapFree(GetProcessHeap(), 0, font->gm);
4146 HeapFree(GetProcessHeap(), 0, font->GSUB_Table);
4147 HeapFree(GetProcessHeap(), 0, font);
4148 }
4149
4150
4151 static DWORD get_font_data( GdiFont *font, DWORD table, DWORD offset, LPVOID buf, DWORD cbData)
4152 {
4153 FT_Face ft_face = font->ft_face;
4154 FT_ULong len;
4155 FT_Error err;
4156
4157 if (!FT_IS_SFNT(ft_face)) return GDI_ERROR;
4158
4159 if(!buf)
4160 len = 0;
4161 else
4162 len = cbData;
4163
4164 table = RtlUlongByteSwap( table ); /* MS tags differ in endianness from FT ones */
4165
4166 /* make sure value of len is the value freetype says it needs */
4167 if (buf && len)
4168 {
4169 FT_ULong needed = 0;
4170 err = pFT_Load_Sfnt_Table(ft_face, table, offset, NULL, &needed);
4171 if( !err && needed < len) len = needed;
4172 }
4173 err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, &len);
4174 if (err)
4175 {
4176 TRACE("Can't find table %c%c%c%c\n",
4177 /* bytes were reversed */
4178 HIBYTE(HIWORD(table)), LOBYTE(HIWORD(table)),
4179 HIBYTE(LOWORD(table)), LOBYTE(LOWORD(table)));
4180 return GDI_ERROR;
4181 }
4182 return len;
4183 }
4184
4185 /*************************************************************
4186 * load_VDMX
4187 *
4188 * load the vdmx entry for the specified height
4189 */
4190
4191 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
4192 ( ( (FT_ULong)_x4 << 24 ) | \
4193 ( (FT_ULong)_x3 << 16 ) | \
4194 ( (FT_ULong)_x2 << 8 ) | \
4195 (FT_ULong)_x1 )
4196
4197 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
4198
4199 typedef struct {
4200 BYTE bCharSet;
4201 BYTE xRatio;
4202 BYTE yStartRatio;
4203 BYTE yEndRatio;
4204 } Ratios;
4205
4206 typedef struct {
4207 WORD recs;
4208 BYTE startsz;
4209 BYTE endsz;
4210 } VDMX_group;
4211
4212 static LONG load_VDMX(GdiFont *font, LONG height)
4213 {
4214 WORD hdr[3], tmp;
4215 VDMX_group group;
4216 BYTE devXRatio, devYRatio;
4217 USHORT numRecs, numRatios;
4218 DWORD result, offset = -1;
4219 LONG ppem = 0;
4220 int i;
4221
4222 result = get_font_data(font, MS_VDMX_TAG, 0, hdr, 6);
4223
4224 if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
4225 return ppem;
4226
4227 /* FIXME: need the real device aspect ratio */
4228 devXRatio = 1;
4229 devYRatio = 1;
4230
4231 numRecs = GET_BE_WORD(hdr[1]);
4232 numRatios = GET_BE_WORD(hdr[2]);
4233
4234 TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
4235 for(i = 0; i < numRatios; i++) {
4236 Ratios ratio;
4237
4238 offset = (3 * 2) + (i * sizeof(Ratios));
4239 get_font_data(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
4240 offset = -1;
4241
4242 TRACE("Ratios[%d] %d %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
4243
4244 if((ratio.xRatio == 0 &&
4245 ratio.yStartRatio == 0 &&
4246 ratio.yEndRatio == 0) ||
4247 (devXRatio == ratio.xRatio &&
4248 devYRatio >= ratio.yStartRatio &&
4249 devYRatio <= ratio.yEndRatio))
4250 {
4251 offset = (3 * 2) + (numRatios * 4) + (i * 2);
4252 get_font_data(font, MS_VDMX_TAG, offset, &tmp, 2);
4253 offset = GET_BE_WORD(tmp);
4254 break;
4255 }
4256 }
4257
4258 if(offset == -1) {
4259 FIXME("No suitable ratio found\n");
4260 return ppem;
4261 }
4262
4263 if(get_font_data(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
4264 USHORT recs;
4265 BYTE startsz, endsz;
4266 WORD *vTable;
4267
4268 recs = GET_BE_WORD(group.recs);
4269 startsz = group.startsz;
4270 endsz = group.endsz;
4271
4272 TRACE("recs=%d startsz=%d endsz=%d\n", recs, startsz, endsz);
4273
4274 vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
4275 result = get_font_data(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
4276 if(result == GDI_ERROR) {
4277 FIXME("Failed to retrieve vTable\n");
4278 goto end;
4279 }
4280
4281 if(height > 0) {
4282 for(i = 0; i < recs; i++) {
4283 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
4284 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
4285 ppem = GET_BE_WORD(vTable[i * 3]);
4286
4287 if(yMax + -yMin == height) {
4288 font->yMax = yMax;
4289 font->yMin = yMin;
4290 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
4291 break;
4292 }
4293 if(yMax + -yMin > height) {
4294 if(--i < 0) {
4295 ppem = 0;
4296 goto end; /* failed */
4297 }
4298 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
4299 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
4300 ppem = GET_BE_WORD(vTable[i * 3]);
4301 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
4302 break;
4303 }
4304 }
4305 if(!font->yMax) {
4306 ppem = 0;
4307 TRACE("ppem not found for height %d\n", height);
4308 }
4309 }
4310 end:
4311 HeapFree(GetProcessHeap(), 0, vTable);
4312 }
4313
4314 return ppem;
4315 }
4316
4317 static void dump_gdi_font_list(void)
4318 {
4319 GdiFont *font;
4320
4321 TRACE("---------- Font Cache ----------\n");
4322 LIST_FOR_EACH_ENTRY( font, &gdi_font_list, struct tagGdiFont, entry )
4323 TRACE("font=%p ref=%u %s %d\n", font, font->refcount,
4324 debugstr_w(font->font_desc.lf.lfFaceName), font->font_desc.lf.lfHeight);
4325 }
4326
4327 static void grab_font( GdiFont *font )
4328 {
4329 if (!font->refcount++)
4330 {
4331 list_remove( &font->unused_entry );
4332 unused_font_count--;
4333 }
4334 }
4335
4336 static void release_font( GdiFont *font )
4337 {
4338 if (!font) return;
4339 if (!--font->refcount)
4340 {
4341 TRACE( "font %p\n", font );
4342
4343 /* add it to the unused list */
4344 list_add_head( &unused_gdi_font_list, &font->unused_entry );
4345 if (unused_font_count > UNUSED_CACHE_SIZE)
4346 {
4347 font = LIST_ENTRY( list_tail( &unused_gdi_font_list ), struct tagGdiFont, unused_entry );
4348 TRACE( "freeing %p\n", font );
4349 list_remove( &font->entry );
4350 list_remove( &font->unused_entry );
4351 free_font( font );
4352 }
4353 else unused_font_count++;
4354
4355 if (TRACE_ON(font)) dump_gdi_font_list();
4356 }
4357 }
4358
4359 static BOOL fontcmp(const GdiFont *font, FONT_DESC *fd)
4360 {
4361 if(font->font_desc.hash != fd->hash) return TRUE;
4362 if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
4363 if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
4364 if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
4365 return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
4366 }
4367
4368 static void calc_hash(FONT_DESC *pfd)
4369 {
4370 DWORD hash = 0, *ptr, two_chars;
4371 WORD *pwc;
4372 unsigned int i;
4373
4374 for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
4375 hash ^= *ptr;
4376 for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
4377 hash ^= *ptr;
4378 for(i = 0, ptr = (DWORD*)pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
4379 two_chars = *ptr;
4380 pwc = (WCHAR *)&two_chars;
4381 if(!*pwc) break;
4382 *pwc = toupperW(*pwc);
4383 pwc++;
4384 *pwc = toupperW(*pwc);
4385 hash ^= two_chars;
4386 if(!*pwc) break;
4387 }
4388 hash ^= !pfd->can_use_bitmap;
4389 pfd->hash = hash;
4390 return;
4391 }
4392
4393 static GdiFont *find_in_cache(HFONT hfont, const LOGFONTW *plf, const FMAT2 *pmat, BOOL can_use_bitmap)
4394 {
4395 GdiFont *ret;
4396 FONT_DESC fd;
4397
4398 fd.lf = *plf;
4399 fd.matrix = *pmat;
4400 fd.can_use_bitmap = can_use_bitmap;
4401 calc_hash(&fd);
4402
4403 /* try the in-use list */
4404 LIST_FOR_EACH_ENTRY( ret, &gdi_font_list, struct tagGdiFont, entry )
4405 {
4406 if(fontcmp(ret, &fd)) continue;
4407 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
4408 list_remove( &ret->entry );
4409 list_add_head( &gdi_font_list, &ret->entry );
4410 grab_font( ret );
4411 return ret;
4412 }
4413 return NULL;
4414 }
4415
4416 static void add_to_cache(GdiFont *font)
4417 {
4418 static DWORD cache_num = 1;
4419
4420 font->cache_num = cache_num++;
4421 list_add_head(&gdi_font_list, &font->entry);
4422 TRACE( "font %p\n", font );
4423 }
4424
4425 /*************************************************************
4426 * create_child_font_list
4427 */
4428 static BOOL create_child_font_list(GdiFont *font)
4429 {
4430 BOOL ret = FALSE;
4431 SYSTEM_LINKS *font_link;
4432 CHILD_FONT *font_link_entry, *new_child;
4433 FontSubst *psub;
4434 WCHAR* font_name;
4435
4436 psub = get_font_subst(&font_subst_list, font->name, -1);
4437 font_name = psub ? psub->to.name : font->name;
4438 font_link = find_font_link(font_name);
4439 if (font_link != NULL)
4440 {
4441 TRACE("found entry in system list\n");
4442 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
4443 {
4444 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
4445 new_child->face = font_link_entry->face;
4446 new_child->font = NULL;
4447 new_child->face->refcount++;
4448 list_add_tail(&font->child_fonts, &new_child->entry);
4449 TRACE("font %s %ld\n", debugstr_w(new_child->face->file), new_child->face->face_index);
4450 }
4451 ret = TRUE;
4452 }
4453 /*
4454 * if not SYMBOL or OEM then we also get all the fonts for Microsoft
4455 * Sans Serif. This is how asian windows get default fallbacks for fonts
4456 */
4457 if (use_default_fallback && font->charset != SYMBOL_CHARSET &&
4458 font->charset != OEM_CHARSET &&
4459 strcmpiW(font_name,szDefaultFallbackLink) != 0)
4460 {
4461 font_link = find_font_link(szDefaultFallbackLink);
4462 if (font_link != NULL)
4463 {
4464 TRACE("found entry in default fallback list\n");
4465 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
4466 {
4467 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
4468 new_child->face = font_link_entry->face;
4469 new_child->font = NULL;
4470 new_child->face->refcount++;
4471 list_add_tail(&font->child_fonts, &new_child->entry);
4472 TRACE("font %s %ld\n", debugstr_w(new_child->face->file), new_child->face->face_index);
4473 }
4474 ret = TRUE;
4475 }
4476 }
4477
4478 return ret;
4479 }
4480
4481 static BOOL select_charmap(FT_Face ft_face, FT_Encoding encoding)
4482 {
4483 FT_Error ft_err = FT_Err_Invalid_CharMap_Handle;
4484
4485 if (pFT_Set_Charmap)
4486 {
4487 FT_Int i;
4488 FT_CharMap cmap0, cmap1, cmap2, cmap3, cmap_def;
4489
4490 cmap0 = cmap1 = cmap2 = cmap3 = cmap_def = NULL;
4491
4492 for (i = 0; i < ft_face->num_charmaps; i++)
4493 {
4494 if (ft_face->charmaps[i]->encoding == encoding)
4495 {
4496 TRACE("found cmap with platform_id %u, encoding_id %u\n",
4497 ft_face->charmaps[i]->platform_id, ft_face->charmaps[i]->encoding_id);
4498
4499 switch (ft_face->charmaps[i]->platform_id)
4500 {
4501 default:
4502 cmap_def = ft_face->charmaps[i];
4503 break;
4504 case 0: /* Apple Unicode */
4505 cmap0 = ft_face->charmaps[i];
4506 break;
4507 case 1: /* Macintosh */
4508 cmap1 = ft_face->charmaps[i];
4509 break;
4510 case 2: /* ISO */
4511 cmap2 = ft_face->charmaps[i];
4512 break;
4513 case 3: /* Microsoft */
4514 cmap3 = ft_face->charmaps[i];
4515 break;
4516 }
4517 }
4518
4519 if (cmap3) /* prefer Microsoft cmap table */
4520 ft_err = pFT_Set_Charmap(ft_face, cmap3);
4521 else if (cmap1)
4522 ft_err = pFT_Set_Charmap(ft_face, cmap1);
4523 else if (cmap2)
4524 ft_err = pFT_Set_Charmap(ft_face, cmap2);
4525 else if (cmap0)
4526 ft_err = pFT_Set_Charmap(ft_face, cmap0);
4527 else if (cmap_def)
4528 ft_err = pFT_Set_Charmap(ft_face, cmap_def);
4529 }
4530 return ft_err == FT_Err_Ok;
4531 }
4532
4533 return pFT_Select_Charmap(ft_face, encoding) == FT_Err_Ok;
4534 }
4535
4536
4537 /*************************************************************
4538 * freetype_CreateDC
4539 */
4540 static BOOL freetype_CreateDC( PHYSDEV *dev, LPCWSTR driver, LPCWSTR device,
4541 LPCWSTR output, const DEVMODEW *devmode )
4542 {
4543 struct freetype_physdev *physdev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physdev) );
4544
4545 if (!physdev) return FALSE;
4546 push_dc_driver( dev, &physdev->dev, &freetype_funcs );
4547 return TRUE;
4548 }
4549
4550
4551 /*************************************************************
4552 * freetype_DeleteDC
4553 */
4554 static BOOL freetype_DeleteDC( PHYSDEV dev )
4555 {
4556 struct freetype_physdev *physdev = get_freetype_dev( dev );
4557 release_font( physdev->font );
4558 HeapFree( GetProcessHeap(), 0, physdev );
4559 return TRUE;
4560 }
4561
4562 static FT_Encoding pick_charmap( FT_Face face, int charset )
4563 {
4564 static const FT_Encoding regular_order[] = { FT_ENCODING_UNICODE, FT_ENCODING_APPLE_ROMAN, FT_ENCODING_MS_SYMBOL, 0 };
4565 static const FT_Encoding symbol_order[] = { FT_ENCODING_MS_SYMBOL, FT_ENCODING_UNICODE, FT_ENCODING_APPLE_ROMAN, 0 };
4566 const FT_Encoding *encs = regular_order;
4567
4568 if (charset == SYMBOL_CHARSET) encs = symbol_order;
4569
4570 while (*encs != 0)
4571 {
4572 if (select_charmap( face, *encs )) break;
4573 encs++;
4574 }
4575 return *encs;
4576 }
4577
4578 #define GASP_GRIDFIT 0x01
4579 #define GASP_DOGRAY 0x02
4580 #define GASP_TAG MS_MAKE_TAG('g','a','s','p')
4581
4582 static BOOL get_gasp_flags( GdiFont *font, WORD *flags )
4583 {
4584 DWORD size;
4585 WORD buf[16]; /* Enough for seven ranges before we need to alloc */
4586 WORD *alloced = NULL, *ptr = buf;
4587 WORD num_recs, version;
4588 BOOL ret = FALSE;
4589
4590 *flags = 0;
4591 size = get_font_data( font, GASP_TAG, 0, NULL, 0 );
4592 if (size == GDI_ERROR) return FALSE;
4593 if (size < 4 * sizeof(WORD)) return FALSE;
4594 if (size > sizeof(buf))
4595 {
4596 ptr = alloced = HeapAlloc( GetProcessHeap(), 0, size );
4597 if (!ptr) return FALSE;
4598 }
4599
4600 get_font_data( font, GASP_TAG, 0, ptr, size );
4601
4602 version = GET_BE_WORD( *ptr++ );
4603 num_recs = GET_BE_WORD( *ptr++ );
4604
4605 if (version > 1 || size < (num_recs * 2 + 2) * sizeof(WORD))
4606 {
4607 FIXME( "Unsupported gasp table: ver %d size %d recs %d\n", version, size, num_recs );
4608 goto done;
4609 }
4610
4611 while (num_recs--)
4612 {
4613 *flags = GET_BE_WORD( *(ptr + 1) );
4614 if (font->ft_face->size->metrics.y_ppem <= GET_BE_WORD( *ptr )) break;
4615 ptr += 2;
4616 }
4617 TRACE( "got flags %04x for ppem %d\n", *flags, font->ft_face->size->metrics.y_ppem );
4618 ret = TRUE;
4619
4620 done:
4621 HeapFree( GetProcessHeap(), 0, alloced );
4622 return ret;
4623 }
4624
4625 /*************************************************************
4626 * freetype_SelectFont
4627 */
4628 static HFONT freetype_SelectFont( PHYSDEV dev, HFONT hfont, UINT *aa_flags )
4629 {
4630 struct freetype_physdev *physdev = get_freetype_dev( dev );
4631 GdiFont *ret;
4632 Face *face, *best, *best_bitmap;
4633 Family *family, *last_resort_family;
4634 const struct list *face_list;
4635 INT height, width = 0;
4636 unsigned int score = 0, new_score;
4637 signed int diff = 0, newdiff;
4638 BOOL bd, it, can_use_bitmap, want_vertical;
4639 LOGFONTW lf;
4640 CHARSETINFO csi;
4641 FMAT2 dcmat;
4642 FontSubst *psub = NULL;
4643 DC *dc = get_dc_ptr( dev->hdc );
4644 const SYSTEM_LINKS *font_link;
4645
4646 if (!hfont) /* notification that the font has been changed by another driver */
4647 {
4648 release_font( physdev->font );
4649 physdev->font = NULL;
4650 release_dc_ptr( dc );
4651 return 0;
4652 }
4653
4654 GetObjectW( hfont, sizeof(lf), &lf );
4655 lf.lfWidth = abs(lf.lfWidth);
4656
4657 can_use_bitmap = GetDeviceCaps(dev->hdc, TEXTCAPS) & TC_RA_ABLE;
4658
4659 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
4660 debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
4661 lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
4662 lf.lfEscapement);
4663
4664 if(dc->GraphicsMode == GM_ADVANCED)
4665 {
4666 memcpy(&dcmat, &dc->xformWorld2Vport, sizeof(FMAT2));
4667 /* Try to avoid not necessary glyph transformations */
4668 if (dcmat.eM21 == 0.0 && dcmat.eM12 == 0.0 && dcmat.eM11 == dcmat.eM22)
4669 {
4670 lf.lfHeight *= fabs(dcmat.eM11);
4671 lf.lfWidth *= fabs(dcmat.eM11);
4672 dcmat.eM11 = dcmat.eM22 = dcmat.eM11 < 0 ? -1 : 1;
4673 }
4674 }
4675 else
4676 {
4677 /* Windows 3.1 compatibility mode GM_COMPATIBLE has only limited
4678 font scaling abilities. */
4679 dcmat.eM11 = dcmat.eM22 = 1.0;
4680 dcmat.eM21 = dcmat.eM12 = 0;
4681 lf.lfOrientation = lf.lfEscapement;
4682 if (dc->vport2WorldValid)
4683 {
4684 if (dc->xformWorld2Vport.eM11 * dc->xformWorld2Vport.eM22 < 0)
4685 lf.lfOrientation = -lf.lfOrientation;
4686 lf.lfHeight *= fabs(dc->xformWorld2Vport.eM22);
4687 lf.lfWidth *= fabs(dc->xformWorld2Vport.eM22);
4688 }
4689 }
4690
4691 TRACE("DC transform %f %f %f %f\n", dcmat.eM11, dcmat.eM12,
4692 dcmat.eM21, dcmat.eM22);
4693
4694 GDI_CheckNotLock();
4695 EnterCriticalSection( &freetype_cs );
4696
4697 /* check the cache first */
4698 if((ret = find_in_cache(hfont, &lf, &dcmat, can_use_bitmap)) != NULL) {
4699 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
4700 goto done;
4701 }
4702
4703 TRACE("not in cache\n");
4704 ret = alloc_font();
4705
4706 ret->font_desc.matrix = dcmat;
4707 ret->font_desc.lf = lf;
4708 ret->font_desc.can_use_bitmap = can_use_bitmap;
4709 calc_hash(&ret->font_desc);
4710
4711 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
4712 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
4713 original value lfCharSet. Note this is a special case for
4714 Symbol and doesn't happen at least for "Wingdings*" */
4715
4716 if(!strcmpiW(lf.lfFaceName, SymbolW))
4717 lf.lfCharSet = SYMBOL_CHARSET;
4718
4719 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
4720 switch(lf.lfCharSet) {
4721 case DEFAULT_CHARSET:
4722 csi.fs.fsCsb[0] = 0;
4723 break;
4724 default:
4725 FIXME("Untranslated charset %d\n", lf.lfCharSet);
4726 csi.fs.fsCsb[0] = 0;
4727 break;
4728 }
4729 }
4730
4731 family = NULL;
4732 if(lf.lfFaceName[0] != '\0') {
4733 CHILD_FONT *font_link_entry;
4734 LPWSTR FaceName = lf.lfFaceName;
4735
4736 psub = get_font_subst(&font_subst_list, FaceName, lf.lfCharSet);
4737
4738 if(psub) {
4739 TRACE("substituting %s,%d -> %s,%d\n", debugstr_w(FaceName), lf.lfCharSet,
4740 debugstr_w(psub->to.name), (psub->to.charset != -1) ? psub->to.charset : lf.lfCharSet);
4741 if (psub->to.charset != -1)
4742 lf.lfCharSet = psub->to.charset;
4743 }
4744
4745 /* We want a match on name and charset or just name if
4746 charset was DEFAULT_CHARSET. If the latter then
4747 we fixup the returned charset later in get_nearest_charset
4748 where we'll either use the charset of the current ansi codepage
4749 or if that's unavailable the first charset that the font supports.
4750 */
4751 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
4752 if (!strcmpiW(family->FamilyName, FaceName) ||
4753 (psub && !strcmpiW(family->FamilyName, psub->to.name)))
4754 {
4755 font_link = find_font_link(family->FamilyName);
4756 face_list = get_face_list_from_family(family);
4757 LIST_FOR_EACH_ENTRY( face, face_list, Face, entry ) {
4758 if (!(face->scalable || can_use_bitmap))
4759 continue;
4760 if (csi.fs.fsCsb[0] & face->fs.fsCsb[0])
4761 goto found;
4762 if (font_link != NULL &&
4763 csi.fs.fsCsb[0] & font_link->fs.fsCsb[0])
4764 goto found;
4765 if (!csi.fs.fsCsb[0])
4766 goto found;
4767 }
4768 }
4769 }
4770
4771 /* Search by full face name. */
4772 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
4773 face_list = get_face_list_from_family(family);
4774 LIST_FOR_EACH_ENTRY( face, face_list, Face, entry ) {
4775 if(face->FullName && !strcmpiW(face->FullName, FaceName) &&
4776 (face->scalable || can_use_bitmap))
4777 {
4778 if (csi.fs.fsCsb[0] & face->fs.fsCsb[0] || !csi.fs.fsCsb[0])
4779 goto found_face;
4780 font_link = find_font_link(family->FamilyName);
4781 if (font_link != NULL &&
4782 csi.fs.fsCsb[0] & font_link->fs.fsCsb[0])
4783 goto found_face;
4784 }
4785 }
4786 }
4787
4788 /*
4789 * Try check the SystemLink list first for a replacement font.
4790 * We may find good replacements there.
4791 */
4792 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
4793 {
4794 if(!strcmpiW(font_link->font_name, FaceName) ||
4795 (psub && !strcmpiW(font_link->font_name,psub->to.name)))
4796 {
4797 TRACE("found entry in system list\n");
4798 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
4799 {
4800 const SYSTEM_LINKS *links;
4801
4802 face = font_link_entry->face;
4803 if (!(face->scalable || can_use_bitmap))
4804 continue;
4805 family = face->family;
4806 if (csi.fs.fsCsb[0] & face->fs.fsCsb[0] || !csi.fs.fsCsb[0])
4807 goto found;
4808 links = find_font_link(family->FamilyName);
4809 if (links != NULL && csi.fs.fsCsb[0] & links->fs.fsCsb[0])
4810 goto found;
4811 }
4812 }
4813 }
4814 }
4815
4816 psub = NULL; /* substitution is no more relevant */
4817
4818 /* If requested charset was DEFAULT_CHARSET then try using charset
4819 corresponding to the current ansi codepage */
4820 if (!csi.fs.fsCsb[0])
4821 {
4822 INT acp = GetACP();
4823 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
4824 FIXME("TCI failed on codepage %d\n", acp);
4825 csi.fs.fsCsb[0] = 0;
4826 } else
4827 lf.lfCharSet = csi.ciCharset;
4828 }
4829
4830 want_vertical = (lf.lfFaceName[0] == '@');
4831
4832 /* Face families are in the top 4 bits of lfPitchAndFamily,
4833 so mask with 0xF0 before testing */
4834
4835 if((lf.lfPitchAndFamily & FIXED_PITCH) ||
4836 (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
4837 strcpyW(lf.lfFaceName, defFixed);
4838 else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
4839 strcpyW(lf.lfFaceName, defSerif);
4840 else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
4841 strcpyW(lf.lfFaceName, defSans);
4842 else
4843 strcpyW(lf.lfFaceName, defSans);
4844 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
4845 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
4846 font_link = find_font_link(family->FamilyName);
4847 face_list = get_face_list_from_family(family);
4848 LIST_FOR_EACH_ENTRY( face, face_list, Face, entry ) {
4849 if (!(face->scalable || can_use_bitmap))
4850 continue;
4851 if (csi.fs.fsCsb[0] & face->fs.fsCsb[0])
4852 goto found;
4853 if (font_link != NULL && csi.fs.fsCsb[0] & font_link->fs.fsCsb[0])
4854 goto found;
4855 }
4856 }
4857 }
4858
4859 last_resort_family = NULL;
4860 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
4861 font_link = find_font_link(family->FamilyName);
4862 face_list = get_face_list_from_family(family);
4863 LIST_FOR_EACH_ENTRY( face, face_list, Face, entry ) {
4864 if(!(face->flags & ADDFONT_VERTICAL_FONT) == !want_vertical &&
4865 (csi.fs.fsCsb[0] & face->fs.fsCsb[0] ||
4866 (font_link != NULL && csi.fs.fsCsb[0] & font_link->fs.fsCsb[0]))) {
4867 if(face->scalable)
4868 goto found;
4869 if(can_use_bitmap && !last_resort_family)
4870 last_resort_family = family;
4871 }
4872 }
4873 }
4874
4875 if(last_resort_family) {
4876 family = last_resort_family;
4877 csi.fs.fsCsb[0] = 0;
4878 goto found;
4879 }
4880
4881 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
4882 face_list = get_face_list_from_family(family);
4883 LIST_FOR_EACH_ENTRY( face, face_list, Face, entry ) {
4884 if(face->scalable && !(face->flags & ADDFONT_VERTICAL_FONT) == !want_vertical) {
4885 csi.fs.fsCsb[0] = 0;
4886 WARN("just using first face for now\n");
4887 goto found;
4888 }
4889 if(can_use_bitmap && !last_resort_family)
4890 last_resort_family = family;
4891 }
4892 }
4893 if(!last_resort_family) {
4894 FIXME("can't find a single appropriate font - bailing\n");
4895 free_font(ret);
4896 ret = NULL;
4897 goto done;
4898 }
4899
4900 WARN("could only find a bitmap font - this will probably look awful!\n");
4901 family = last_resort_family;
4902 csi.fs.fsCsb[0] = 0;
4903
4904 found:
4905 it = lf.lfItalic ? 1 : 0;
4906 bd = lf.lfWeight > 550 ? 1 : 0;
4907
4908 height = lf.lfHeight;
4909
4910 face = best = best_bitmap = NULL;
4911 font_link = find_font_link(family->FamilyName);
4912 face_list = get_face_list_from_family(family);
4913 LIST_FOR_EACH_ENTRY(face, face_list, Face, entry)
4914 {
4915 if (csi.fs.fsCsb[0] & face->fs.fsCsb[0] ||
4916 (font_link != NULL && csi.fs.fsCsb[0] & font_link->fs.fsCsb[0]) ||
4917 !csi.fs.fsCsb[0])
4918 {
4919 BOOL italic, bold;
4920
4921 italic = (face->ntmFlags & NTM_ITALIC) ? 1 : 0;
4922 bold = (face->ntmFlags & NTM_BOLD) ? 1 : 0;
4923 new_score = (italic ^ it) + (bold ^ bd);
4924 if(!best || new_score <= score)
4925 {
4926 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
4927 italic, bold, it, bd);
4928 score = new_score;
4929 best = face;
4930 if(best->scalable && score == 0) break;
4931 if(!best->scalable)
4932 {
4933 if(height > 0)
4934 newdiff = height - (signed int)(best->size.height);
4935 else
4936 newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
4937 if(!best_bitmap || new_score < score ||
4938 (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
4939 {
4940 TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
4941 diff = newdiff;
4942 best_bitmap = best;
4943 if(score == 0 && diff == 0) break;
4944 }
4945 }
4946 }
4947 }
4948 }
4949 if(best)
4950 face = best->scalable ? best : best_bitmap;
4951 ret->fake_italic = (it && !(face->ntmFlags & NTM_ITALIC));
4952 ret->fake_bold = (bd && !(face->ntmFlags & NTM_BOLD));
4953
4954 found_face:
4955 height = lf.lfHeight;
4956
4957 ret->fs = face->fs;
4958
4959 if(csi.fs.fsCsb[0]) {
4960 ret->charset = lf.lfCharSet;
4961 ret->codepage = csi.ciACP;
4962 }
4963 else
4964 ret->charset = get_nearest_charset(family->FamilyName, face, &ret->codepage);
4965
4966 TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family->FamilyName),
4967 debugstr_w(face->StyleName), debugstr_w(face->file), face->font_data_ptr, face->face_index);
4968
4969 ret->aveWidth = height ? lf.lfWidth : 0;
4970
4971 if(!face->scalable) {
4972 /* Windows uses integer scaling factors for bitmap fonts */
4973 INT scale, scaled_height;
4974 GdiFont *cachedfont;
4975
4976 /* FIXME: rotation of bitmap fonts is ignored */
4977 height = abs(GDI_ROUND( (double)height * ret->font_desc.matrix.eM22 ));
4978 if (ret->aveWidth)
4979 ret->aveWidth = (double)ret->aveWidth * ret->font_desc.matrix.eM11;
4980 ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
4981 dcmat.eM11 = dcmat.eM22 = 1.0;
4982 /* As we changed the matrix, we need to search the cache for the font again,
4983 * otherwise we might explode the cache. */
4984 if((cachedfont = find_in_cache(hfont, &lf, &dcmat, can_use_bitmap)) != NULL) {
4985 TRACE("Found cached font after non-scalable matrix rescale!\n");
4986 free_font( ret );
4987 ret = cachedfont;
4988 goto done;
4989 }
4990 calc_hash(&ret->font_desc);
4991
4992 if (height != 0) height = diff;
4993 height += face->size.height;
4994
4995 scale = (height + face->size.height - 1) / face->size.height;
4996 scaled_height = scale * face->size.height;
4997 /* Only jump to the next height if the difference <= 25% original height */
4998 if (scale > 2 && scaled_height - height > face->size.height / 4) scale--;
4999 /* The jump between unscaled and doubled is delayed by 1 */
5000 else if (scale == 2 && scaled_height - height > (face->size.height / 4 - 1)) scale--;
5001 ret->scale_y = scale;
5002
5003 width = face->size.x_ppem >> 6;
5004 height = face->size.y_ppem >> 6;
5005 }
5006 else
5007 ret->scale_y = 1.0;
5008 TRACE("font scale y: %f\n", ret->scale_y);
5009
5010 ret->ft_face = OpenFontFace(ret, face, width, height);
5011
5012 if (!ret->ft_face)
5013 {
5014 free_font( ret );
5015 ret = NULL;
5016 goto done;
5017 }
5018
5019 ret->ntmFlags = face->ntmFlags;
5020
5021 pick_charmap( ret->ft_face, ret->charset );
5022
5023 ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
5024 ret->name = psub ? strdupW(psub->from.name) : strdupW(family->FamilyName);
5025 ret->underline = lf.lfUnderline ? 0xff : 0;
5026 ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
5027 create_child_font_list(ret);
5028
5029 if (face->flags & ADDFONT_VERTICAL_FONT) /* We need to try to load the GSUB table */
5030 {
5031 int length = get_font_data(ret, GSUB_TAG , 0, NULL, 0);
5032 if (length != GDI_ERROR)
5033 {
5034 ret->GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
5035 get_font_data(ret, GSUB_TAG , 0, ret->GSUB_Table, length);
5036 TRACE("Loaded GSUB table of %i bytes\n",length);
5037 }
5038 }
5039 ret->aa_flags = HIWORD( face->flags );
5040
5041 TRACE("caching: gdiFont=%p hfont=%p\n", ret, hfont);
5042
5043 add_to_cache(ret);
5044 done:
5045 if (ret)
5046 {
5047 PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectFont );
5048
5049 switch (lf.lfQuality)
5050 {
5051 case NONANTIALIASED_QUALITY:
5052 case ANTIALIASED_QUALITY:
5053 next->funcs->pSelectFont( dev, hfont, aa_flags );
5054 break;
5055 case CLEARTYPE_QUALITY:
5056 case CLEARTYPE_NATURAL_QUALITY:
5057 default:
5058 if (!*aa_flags) *aa_flags = ret->aa_flags;
5059 next->funcs->pSelectFont( dev, hfont, aa_flags );
5060
5061 /* fixup the antialiasing flags for that font */
5062 switch (*aa_flags)
5063 {
5064 case WINE_GGO_HRGB_BITMAP:
5065 case WINE_GGO_HBGR_BITMAP:
5066 case WINE_GGO_VRGB_BITMAP:
5067 case WINE_GGO_VBGR_BITMAP:
5068 if (is_subpixel_rendering_enabled()) break;
5069 *aa_flags = GGO_GRAY4_BITMAP;
5070 /* fall through */
5071 case GGO_GRAY2_BITMAP:
5072 case GGO_GRAY4_BITMAP:
5073 case GGO_GRAY8_BITMAP:
5074 case WINE_GGO_GRAY16_BITMAP:
5075 if (is_hinting_enabled())
5076 {
5077 WORD gasp_flags;
5078 if (get_gasp_flags( ret, &gasp_flags ) && !(gasp_flags & GASP_DOGRAY))
5079 {
5080 TRACE( "font %s %d aa disabled by GASP\n",
5081 debugstr_w(lf.lfFaceName), lf.lfHeight );
5082 *aa_flags = GGO_BITMAP;
5083 }
5084 }
5085 }
5086 }
5087 TRACE( "%p %s %d aa %x\n", hfont, debugstr_w(lf.lfFaceName), lf.lfHeight, *aa_flags );
5088 release_font( physdev->font );
5089 physdev->font = ret;
5090 }
5091 LeaveCriticalSection( &freetype_cs );
5092 release_dc_ptr( dc );
5093 return ret ? hfont : 0;
5094 }
5095
5096 static INT load_script_name( UINT id, WCHAR buffer[LF_FACESIZE] )
5097 {
5098 HRSRC rsrc;
5099 HGLOBAL hMem;
5100 WCHAR *p;
5101 int i;
5102
5103 id += IDS_FIRST_SCRIPT;
5104 rsrc = FindResourceW( gdi32_module, (LPCWSTR)(ULONG_PTR)((id >> 4) + 1), (LPCWSTR)6 /*RT_STRING*/ );
5105 if (!rsrc) return 0;
5106 hMem = LoadResource( gdi32_module, rsrc );
5107 if (!hMem) return 0;
5108
5109 p = LockResource( hMem );
5110 id &= 0x000f;
5111 while (id--) p += *p + 1;
5112
5113 i = min(LF_FACESIZE - 1, *p);
5114 memcpy(buffer, p + 1, i * sizeof(WCHAR));
5115 buffer[i] = 0;
5116 return i;
5117 }
5118
5119
5120 /***************************************************
5121 * create_enum_charset_list
5122 *
5123 * This function creates charset enumeration list because in DEFAULT_CHARSET
5124 * case, the ANSI codepage's charset takes precedence over other charsets.
5125 * This function works as a filter other than DEFAULT_CHARSET case.
5126 */
5127 static DWORD create_enum_charset_list(DWORD charset, struct enum_charset_list *list)
5128 {
5129 CHARSETINFO csi;
5130 DWORD n = 0;
5131
5132 if (TranslateCharsetInfo(ULongToPtr(charset), &csi, TCI_SRCCHARSET) &&
5133 csi.fs.fsCsb[0] != 0) {
5134 list->element[n].mask = csi.fs.fsCsb[0];
5135 list->element[n].charset = csi.ciCharset;
5136 load_script_name( ffs(csi.fs.fsCsb[0]) - 1, list->element[n].name );
5137 n++;
5138 }
5139 else { /* charset is DEFAULT_CHARSET or invalid. */
5140 INT acp, i;
5141 DWORD mask = 0;
5142
5143 /* Set the current codepage's charset as the first element. */
5144 acp = GetACP();
5145 if (TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE) &&
5146 csi.fs.fsCsb[0] != 0) {
5147 list->element[n].mask = csi.fs.fsCsb[0];
5148 list->element[n].charset = csi.ciCharset;
5149 load_script_name( ffs(csi.fs.fsCsb[0]) - 1, list->element[n].name );
5150 mask |= csi.fs.fsCsb[0];
5151 n++;
5152 }
5153
5154 /* Fill out left elements. */
5155 for (i = 0; i < 32; i++) {
5156 FONTSIGNATURE fs;
5157 fs.fsCsb[0] = 1L << i;
5158 fs.fsCsb[1] = 0;
5159 if (fs.fsCsb[0] & mask)
5160 continue; /* skip, already added. */
5161 if (!TranslateCharsetInfo(fs.fsCsb, &csi, TCI_SRCFONTSIG))
5162 continue; /* skip, this is an invalid fsCsb bit. */
5163
5164 list->element[n].mask = fs.fsCsb[0];
5165 list->element[n].charset = csi.ciCharset;
5166 load_script_name( i, list->element[n].name );
5167 mask |= fs.fsCsb[0];
5168 n++;
5169 }
5170
5171 /* add catch all mask for remaining bits */
5172 if (~mask)
5173 {
5174 list->element[n].mask = ~mask;
5175 list->element[n].charset = DEFAULT_CHARSET;
5176 load_script_name( IDS_OTHER - IDS_FIRST_SCRIPT, list->element[n].name );
5177 n++;
5178 }
5179 }
5180 list->total = n;
5181
5182 return n;
5183 }
5184
5185 static void GetEnumStructs(Face *face, const WCHAR *family_name, LPENUMLOGFONTEXW pelf,
5186 NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
5187 {
5188 GdiFont *font;
5189 LONG width, height;
5190
5191 if (face->cached_enum_data)
5192 {
5193 TRACE("Cached\n");
5194 *pelf = face->cached_enum_data->elf;
5195 *pntm = face->cached_enum_data->ntm;
5196 *ptype = face->cached_enum_data->type;
5197 return;
5198 }
5199
5200 font = alloc_font();
5201
5202 if(face->scalable) {
5203 height = 100;
5204 width = 0;
5205 } else {
5206 height = face->size.y_ppem >> 6;
5207 width = face->size.x_ppem >> 6;
5208 }
5209 font->scale_y = 1.0;
5210
5211 if (!(font->ft_face = OpenFontFace(font, face, width, height)))
5212 {
5213 free_font(font);
5214 return;
5215 }
5216
5217 font->name = strdupW( family_name );
5218 font->ntmFlags = face->ntmFlags;
5219
5220 if (get_outline_text_metrics(font))
5221 {
5222 memcpy(&pntm->ntmTm, &font->potm->otmTextMetrics, sizeof(TEXTMETRICW));
5223
5224 pntm->ntmTm.ntmSizeEM = font->potm->otmEMSquare;
5225 pntm->ntmTm.ntmCellHeight = font->ntmCellHeight;
5226 pntm->ntmTm.ntmAvgWidth = font->ntmAvgWidth;
5227
5228 lstrcpynW(pelf->elfLogFont.lfFaceName,
5229 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFamilyName),
5230 LF_FACESIZE);
5231 lstrcpynW(pelf->elfFullName,
5232 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFaceName),
5233 LF_FULLFACESIZE);
5234 lstrcpynW(pelf->elfStyle,
5235 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpStyleName),
5236 LF_FACESIZE);
5237 }
5238 else
5239 {
5240 get_text_metrics(font, (TEXTMETRICW *)&pntm->ntmTm);
5241
5242 pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
5243 pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
5244 pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
5245
5246 lstrcpynW(pelf->elfLogFont.lfFaceName, family_name, LF_FACESIZE);
5247 if (face->FullName)
5248 lstrcpynW(pelf->elfFullName, face->FullName, LF_FULLFACESIZE);
5249 else
5250 lstrcpynW(pelf->elfFullName, family_name, LF_FULLFACESIZE);
5251 lstrcpynW(pelf->elfStyle, face->StyleName, LF_FACESIZE);
5252 }
5253
5254 pntm->ntmTm.ntmFlags = face->ntmFlags;
5255 pntm->ntmFontSig = face->fs;
5256
5257 pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
5258
5259 pelf->elfLogFont.lfEscapement = 0;
5260 pelf->elfLogFont.lfOrientation = 0;
5261 pelf->elfLogFont.lfHeight = pntm->ntmTm.tmHeight;
5262 pelf->elfLogFont.lfWidth = pntm->ntmTm.tmAveCharWidth;
5263 pelf->elfLogFont.lfWeight = pntm->ntmTm.tmWeight;
5264 pelf->elfLogFont.lfItalic = pntm->ntmTm.tmItalic;
5265 pelf->elfLogFont.lfUnderline = pntm->ntmTm.tmUnderlined;
5266 pelf->elfLogFont.lfStrikeOut = pntm->ntmTm.tmStruckOut;
5267 pelf->elfLogFont.lfCharSet = pntm->ntmTm.tmCharSet;
5268 pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
5269 pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
5270 pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
5271 pelf->elfLogFont.lfPitchAndFamily = (pntm->ntmTm.tmPitchAndFamily & 0xf1) + 1;
5272
5273 *ptype = 0;
5274 if (pntm->ntmTm.tmPitchAndFamily & TMPF_TRUETYPE)
5275 *ptype |= TRUETYPE_FONTTYPE;
5276 if (pntm->ntmTm.tmPitchAndFamily & TMPF_DEVICE)
5277 *ptype |= DEVICE_FONTTYPE;
5278 if(!(pntm->ntmTm.tmPitchAndFamily & TMPF_VECTOR))
5279 *ptype |= RASTER_FONTTYPE;
5280
5281 face->cached_enum_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*face->cached_enum_data));
5282 if (face->cached_enum_data)
5283 {
5284 face->cached_enum_data->elf = *pelf;
5285 face->cached_enum_data->ntm = *pntm;
5286 face->cached_enum_data->type = *ptype;
5287 }
5288
5289 free_font(font);
5290 }
5291
5292 static BOOL family_matches(Family *family, const LOGFONTW *lf)
5293 {
5294 Face *face;
5295 const struct list *face_list;
5296
5297 if (!strcmpiW(lf->lfFaceName, family->FamilyName)) return TRUE;
5298
5299 face_list = get_face_list_from_family(family);
5300 LIST_FOR_EACH_ENTRY(face, face_list, Face, entry)
5301 if (face->FullName && !strcmpiW(lf->lfFaceName, face->FullName)) return TRUE;
5302
5303 return FALSE;
5304 }
5305
5306 static BOOL face_matches(const WCHAR *family_name, Face *face, const LOGFONTW *lf)
5307 {
5308 if (!strcmpiW(lf->lfFaceName, family_name)) return TRUE;
5309
5310 return (face->FullName && !strcmpiW(lf->lfFaceName, face->FullName));
5311 }
5312
5313 static BOOL enum_face_charsets(const Family *family, Face *face, struct enum_charset_list *list,
5314 FONTENUMPROCW proc, LPARAM lparam)
5315 {
5316 ENUMLOGFONTEXW elf;
5317 NEWTEXTMETRICEXW ntm;
5318 DWORD type = 0;
5319 DWORD i;
5320
5321 GetEnumStructs(face, face->family->FamilyName, &elf, &ntm, &type);
5322 for(i = 0; i < list->total; i++) {
5323 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
5324 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
5325 load_script_name( IDS_OEM_DOS - IDS_FIRST_SCRIPT, elf.elfScript );
5326 i = list->total; /* break out of loop after enumeration */
5327 }
5328 else
5329 {
5330 if(!(face->fs.fsCsb[0] & list->element[i].mask)) continue;
5331 /* use the DEFAULT_CHARSET case only if no other charset is present */
5332 if (list->element[i].charset == DEFAULT_CHARSET &&
5333 (face->fs.fsCsb[0] & ~list->element[i].mask)) continue;
5334 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = list->element[i].charset;
5335 strcpyW(elf.elfScript, list->element[i].name);
5336 if (!elf.elfScript[0])
5337 FIXME("Unknown elfscript for bit %d\n", ffs(list->element[i].mask) - 1);
5338 }
5339 /* Font Replacement */
5340 if (family != face->family)
5341 {
5342 strcpyW(elf.elfLogFont.lfFaceName, family->FamilyName);
5343 if (face->FullName)
5344 strcpyW(elf.elfFullName, face->FullName);
5345 else
5346 strcpyW(elf.elfFullName, family->FamilyName);
5347 }
5348 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
5349 debugstr_w(elf.elfLogFont.lfFaceName),
5350 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
5351 elf.elfLogFont.lfCharSet, type, debugstr_w(elf.elfScript),
5352 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
5353 ntm.ntmTm.ntmFlags);
5354 /* release section before callback (FIXME) */
5355 LeaveCriticalSection( &freetype_cs );
5356 if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return FALSE;
5357 EnterCriticalSection( &freetype_cs );
5358 }
5359 return TRUE;
5360 }
5361
5362 /*************************************************************
5363 * freetype_EnumFonts
5364 */
5365 static BOOL freetype_EnumFonts( PHYSDEV dev, LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam )
5366 {
5367 Family *family;
5368 Face *face;
5369 const struct list *face_list;
5370 LOGFONTW lf;
5371 struct enum_charset_list enum_charsets;
5372
5373 if (!plf)
5374 {
5375 lf.lfCharSet = DEFAULT_CHARSET;
5376 lf.lfPitchAndFamily = 0;
5377 lf.lfFaceName[0] = 0;
5378 plf = &lf;
5379 }
5380
5381 TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
5382
5383 create_enum_charset_list(plf->lfCharSet, &enum_charsets);
5384
5385 GDI_CheckNotLock();
5386 EnterCriticalSection( &freetype_cs );
5387 if(plf->lfFaceName[0]) {
5388 FontSubst *psub;
5389 psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
5390
5391 if(psub) {
5392 TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
5393 debugstr_w(psub->to.name));
5394 lf = *plf;
5395 strcpyW(lf.lfFaceName, psub->to.name);
5396 plf = &lf;
5397 }
5398
5399 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
5400 if (!family_matches(family, plf)) continue;
5401 face_list = get_face_list_from_family(family);
5402 LIST_FOR_EACH_ENTRY( face, face_list, Face, entry ) {
5403 if (!face_matches(family->FamilyName, face, plf)) continue;
5404 if (!enum_face_charsets(family, face, &enum_charsets, proc, lparam)) return FALSE;
5405 }
5406 }
5407 } else {
5408 LIST_FOR_EACH_ENTRY( family, &font_list, Family, entry ) {
5409 face_list = get_face_list_from_family(family);
5410 face = LIST_ENTRY(list_head(face_list), Face, entry);
5411 if (!enum_face_charsets(family, face, &enum_charsets, proc, lparam)) return FALSE;
5412 }
5413 }
5414 LeaveCriticalSection( &freetype_cs );
5415 return TRUE;
5416 }
5417
5418 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
5419 {
5420 pt->x.value = vec->x >> 6;
5421 pt->x.fract = (vec->x & 0x3f) << 10;
5422 pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
5423 pt->y.value = vec->y >> 6;
5424 pt->y.fract = (vec->y & 0x3f) << 10;
5425 pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
5426 return;
5427 }
5428
5429 /***************************************************
5430 * According to the MSDN documentation on WideCharToMultiByte,
5431 * certain codepages cannot set the default_used parameter.
5432 * This returns TRUE if the codepage can set that parameter, false else
5433 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
5434 */
5435 static BOOL codepage_sets_default_used(UINT codepage)
5436 {
5437 switch (codepage)
5438 {
5439 case CP_UTF7:
5440 case CP_UTF8:
5441 case CP_SYMBOL:
5442 return FALSE;
5443 default:
5444 return TRUE;
5445 }
5446 }
5447
5448 /*
5449 * GSUB Table handling functions
5450 */
5451
5452 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
5453 {
5454 const GSUB_CoverageFormat1* cf1;
5455
5456 cf1 = table;
5457
5458 if (GET_BE_WORD(cf1->CoverageFormat) == 1)
5459 {
5460 int count = GET_BE_WORD(cf1->GlyphCount);
5461 int i;
5462 TRACE("Coverage Format 1, %i glyphs\n",count);
5463 for (i = 0; i < count; i++)
5464 if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
5465 return i;
5466 return -1;
5467 }
5468 else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
5469 {
5470 const GSUB_CoverageFormat2* cf2;
5471 int i;
5472 int count;
5473 cf2 = (const GSUB_CoverageFormat2*)cf1;
5474
5475 count = GET_BE_WORD(cf2->RangeCount);
5476 TRACE("Coverage Format 2, %i ranges\n",count);
5477 for (i = 0; i < count; i++)
5478 {
5479 if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
5480 return -1;
5481 if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
5482 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
5483 {
5484 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
5485 glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
5486 }
5487 }
5488 return -1;
5489 }
5490 else
5491 ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
5492
5493 return -1;
5494 }
5495
5496 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
5497 {
5498 const GSUB_ScriptList *script;
5499 const GSUB_Script *deflt = NULL;
5500 int i;
5501 script = (const GSUB_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
5502
5503 TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
5504 for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
5505 {
5506 const GSUB_Script *scr;
5507 int offset;
5508
5509 offset = GET_BE_WORD(script->ScriptRecord[i].Script);
5510 scr = (const GSUB_Script*)((const BYTE*)script + offset);
5511
5512 if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
5513 return scr;
5514 if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
5515 deflt = scr;
5516 }
5517 return deflt;
5518 }
5519
5520 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
5521 {
5522 int i;
5523 int offset;
5524 const GSUB_LangSys *Lang;
5525
5526 TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
5527
5528 for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
5529 {
5530 offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
5531 Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
5532
5533 if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
5534 return Lang;
5535 }
5536 offset = GET_BE_WORD(script->DefaultLangSys);
5537 if (offset)
5538 {
5539 Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
5540 return Lang;
5541 }
5542 return NULL;
5543 }
5544
5545 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
5546 {
5547 int i;
5548 const GSUB_FeatureList *feature;
5549 feature = (const GSUB_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
5550
5551 TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
5552 for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
5553 {
5554 int index = GET_BE_WORD(lang->FeatureIndex[i]);
5555 if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
5556 {
5557 const GSUB_Feature *feat;
5558 feat = (const GSUB_Feature*)((const BYTE*)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
5559 return feat;
5560 }
5561 }
5562 return NULL;
5563 }
5564
5565 static FT_UInt GSUB_apply_feature(const GSUB_Header * header, const GSUB_Feature* feature, UINT glyph)
5566 {
5567 int i;
5568 int offset;
5569 const GSUB_LookupList *lookup;
5570 lookup = (const GSUB_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
5571
5572 TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
5573 for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
5574 {
5575 const GSUB_LookupTable *look;
5576 offset = GET_BE_WORD(lookup->Lookup[GET_BE_WORD(feature->LookupListIndex[i])]);
5577 look = (const GSUB_LookupTable*)((const BYTE*)lookup + offset);
5578 TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
5579 if (GET_BE_WORD(look->LookupType) != 1)
5580 FIXME("We only handle SubType 1\n");
5581 else
5582 {
5583 int j;
5584
5585 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
5586 {
5587 const GSUB_SingleSubstFormat1 *ssf1;
5588 offset = GET_BE_WORD(look->SubTable[j]);
5589 ssf1 = (const GSUB_SingleSubstFormat1*)((const BYTE*)look+offset);
5590 if (GET_BE_WORD(ssf1->SubstFormat) == 1)
5591 {
5592 int offset = GET_BE_WORD(ssf1->Coverage);
5593 TRACE(" subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
5594 if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyph) != -1)
5595 {
5596 TRACE(" Glyph 0x%x ->",glyph);
5597 glyph += GET_BE_WORD(ssf1->DeltaGlyphID);
5598 TRACE(" 0x%x\n",glyph);
5599 }
5600 }
5601 else
5602 {
5603 const GSUB_SingleSubstFormat2 *ssf2;
5604 INT index;
5605 INT offset;
5606
5607 ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
5608 offset = GET_BE_WORD(ssf1->Coverage);
5609 TRACE(" subtype 2, glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
5610 index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyph);
5611 TRACE(" Coverage index %i\n",index);
5612 if (index != -1)
5613 {
5614 TRACE(" Glyph is 0x%x ->",glyph);
5615 glyph = GET_BE_WORD(ssf2->Substitute[index]);
5616 TRACE("0x%x\n",glyph);
5617 }
5618 }
5619 }
5620 }
5621 }
5622 return glyph;
5623 }
5624
5625 static const char* get_opentype_script(const GdiFont *font)
5626 {
5627 /*
5628 * I am not sure if this is the correct way to generate our script tag
5629 */
5630
5631 switch (font->charset)
5632 {
5633 case ANSI_CHARSET: return "latn";
5634 case BALTIC_CHARSET: return "latn"; /* ?? */
5635 case CHINESEBIG5_CHARSET: return "hani";
5636 case EASTEUROPE_CHARSET: return "latn"; /* ?? */
5637 case GB2312_CHARSET: return "hani";
5638 case GREEK_CHARSET: return "grek";
5639 case HANGUL_CHARSET: return "hang";
5640 case RUSSIAN_CHARSET: return "cyrl";
5641 case SHIFTJIS_CHARSET: return "kana";
5642 case TURKISH_CHARSET: return "latn"; /* ?? */
5643 case VIETNAMESE_CHARSET: return "latn";
5644 case JOHAB_CHARSET: return "latn"; /* ?? */
5645 case ARABIC_CHARSET: return "arab";
5646 case HEBREW_CHARSET: return "hebr";
5647 case THAI_CHARSET: return "thai";
5648 default: return "latn";
5649 }
5650 }
5651
5652 static FT_UInt get_GSUB_vert_glyph(const GdiFont *font, UINT glyph)
5653 {
5654 const GSUB_Header *header;
5655 const GSUB_Script *script;
5656 const GSUB_LangSys *language;
5657 const GSUB_Feature *feature;
5658
5659 if (!font->GSUB_Table)
5660 return glyph;
5661
5662 header = font->GSUB_Table;
5663
5664 script = GSUB_get_script_table(header, get_opentype_script(font));
5665 if (!script)
5666 {
5667 TRACE("Script not found\n");
5668 return glyph;
5669 }
5670 language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
5671 if (!language)
5672 {
5673 TRACE("Language not found\n");
5674 return glyph;
5675 }
5676 feature = GSUB_get_feature(header, language, "vrt2");
5677 if (!feature)
5678 feature = GSUB_get_feature(header, language, "vert");
5679 if (!feature)
5680 {
5681 TRACE("vrt2/vert feature not found\n");
5682 return glyph;
5683 }
5684 return GSUB_apply_feature(header, feature, glyph);
5685 }
5686
5687 static FT_UInt get_glyph_index(const GdiFont *font, UINT glyph)
5688 {
5689 FT_UInt glyphId;
5690
5691 if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
5692 WCHAR wc = (WCHAR)glyph;
5693 BOOL default_used;
5694 BOOL *default_used_pointer;
5695 FT_UInt ret;
5696 char buf;
5697 default_used_pointer = NULL;
5698 default_used = FALSE;
5699 if (codepage_sets_default_used(font->codepage))
5700 default_used_pointer = &default_used;
5701 if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
5702 {
5703 if (font->codepage == CP_SYMBOL && wc < 0x100)
5704 ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)wc);
5705 else
5706 ret = 0;
5707 }
5708 else
5709 ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
5710 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
5711 return ret;
5712 }
5713
5714 if(font->ft_face->charmap->encoding == FT_ENCODING_MS_SYMBOL)
5715 {
5716 if (glyph < 0x100) glyph += 0xf000;
5717 /* there is a number of old pre-Unicode "broken" TTFs, which
5718 do have symbols at U+00XX instead of U+f0XX */
5719 if (!(glyphId = pFT_Get_Char_Index(font->ft_face, glyph)))
5720 glyphId = pFT_Get_Char_Index(font->ft_face, glyph-0xf000);
5721 }
5722 else glyphId = pFT_Get_Char_Index(font->ft_face, glyph);
5723
5724 return glyphId;
5725 }
5726
5727 /*************************************************************
5728 * freetype_GetGlyphIndices
5729 */
5730 static DWORD freetype_GetGlyphIndices( PHYSDEV dev, LPCWSTR lpstr, INT count, LPWORD pgi, DWORD flags )
5731 {
5732 struct freetype_physdev *physdev = get_freetype_dev( dev );
5733 int i;
5734 WORD default_char;
5735 BOOL got_default = FALSE;
5736
5737 if (!physdev->font)
5738 {
5739 dev = GET_NEXT_PHYSDEV( dev, pGetGlyphIndices );
5740 return dev->funcs->pGetGlyphIndices( dev, lpstr, count, pgi, flags );
5741 }
5742
5743 if (flags & GGI_MARK_NONEXISTING_GLYPHS)
5744 {
5745 default_char = 0xffff; /* XP would use 0x1f for bitmap fonts */
5746 got_default = TRUE;
5747 }
5748
5749 GDI_CheckNotLock();
5750 EnterCriticalSection( &freetype_cs );
5751
5752 for(i = 0; i < count; i++)
5753 {
5754 pgi[i] = get_glyph_index(physdev->font, lpstr[i]);
5755 if (pgi[i] == 0)
5756 {
5757 if (!got_default)
5758 {
5759 if (FT_IS_SFNT(physdev->font->ft_face))
5760 {
5761 TT_OS2 *pOS2 = pFT_Get_Sfnt_Table(physdev->font->ft_face, ft_sfnt_os2);
5762 default_char = (pOS2->usDefaultChar ? get_glyph_index(physdev->font, pOS2->usDefaultChar) : 0);
5763 }
5764 else
5765 {
5766 TEXTMETRICW textm;
5767 get_text_metrics(physdev->font, &textm);
5768 default_char = textm.tmDefaultChar;
5769 }
5770 got_default = TRUE;
5771 }
5772 pgi[i] = default_char;
5773 }
5774 }
5775 LeaveCriticalSection( &freetype_cs );
5776 return count;
5777 }
5778
5779 static inline BOOL is_identity_FMAT2(const FMAT2 *matrix)
5780 {
5781 static const FMAT2 identity = { 1.0, 0.0, 0.0, 1.0 };
5782 return !memcmp(matrix, &identity, sizeof(FMAT2));
5783 }
5784
5785 static inline BOOL is_identity_MAT2(const MAT2 *matrix)
5786 {
5787 static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
5788 return !memcmp(matrix, &identity, sizeof(MAT2));
5789 }
5790
5791 static inline BYTE get_max_level( UINT format )
5792 {
5793 switch( format )
5794 {
5795 case GGO_GRAY2_BITMAP: return 4;
5796 case GGO_GRAY4_BITMAP: return 16;
5797 case GGO_GRAY8_BITMAP: return 64;
5798 }
5799 return 255;
5800 }
5801
5802 static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
5803
5804 static DWORD get_glyph_outline(GdiFont *incoming_font, UINT glyph, UINT format,
5805 LPGLYPHMETRICS lpgm, ABC *abc, DWORD buflen, LPVOID buf,
5806 const MAT2* lpmat)
5807 {
5808 static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
5809 FT_Face ft_face = incoming_font->ft_face;
5810 GdiFont *font = incoming_font;
5811 FT_UInt glyph_index;
5812 DWORD width, height, pitch, needed = 0;
5813 FT_Bitmap ft_bitmap;
5814 FT_Error err;
5815 INT left, right, top = 0, bottom = 0, adv;
5816 FT_Angle angle = 0;
5817 FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
5818 double widthRatio = 1.0;
5819 FT_Matrix transMat = identityMat;
5820 FT_Matrix transMatUnrotated;
5821 BOOL needsTransform = FALSE;
5822 BOOL tategaki = (font->GSUB_Table != NULL);
5823 UINT original_index;
5824 FT_Fixed avgAdvance = 0;
5825
5826 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
5827 buflen, buf, lpmat);
5828
5829 TRACE("font transform %f %f %f %f\n",
5830 font->font_desc.matrix.eM11, font->font_desc.matrix.eM12,
5831 font->font_desc.matrix.eM21, font->font_desc.matrix.eM22);
5832
5833 if(format & GGO_GLYPH_INDEX) {
5834 glyph_index = get_GSUB_vert_glyph(incoming_font,glyph);
5835 original_index = glyph;
5836 format &= ~GGO_GLYPH_INDEX;
5837 } else {
5838 get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
5839 ft_face = font->ft_face;
5840 original_index = glyph_index;
5841 }
5842
5843 if(format & GGO_UNHINTED) {
5844 load_flags |= FT_LOAD_NO_HINTING;
5845 format &= ~GGO_UNHINTED;
5846 }
5847
5848 /* tategaki never appears to happen to lower glyph index */
5849 if (glyph_index < TATEGAKI_LOWER_BOUND )
5850 tategaki = FALSE;
5851
5852 if(original_index >= font->gmsize * GM_BLOCK_SIZE) {
5853 font->gmsize = (original_index / GM_BLOCK_SIZE + 1);
5854 font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
5855 font->gmsize * sizeof(GM*));
5856 } else {
5857 if (format == GGO_METRICS && font->gm[original_index / GM_BLOCK_SIZE] != NULL &&
5858 FONT_GM(font,original_index)->init && is_identity_MAT2(lpmat))
5859 {
5860 *lpgm = FONT_GM(font,original_index)->gm;
5861 *abc = FONT_GM(font,original_index)->abc;
5862 TRACE("cached: %u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
5863 wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
5864 lpgm->gmCellIncX, lpgm->gmCellIncY);
5865 return 1; /* FIXME */
5866 }
5867 }
5868
5869 if (!font->gm[original_index / GM_BLOCK_SIZE])
5870 font->gm[original_index / GM_BLOCK_SIZE] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
5871
5872 /* Scaling factor */
5873 if (font->aveWidth)
5874 {
5875 TEXTMETRICW tm;
5876
5877 get_text_metrics(font, &tm);
5878
5879 widthRatio = (double)font->aveWidth;
5880 widthRatio /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
5881 }
5882 else
5883 widthRatio = font->scale_y;
5884
5885 /* Scaling transform */
5886 if (widthRatio != 1.0 || font->scale_y != 1.0)
5887 {
5888 FT_Matrix scaleMat;
5889 scaleMat.xx = FT_FixedFromFloat(widthRatio);
5890 scaleMat.xy = 0;
5891 scaleMat.yx = 0;
5892 scaleMat.yy = FT_FixedFromFloat(font->scale_y);
5893
5894 pFT_Matrix_Multiply(&scaleMat, &transMat);
5895 needsTransform = TRUE;
5896 }
5897
5898 /* Slant transform */
5899 if (font->fake_italic) {
5900 FT_Matrix slantMat;
5901
5902 slantMat.xx = (1 << 16);
5903 slantMat.xy = ((1 << 16) >> 2);
5904 slantMat.yx = 0;
5905 slantMat.yy = (1 << 16);
5906 pFT_Matrix_Multiply(&slantMat, &transMat);
5907 needsTransform = TRUE;
5908 }
5909
5910 /* Rotation transform */
5911 transMatUnrotated = transMat;
5912 if(font->orientation && !tategaki) {
5913 FT_Matrix rotationMat;
5914 FT_Vector vecAngle;
5915 angle = FT_FixedFromFloat((double)font->orientation / 10.0);
5916 pFT_Vector_Unit(&vecAngle, angle);
5917 rotationMat.xx = vecAngle.x;
5918 rotationMat.xy = -vecAngle.y;
5919 rotationMat.yx = -rotationMat.xy;
5920 rotationMat.yy = rotationMat.xx;
5921
5922 pFT_Matrix_Multiply(&rotationMat, &transMat);
5923 needsTransform = TRUE;
5924 }
5925
5926 /* World transform */
5927 if (!is_identity_FMAT2(&font->font_desc.matrix))
5928 {
5929 FT_Matrix worldMat;
5930 worldMat.xx = FT_FixedFromFloat(font->font_desc.matrix.eM11);
5931 worldMat.xy = -FT_FixedFromFloat(font->font_desc.matrix.eM21);
5932 worldMat.yx = -FT_FixedFromFloat(font->font_desc.matrix.eM12);
5933 worldMat.yy = FT_FixedFromFloat(font->font_desc.matrix.eM22);
5934 pFT_Matrix_Multiply(&worldMat, &transMat);
5935 pFT_Matrix_Multiply(&worldMat, &transMatUnrotated);
5936 needsTransform = TRUE;
5937 }
5938
5939 /* Extra transformation specified by caller */
5940 if (!is_identity_MAT2(lpmat))
5941 {
5942 FT_Matrix extraMat;
5943 extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
5944 extraMat.xy = FT_FixedFromFIXED(lpmat->eM21);
5945 extraMat.yx = FT_FixedFromFIXED(lpmat->eM12);
5946 extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
5947 pFT_Matrix_Multiply(&extraMat, &transMat);
5948 pFT_Matrix_Multiply(&extraMat, &transMatUnrotated);
5949 needsTransform = TRUE;
5950 }
5951
5952 if (needsTransform || format != GGO_BITMAP) load_flags |= FT_LOAD_NO_BITMAP;
5953
5954 err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
5955
5956 if(err) {
5957 WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
5958 return GDI_ERROR;
5959 }
5960
5961 if(FT_IS_SCALABLE(incoming_font->ft_face)) {
5962 TEXTMETRICW tm;
5963 if (get_text_metrics(incoming_font, &tm) &&
5964 !(tm.tmPitchAndFamily & TMPF_FIXED_PITCH)) {
5965 avgAdvance = pFT_MulFix(incoming_font->ntmAvgWidth,
5966 incoming_font->ft_face->size->metrics.x_scale);
5967 if (avgAdvance && (ft_face->glyph->metrics.horiAdvance+63) >> 6 == (avgAdvance*2+63) >> 6)
5968 TRACE("Fixed-pitch full-width character detected\n");
5969 else
5970 avgAdvance = 0; /* cancel this feature */
5971 }
5972 }
5973
5974 if(!needsTransform) {
5975 left = (INT)(ft_face->glyph->metrics.horiBearingX) & -64;
5976 right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) + 63) & -64;
5977 if (!avgAdvance)
5978 adv = (INT)(ft_face->glyph->metrics.horiAdvance + 63) >> 6;
5979 else
5980 adv = (INT)((avgAdvance + 32) >> 6) * 2;
5981
5982 top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
5983 bottom = (ft_face->glyph->metrics.horiBearingY -
5984 ft_face->glyph->metrics.height) & -64;
5985 lpgm->gmCellIncX = adv;
5986 lpgm->gmCellIncY = 0;
5987 } else {
5988 INT xc, yc;
5989 FT_Vector vec;
5990
5991 left = right = 0;
5992
5993 for(xc = 0; xc < 2; xc++) {
5994 for(yc = 0; yc < 2; yc++) {
5995 vec.x = (ft_face->glyph->metrics.horiBearingX +
5996 xc * ft_face->glyph->metrics.width);
5997 vec.y = ft_face->glyph->metrics.horiBearingY -
5998 yc * ft_face->glyph->metrics.height;
5999 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
6000 pFT_Vector_Transform(&vec, &transMat);
6001 if(xc == 0 && yc == 0) {
6002 left = right = vec.x;
6003 top = bottom = vec.y;
6004 } else {
6005 if(vec.x < left) left = vec.x;
6006 else if(vec.x > right) right = vec.x;
6007 if(vec.y < bottom) bottom = vec.y;
6008 else if(vec.y > top) top = vec.y;
6009 }
6010 }
6011 }
6012 left = left & -64;
6013 right = (right + 63) & -64;
6014 bottom = bottom & -64;
6015 top = (top + 63) & -64;
6016
6017 TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
6018 vec.x = ft_face->glyph->metrics.horiAdvance;
6019 vec.y = 0;
6020 pFT_Vector_Transform(&vec, &transMat);
6021 lpgm->gmCellIncY = -((vec.y+63) >> 6);
6022 if (!avgAdvance || vec.y)
6023 lpgm->gmCellIncX = (vec.x+63) >> 6;
6024 else {
6025 vec.x = avgAdvance;
6026 vec.y = 0;
6027 pFT_Vector_Transform(&vec, &transMat);
6028 lpgm->gmCellIncX = ((vec.x+32) >> 6) * 2;
6029 }
6030
6031 vec.x = ft_face->glyph->metrics.horiAdvance;
6032 vec.y = 0;
6033 pFT_Vector_Transform(&vec, &transMatUnrotated);
6034 if (!avgAdvance || vec.y)
6035 adv = (vec.x+63) >> 6;
6036 else {
6037 vec.x = avgAdvance;
6038 vec.y = 0;
6039 pFT_Vector_Transform(&vec, &transMatUnrotated);
6040 adv = ((vec.x+32) >> 6) * 2;
6041 }
6042 }
6043
6044 lpgm->gmBlackBoxX = (right - left) >> 6;
6045 lpgm->gmBlackBoxY = (top - bottom) >> 6;
6046 lpgm->gmptGlyphOrigin.x = left >> 6;
6047 lpgm->gmptGlyphOrigin.y = top >> 6;
6048 abc->abcA = left >> 6;
6049 abc->abcB = (right - left) >> 6;
6050 abc->abcC = adv - abc->abcA - abc->abcB;
6051
6052 TRACE("%u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
6053 wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
6054 lpgm->gmCellIncX, lpgm->gmCellIncY);
6055
6056 if ((format == GGO_METRICS || format == GGO_BITMAP || format == WINE_GGO_GRAY16_BITMAP) &&
6057 is_identity_MAT2(lpmat)) /* don't cache custom transforms */
6058 {
6059 FONT_GM(font,original_index)->gm = *lpgm;
6060 FONT_GM(font,original_index)->abc = *abc;
6061 FONT_GM(font,original_index)->init = TRUE;
6062 }
6063
6064 if(format == GGO_METRICS)
6065 {
6066 return 1; /* FIXME */
6067 }
6068
6069 if(ft_face->glyph->format != ft_glyph_format_outline &&
6070 (format == GGO_NATIVE || format == GGO_BEZIER))
6071 {
6072 TRACE("loaded a bitmap\n");
6073 return GDI_ERROR;
6074 }
6075
6076 switch(format) {
6077 case GGO_BITMAP:
6078 width = lpgm->gmBlackBoxX;
6079 height = lpgm->gmBlackBoxY;
6080 pitch = ((width + 31) >> 5) << 2;
6081 needed = pitch * height;
6082
6083 if(!buf || !buflen) break;
6084
6085 switch(ft_face->glyph->format) {
6086 case ft_glyph_format_bitmap:
6087 {
6088 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
6089 INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
6090 INT h = ft_face->glyph->bitmap.rows;
6091 while(h--) {
6092 memcpy(dst, src, w);
6093 src += ft_face->glyph->bitmap.pitch;
6094 dst += pitch;
6095 }
6096 break;
6097 }
6098
6099 case ft_glyph_format_outline:
6100 ft_bitmap.width = width;
6101 ft_bitmap.rows = height;
6102 ft_bitmap.pitch = pitch;
6103 ft_bitmap.pixel_mode = ft_pixel_mode_mono;
6104 ft_bitmap.buffer = buf;
6105
6106 if(needsTransform)
6107 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
6108
6109 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
6110
6111 /* Note: FreeType will only set 'black' bits for us. */
6112 memset(buf, 0, needed);
6113 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
6114 break;
6115
6116 default:
6117 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
6118 return GDI_ERROR;
6119 }
6120 break;
6121
6122 case GGO_GRAY2_BITMAP:
6123 case GGO_GRAY4_BITMAP:
6124 case GGO_GRAY8_BITMAP:
6125 case WINE_GGO_GRAY16_BITMAP:
6126 {
6127 unsigned int max_level, row, col;
6128 BYTE *start, *ptr;
6129
6130 width = lpgm->gmBlackBoxX;
6131 height = lpgm->gmBlackBoxY;
6132 pitch = (width + 3) / 4 * 4;
6133 needed = pitch * height;
6134
6135 if(!buf || !buflen) break;
6136
6137 max_level = get_max_level( format );
6138
6139 switch(ft_face->glyph->format) {
6140 case ft_glyph_format_bitmap:
6141 {
6142 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
6143 INT h = ft_face->glyph->bitmap.rows;
6144 INT x;
6145 memset( buf, 0, needed );
6146 while(h--) {
6147 for(x = 0; x < pitch && x < ft_face->glyph->bitmap.width; x++)
6148 if (src[x / 8] & masks[x % 8]) dst[x] = max_level;
6149 src += ft_face->glyph->bitmap.pitch;
6150 dst += pitch;
6151 }
6152 return needed;
6153 }
6154 case ft_glyph_format_outline:
6155 {
6156 ft_bitmap.width = width;
6157 ft_bitmap.rows = height;
6158 ft_bitmap.pitch = pitch;
6159 ft_bitmap.pixel_mode = ft_pixel_mode_grays;
6160 ft_bitmap.buffer = buf;
6161
6162 if(needsTransform)
6163 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
6164
6165 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
6166
6167 memset(ft_bitmap.buffer, 0, buflen);
6168
6169 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
6170
6171 if (max_level != 255)
6172 {
6173 for (row = 0, start = buf; row < height; row++)
6174 {
6175 for (col = 0, ptr = start; col < width; col++, ptr++)
6176 *ptr = (((int)*ptr) * (max_level + 1)) / 256;
6177 start += pitch;
6178 }
6179 }
6180 return needed;
6181 }
6182
6183 default:
6184 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
6185 return GDI_ERROR;
6186 }
6187 break;
6188 }
6189
6190 case WINE_GGO_HRGB_BITMAP:
6191 case WINE_GGO_HBGR_BITMAP:
6192 case WINE_GGO_VRGB_BITMAP:
6193 case WINE_GGO_VBGR_BITMAP:
6194 #ifdef HAVE_FREETYPE_FTLCDFIL_H
6195 {
6196 switch (ft_face->glyph->format)
6197 {
6198 case FT_GLYPH_FORMAT_BITMAP:
6199 {
6200 BYTE *src, *dst;
6201 INT src_pitch, x;
6202
6203 width = lpgm->gmBlackBoxX;
6204 height = lpgm->gmBlackBoxY;
6205 pitch = width * 4;
6206 needed = pitch * height;
6207
6208 if (!buf || !buflen) break;
6209
6210 memset(buf, 0, buflen);
6211 dst = buf;
6212 src = ft_face->glyph->bitmap.buffer;
6213 src_pitch = ft_face->glyph->bitmap.pitch;
6214
6215 height = min( height, ft_face->glyph->bitmap.rows );
6216 while ( height-- )
6217 {
6218 for (x = 0; x < width && x < ft_face->glyph->bitmap.width; x++)
6219 {
6220 if ( src[x / 8] & masks[x % 8] )
6221 ((unsigned int *)dst)[x] = ~0u;
6222 }
6223 src += src_pitch;
6224 dst += pitch;
6225 }
6226
6227 break;
6228 }
6229
6230 case FT_GLYPH_FORMAT_OUTLINE:
6231 {
6232 unsigned int *dst;
6233 BYTE *src;
6234 INT x, src_pitch, src_width, src_height, rgb_interval, hmul, vmul;
6235 INT x_shift, y_shift;
6236 BOOL rgb;
6237 FT_LcdFilter lcdfilter = FT_LCD_FILTER_DEFAULT;
6238 FT_Render_Mode render_mode =
6239 (format == WINE_GGO_HRGB_BITMAP || format == WINE_GGO_HBGR_BITMAP)?
6240 FT_RENDER_MODE_LCD: FT_RENDER_MODE_LCD_V;
6241
6242 if ( lcdfilter == FT_LCD_FILTER_DEFAULT || lcdfilter == FT_LCD_FILTER_LIGHT )
6243 {
6244 if ( render_mode == FT_RENDER_MODE_LCD)
6245 {
6246 lpgm->gmBlackBoxX += 2;
6247 lpgm->gmptGlyphOrigin.x -= 1;
6248 }
6249 else
6250 {
6251 lpgm->gmBlackBoxY += 2;
6252 lpgm->gmptGlyphOrigin.y += 1;
6253 }
6254 }
6255
6256 width = lpgm->gmBlackBoxX;
6257 height = lpgm->gmBlackBoxY;
6258 pitch = width * 4;
6259 needed = pitch * height;
6260
6261 if (!buf || !buflen) break;
6262
6263 memset(buf, 0, buflen);
6264 dst = buf;
6265 rgb = (format == WINE_GGO_HRGB_BITMAP || format == WINE_GGO_VRGB_BITMAP);
6266
6267 if ( needsTransform )
6268 pFT_Outline_Transform (&ft_face->glyph->outline, &transMat);
6269
6270 if ( pFT_Library_SetLcdFilter )
6271 pFT_Library_SetLcdFilter( library, lcdfilter );
6272 pFT_Render_Glyph (ft_face->glyph, render_mode);
6273
6274 src = ft_face->glyph->bitmap.buffer;
6275 src_pitch = ft_face->glyph->bitmap.pitch;
6276 src_width = ft_face->glyph->bitmap.width;
6277 src_height = ft_face->glyph->bitmap.rows;
6278
6279 if ( render_mode == FT_RENDER_MODE_LCD)
6280 {
6281 rgb_interval = 1;
6282 hmul = 3;
6283 vmul = 1;
6284 }
6285 else
6286 {
6287 rgb_interval = src_pitch;
6288 hmul = 1;
6289 vmul = 3;
6290 }
6291
6292 x_shift = ft_face->glyph->bitmap_left - lpgm->gmptGlyphOrigin.x;
6293 if ( x_shift < 0 ) x_shift = 0;
6294 if ( x_shift + (src_width / hmul) > width )
6295 x_shift = width - (src_width / hmul);
6296
6297 y_shift = lpgm->gmptGlyphOrigin.y - ft_face->glyph->bitmap_top;
6298 if ( y_shift < 0 ) y_shift = 0;
6299 if ( y_shift + (src_height / vmul) > height )
6300 y_shift = height - (src_height / vmul);
6301
6302 dst += x_shift + y_shift * ( pitch / 4 );
6303 while ( src_height )
6304 {
6305 for ( x = 0; x < src_width / hmul; x++ )
6306 {
6307 if ( rgb )
6308 {
6309 dst[x] = ((unsigned int)src[hmul * x + rgb_interval * 0] << 16) |
6310 ((unsigned int)src[hmul * x + rgb_interval * 1] << 8) |
6311 ((unsigned int)src[hmul * x + rgb_interval * 2] << 0) |
6312 ((unsigned int)src[hmul * x + rgb_interval * 1] << 24) ;
6313 }
6314 else
6315 {
6316 dst[x] = ((unsigned int)src[hmul * x + rgb_interval * 2] << 16) |
6317 ((unsigned int)src[hmul * x + rgb_interval * 1] << 8) |
6318 ((unsigned int)src[hmul * x + rgb_interval * 0] << 0) |
6319 ((unsigned int)src[hmul * x + rgb_interval * 1] << 24) ;
6320 }
6321 }
6322 src += src_pitch * vmul;
6323 dst += pitch / 4;
6324 src_height -= vmul;
6325 }
6326
6327 break;
6328 }
6329
6330 default:
6331 FIXME ("loaded glyph format %x\n", ft_face->glyph->format);
6332 return GDI_ERROR;
6333 }
6334
6335 break;
6336 }
6337 #else
6338 return GDI_ERROR;
6339 #endif
6340
6341 case GGO_NATIVE:
6342 {
6343 int contour, point = 0, first_pt;
6344 FT_Outline *outline = &ft_face->glyph->outline;
6345 TTPOLYGONHEADER *pph;
6346 TTPOLYCURVE *ppc;
6347 DWORD pph_start, cpfx, type;
6348
6349 if(buflen == 0) buf = NULL;
6350
6351 if (needsTransform && buf) {
6352 pFT_Outline_Transform(outline, &transMat);
6353 }
6354
6355 for(contour = 0; contour < outline->n_contours; contour++) {
6356 /* Ignore contours containing one point */
6357 if(point == outline->contours[contour]) {
6358 point++;
6359 continue;
6360 }
6361
6362 pph_start = needed;
6363 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
6364 first_pt = point;
6365 if(buf) {
6366 pph->dwType = TT_POLYGON_TYPE;
6367 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
6368 }
6369 needed += sizeof(*pph);
6370 point++;
6371 while(point <= outline->contours[contour]) {
6372 ppc = (TTPOLYCURVE *)((char *)buf + needed);
6373 type = (outline->tags[point] & FT_Curve_Tag_On) ?
6374 TT_PRIM_LINE : TT_PRIM_QSPLINE;
6375 cpfx = 0;
6376 do {
6377 if(buf)
6378 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
6379 cpfx++;
6380 point++;
6381 } while(point <= outline->contours[contour] &&
6382 (outline->tags[point] & FT_Curve_Tag_On) ==
6383 (outline->tags[point-1] & FT_Curve_Tag_On));
6384 /* At the end of a contour Windows adds the start point, but
6385 only for Beziers */
6386 if(point > outline->contours[contour] &&
6387 !(outline->tags[point-1] & FT_Curve_Tag_On)) {
6388 if(buf)
6389 FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
6390 cpfx++;
6391 } else if(point <= outline->contours[contour] &&
6392 outline->tags[point] & FT_Curve_Tag_On) {
6393 /* add closing pt for bezier */
6394 if(buf)
6395 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
6396 cpfx++;
6397 point++;
6398 }
6399 if(buf) {
6400 ppc->wType = type;
6401 ppc->cpfx = cpfx;
6402 }
6403 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
6404 }
6405 if(buf)
6406 pph->cb = needed - pph_start;
6407 }
6408 break;
6409 }
6410 case GGO_BEZIER:
6411 {
6412 /* Convert the quadratic Beziers to cubic Beziers.
6413 The parametric eqn for a cubic Bezier is, from PLRM:
6414 r(t) = at^3 + bt^2 + ct + r0
6415 with the control points:
6416 r1 = r0 + c/3
6417 r2 = r1 + (c + b)/3
6418 r3 = r0 + c + b + a
6419
6420 A quadratic Bezier has the form:
6421 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
6422
6423 So equating powers of t leads to:
6424 r1 = 2/3 p1 + 1/3 p0
6425 r2 = 2/3 p1 + 1/3 p2
6426 and of course r0 = p0, r3 = p2
6427 */
6428
6429 int contour, point = 0, first_pt;
6430 FT_Outline *outline = &ft_face->glyph->outline;
6431 TTPOLYGONHEADER *pph;
6432 TTPOLYCURVE *ppc;
6433 DWORD pph_start, cpfx, type;
6434 FT_Vector cubic_control[4];
6435 if(buflen == 0) buf = NULL;
6436
6437 if (needsTransform && buf) {
6438 pFT_Outline_Transform(outline, &transMat);
6439 }
6440
6441 for(contour = 0; contour < outline->n_contours; contour++) {
6442 pph_start = needed;
6443 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
6444 first_pt = point;
6445 if(buf) {
6446 pph->dwType = TT_POLYGON_TYPE;
6447 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
6448 }
6449 needed += sizeof(*pph);
6450 point++;
6451 while(point <= outline->contours[contour]) {
6452 ppc = (TTPOLYCURVE *)((char *)buf + needed);
6453 type = (outline->tags[point] & FT_Curve_Tag_On) ?
6454 TT_PRIM_LINE : TT_PRIM_CSPLINE;
6455 cpfx = 0;
6456 do {
6457 if(type == TT_PRIM_LINE) {
6458 if(buf)
6459 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
6460 cpfx++;
6461 point++;
6462 } else {
6463 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
6464 so cpfx = 3n */
6465
6466 /* FIXME: Possible optimization in endpoint calculation
6467 if there are two consecutive curves */
6468 cubic_control[0] = outline->points[point-1];
6469 if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
6470 cubic_control[0].x += outline->points[point].x + 1;
6471 cubic_control[0].y += outline->points[point].y + 1;
6472 cubic_control[0].x >>= 1;
6473 cubic_control[0].y >>= 1;
6474 }
6475 if(point+1 > outline->contours[contour])
6476 cubic_control[3] = outline->points[first_pt];
6477 else {
6478 cubic_control[3] = outline->points[point+1];
6479 if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
6480 cubic_control[3].x += outline->points[point].x + 1;
6481 cubic_control[3].y += outline->points[point].y + 1;
6482 cubic_control[3].x >>= 1;
6483 cubic_control[3].y >>= 1;
6484 }
6485 }
6486 /* r1 = 1/3 p0 + 2/3 p1
6487 r2 = 1/3 p2 + 2/3 p1 */
6488 cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
6489 cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
6490 cubic_control[2] = cubic_control[1];
6491 cubic_control[1].x += (cubic_control[0].x + 1) / 3;
6492 cubic_control[1].y += (cubic_control[0].y + 1) / 3;
6493 cubic_control[2].x += (cubic_control[3].x + 1) / 3;
6494 cubic_control[2].y += (cubic_control[3].y + 1) / 3;
6495 if(buf) {
6496 FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
6497 FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
6498 FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
6499 }
6500 cpfx += 3;
6501 point++;
6502 }
6503 } while(point <= outline->contours[contour] &&
6504 (outline->tags[point] & FT_Curve_Tag_On) ==
6505 (outline->tags[point-1] & FT_Curve_Tag_On));
6506 /* At the end of a contour Windows adds the start point,
6507 but only for Beziers and we've already done that.
6508 */
6509 if(point <= outline->contours[contour] &&
6510 outline->tags[point] & FT_Curve_Tag_On) {
6511 /* This is the closing pt of a bezier, but we've already
6512 added it, so just inc point and carry on */
6513 point++;
6514 }
6515 if(buf) {
6516 ppc->wType = type;
6517 ppc->cpfx = cpfx;
6518 }
6519 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
6520 }
6521 if(buf)
6522 pph->cb = needed - pph_start;
6523 }
6524 break;
6525 }
6526
6527 default:
6528 FIXME("Unsupported format %d\n", format);
6529 return GDI_ERROR;
6530 }
6531 return needed;
6532 }
6533
6534 static BOOL get_bitmap_text_metrics(GdiFont *font)
6535 {
6536 FT_Face ft_face = font->ft_face;
6537 FT_WinFNT_HeaderRec winfnt_header;
6538 const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
6539 font->potm = HeapAlloc(GetProcessHeap(), 0, size);
6540 font->potm->otmSize = size;
6541
6542 #define TM font->potm->otmTextMetrics
6543 if(!pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
6544 {
6545 TM.tmHeight = winfnt_header.pixel_height;
6546 TM.tmAscent = winfnt_header.ascent;
6547 TM.tmDescent = TM.tmHeight - TM.tmAscent;
6548 TM.tmInternalLeading = winfnt_header.internal_leading;
6549 TM.tmExternalLeading = winfnt_header.external_leading;
6550 TM.tmAveCharWidth = winfnt_header.avg_width;
6551 TM.tmMaxCharWidth = winfnt_header.max_width;
6552 TM.tmWeight = winfnt_header.weight;
6553 TM.tmOverhang = 0;
6554 TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
6555 TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
6556 TM.tmFirstChar = winfnt_header.first_char;
6557 TM.tmLastChar = winfnt_header.last_char;
6558 TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
6559 TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
6560 TM.tmItalic = winfnt_header.italic;
6561 TM.tmUnderlined = font->underline;
6562 TM.tmStruckOut = font->strikeout;
6563 TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
6564 TM.tmCharSet = winfnt_header.charset;
6565 }
6566 else
6567 {
6568 TM.tmAscent = ft_face->size->metrics.ascender >> 6;
6569 TM.tmDescent = -ft_face->size->metrics.descender >> 6;
6570 TM.tmHeight = TM.tmAscent + TM.tmDescent;
6571 TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
6572 TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
6573 TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
6574 TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
6575 TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
6576 TM.tmOverhang = 0;
6577 TM.tmDigitizedAspectX = 96; /* FIXME */
6578 TM.tmDigitizedAspectY = 96; /* FIXME */
6579 TM.tmFirstChar = 1;
6580 TM.tmLastChar = 255;
6581 TM.tmDefaultChar = 32;
6582 TM.tmBreakChar = 32;
6583 TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
6584 TM.tmUnderlined = font->underline;
6585 TM.tmStruckOut = font->strikeout;
6586 /* NB inverted meaning of TMPF_FIXED_PITCH */
6587 TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
6588 TM.tmCharSet = font->charset;
6589 }
6590 #undef TM
6591
6592 return TRUE;
6593 }
6594
6595
6596 static void scale_font_metrics(const GdiFont *font, LPTEXTMETRICW ptm)
6597 {
6598 double scale_x, scale_y;
6599
6600 if (font->aveWidth)
6601 {
6602 scale_x = (double)font->aveWidth;
6603 scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
6604 }
6605 else
6606 scale_x = font->scale_y;
6607
6608 scale_x *= fabs(font->font_desc.matrix.eM11);
6609 scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
6610
6611 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
6612 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
6613
6614 SCALE_Y(ptm->tmHeight);
6615 SCALE_Y(ptm->tmAscent);
6616 SCALE_Y(ptm->tmDescent);
6617 SCALE_Y(ptm->tmInternalLeading);
6618 SCALE_Y(ptm->tmExternalLeading);
6619 SCALE_Y(ptm->tmOverhang);
6620
6621 SCALE_X(ptm->tmAveCharWidth);
6622 SCALE_X(ptm->tmMaxCharWidth);
6623
6624 #undef SCALE_X
6625 #undef SCALE_Y
6626 }
6627
6628 static void scale_outline_font_metrics(const GdiFont *font, OUTLINETEXTMETRICW *potm)
6629 {
6630 double scale_x, scale_y;
6631
6632 if (font->aveWidth)
6633 {
6634 scale_x = (double)font->aveWidth;
6635 scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
6636 }
6637 else
6638 scale_x = font->scale_y;
6639
6640 scale_x *= fabs(font->font_desc.matrix.eM11);
6641 scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
6642
6643 scale_font_metrics(font, &potm->otmTextMetrics);
6644
6645 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
6646 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
6647
6648 SCALE_Y(potm->otmAscent);
6649 SCALE_Y(potm->otmDescent);
6650 SCALE_Y(potm->otmLineGap);
6651 SCALE_Y(potm->otmsCapEmHeight);
6652 SCALE_Y(potm->otmsXHeight);
6653 SCALE_Y(potm->otmrcFontBox.top);
6654 SCALE_Y(potm->otmrcFontBox.bottom);
6655 SCALE_X(potm->otmrcFontBox.left);
6656 SCALE_X(potm->otmrcFontBox.right);
6657 SCALE_Y(potm->otmMacAscent);
6658 SCALE_Y(potm->otmMacDescent);
6659 SCALE_Y(potm->otmMacLineGap);
6660 SCALE_X(potm->otmptSubscriptSize.x);
6661 SCALE_Y(potm->otmptSubscriptSize.y);
6662 SCALE_X(potm->otmptSubscriptOffset.x);
6663 SCALE_Y(potm->otmptSubscriptOffset.y);
6664 SCALE_X(potm->otmptSuperscriptSize.x);
6665 SCALE_Y(potm->otmptSuperscriptSize.y);
6666 SCALE_X(potm->otmptSuperscriptOffset.x);
6667 SCALE_Y(potm->otmptSuperscriptOffset.y);
6668 SCALE_Y(potm->otmsStrikeoutSize);
6669 SCALE_Y(potm->otmsStrikeoutPosition);
6670 SCALE_Y(potm->otmsUnderscoreSize);
6671 SCALE_Y(potm->otmsUnderscorePosition);
6672
6673 #undef SCALE_X
6674 #undef SCALE_Y
6675 }
6676
6677 static BOOL get_text_metrics(GdiFont *font, LPTEXTMETRICW ptm)
6678 {
6679 if(!font->potm)
6680 {
6681 if (!get_outline_text_metrics(font) && !get_bitmap_text_metrics(font)) return FALSE;
6682
6683 /* Make sure that the font has sane width/height ratio */
6684 if (font->aveWidth)
6685 {
6686 if ((font->aveWidth + font->potm->otmTextMetrics.tmHeight - 1) / font->potm->otmTextMetrics.tmHeight > 100)
6687 {
6688 WARN("Ignoring too large font->aveWidth %d\n", font->aveWidth);
6689 font->aveWidth = 0;
6690 }
6691 }
6692 }
6693 *ptm = font->potm->otmTextMetrics;
6694 scale_font_metrics(font, ptm);
6695 return TRUE;
6696 }
6697
6698 static BOOL face_has_symbol_charmap(FT_Face ft_face)
6699 {
6700 int i;
6701
6702 for(i = 0; i < ft_face->num_charmaps; i++)
6703 {
6704 if(ft_face->charmaps[i]->encoding == FT_ENCODING_MS_SYMBOL)
6705 return TRUE;
6706 }
6707 return FALSE;
6708 }
6709
6710 static BOOL get_outline_text_metrics(GdiFont *font)
6711 {
6712 BOOL ret = FALSE;
6713 FT_Face ft_face = font->ft_face;
6714 UINT needed, lenfam, lensty, lenface, lenfull;
6715 TT_OS2 *pOS2;
6716 TT_HoriHeader *pHori;
6717 TT_Postscript *pPost;
6718 FT_Fixed x_scale, y_scale;
6719 WCHAR *family_nameW, *style_nameW, *face_nameW, *full_nameW;
6720 char *cp;
6721 INT ascent, descent;
6722
6723 TRACE("font=%p\n", font);
6724
6725 if(!FT_IS_SCALABLE(ft_face))
6726 return FALSE;
6727
6728 needed = sizeof(*font->potm);
6729
6730 lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
6731 family_nameW = strdupW(font->name);
6732
6733 style_nameW = get_face_name( ft_face, TT_NAME_ID_FONT_SUBFAMILY, GetSystemDefaultLangID() );
6734 if (!style_nameW)
6735 style_nameW = get_face_name( ft_face, TT_NAME_ID_FONT_SUBFAMILY, TT_MS_LANGID_ENGLISH_UNITED_STATES );
6736 if (!style_nameW)
6737 {
6738 FIXME("failed to read style_nameW for font %s!\n", wine_dbgstr_w(font->name));
6739 style_nameW = towstr( CP_ACP, ft_face->style_name );
6740 }
6741 lensty = (strlenW(style_nameW) + 1) * sizeof(WCHAR);
6742
6743 face_nameW = get_face_name( ft_face, TT_NAME_ID_FULL_NAME, GetSystemDefaultLangID() );
6744 if (!face_nameW)
6745 face_nameW = get_face_name( ft_face, TT_NAME_ID_FULL_NAME, TT_MS_LANGID_ENGLISH_UNITED_STATES );
6746 if (!face_nameW)
6747 {
6748 FIXME("failed to read face_nameW for font %s!\n", wine_dbgstr_w(font->name));
6749 face_nameW = strdupW(font->name);
6750 }
6751 if (font->name[0] == '@') face_nameW = prepend_at( face_nameW );
6752 lenface = (strlenW(face_nameW) + 1) * sizeof(WCHAR);
6753
6754 full_nameW = get_face_name( ft_face, TT_NAME_ID_UNIQUE_ID, GetSystemDefaultLangID() );
6755 if (!full_nameW)
6756 full_nameW = get_face_name( ft_face, TT_NAME_ID_UNIQUE_ID, TT_MS_LANGID_ENGLISH_UNITED_STATES );
6757 if (!full_nameW)
6758 {
6759 WCHAR fake_nameW[] = {'f','a','k','e',' ','n','a','m','e', 0};
6760 FIXME("failed to read full_nameW for font %s!\n", wine_dbgstr_w(font->name));
6761 full_nameW = strdupW(fake_nameW);
6762 }
6763 lenfull = (strlenW(full_nameW) + 1) * sizeof(WCHAR);
6764
6765 /* These names should be read from the TT name table */
6766
6767 /* length of otmpFamilyName */
6768 needed += lenfam;
6769
6770 /* length of otmpFaceName */
6771 needed += lenface;
6772
6773 /* length of otmpStyleName */
6774 needed += lensty;
6775
6776 /* length of otmpFullName */
6777 needed += lenfull;
6778
6779
6780 x_scale = ft_face->size->metrics.x_scale;
6781 y_scale = ft_face->size->metrics.y_scale;
6782
6783 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
6784 if(!pOS2) {
6785 FIXME("Can't find OS/2 table - not TT font?\n");
6786 goto end;
6787 }
6788
6789 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
6790 if(!pHori) {
6791 FIXME("Can't find HHEA table - not TT font?\n");
6792 goto end;
6793 }
6794
6795 pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
6796
6797 TRACE("OS/2 winA = %d winD = %d typoA = %d typoD = %d typoLG = %d avgW %d FT_Face a = %d, d = %d, h = %d: HORZ a = %d, d = %d lg = %d maxY = %ld minY = %ld\n",
6798 pOS2->usWinAscent, pOS2->usWinDescent,
6799 pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
6800 pOS2->xAvgCharWidth,
6801 ft_face->ascender, ft_face->descender, ft_face->height,
6802 pHori->Ascender, pHori->Descender, pHori->Line_Gap,
6803 ft_face->bbox.yMax, ft_face->bbox.yMin);
6804
6805 font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
6806 font->potm->otmSize = needed;
6807
6808 #define TM font->potm->otmTextMetrics
6809
6810 if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
6811 ascent = pHori->Ascender;
6812 descent = -pHori->Descender;
6813 } else {
6814 ascent = pOS2->usWinAscent;
6815 descent = pOS2->usWinDescent;
6816 }
6817
6818 font->ntmCellHeight = ascent + descent;
6819 font->ntmAvgWidth = pOS2->xAvgCharWidth;
6820
6821 if(font->yMax) {
6822 TM.tmAscent = font->yMax;
6823 TM.tmDescent = -font->yMin;
6824 TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
6825 } else {
6826 TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
6827 TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
6828 TM.tmInternalLeading = (pFT_MulFix(ascent + descent
6829 - ft_face->units_per_EM, y_scale) + 32) >> 6;
6830 }
6831
6832 TM.tmHeight = TM.tmAscent + TM.tmDescent;
6833
6834 /* MSDN says:
6835 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
6836 */
6837 TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
6838 ((ascent + descent) -
6839 (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
6840
6841 TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
6842 if (TM.tmAveCharWidth == 0) {
6843 TM.tmAveCharWidth = 1;
6844 }
6845 TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
6846 TM.tmWeight = FW_REGULAR;
6847 if (font->fake_bold)
6848 TM.tmWeight = FW_BOLD;
6849 else
6850 {
6851 if (ft_face->style_flags & FT_STYLE_FLAG_BOLD)
6852 {
6853 if (pOS2->usWeightClass > FW_MEDIUM)
6854 TM.tmWeight = pOS2->usWeightClass;
6855 }
6856 else if (pOS2->usWeightClass <= FW_MEDIUM)
6857 TM.tmWeight = pOS2->usWeightClass;
6858 }
6859 TM.tmOverhang = 0;
6860 TM.tmDigitizedAspectX = 96; /* FIXME */
6861 TM.tmDigitizedAspectY = 96; /* FIXME */
6862 /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
6863 * symbol range to 0 - f0ff
6864 */
6865
6866 if (face_has_symbol_charmap(ft_face) || (pOS2->usFirstCharIndex >= 0xf000 && pOS2->usFirstCharIndex < 0xf100))
6867 {
6868 TM.tmFirstChar = 0;
6869 switch(GetACP())
6870 {
6871 case 1257: /* Baltic */
6872 TM.tmLastChar = 0xf8fd;
6873 break;
6874 default:
6875 TM.tmLastChar = 0xf0ff;
6876 }
6877 TM.tmBreakChar = 0x20;
6878 TM.tmDefaultChar = 0x1f;
6879 }
6880 else
6881 {
6882 TM.tmFirstChar = pOS2->usFirstCharIndex; /* Should be the first char in the cmap */
6883 TM.tmLastChar = pOS2->usLastCharIndex; /* Should be min(cmap_last, os2_last) */
6884
6885 if(pOS2->usFirstCharIndex <= 1)
6886 TM.tmBreakChar = pOS2->usFirstCharIndex + 2;
6887 else if (pOS2->usFirstCharIndex > 0xff)
6888 TM.tmBreakChar = 0x20;
6889 else
6890 TM.tmBreakChar = pOS2->usFirstCharIndex;
6891 TM.tmDefaultChar = TM.tmBreakChar - 1;
6892 }
6893 TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
6894 TM.tmUnderlined = font->underline;
6895 TM.tmStruckOut = font->strikeout;
6896
6897 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
6898 if(!FT_IS_FIXED_WIDTH(ft_face) &&
6899 (pOS2->version == 0xFFFFU ||
6900 pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
6901 TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
6902 else
6903 TM.tmPitchAndFamily = 0;
6904
6905 switch(pOS2->panose[PAN_FAMILYTYPE_INDEX])
6906 {
6907 case PAN_FAMILY_SCRIPT:
6908 TM.tmPitchAndFamily |= FF_SCRIPT;
6909 break;
6910
6911 case PAN_FAMILY_DECORATIVE:
6912 TM.tmPitchAndFamily |= FF_DECORATIVE;
6913 break;
6914
6915 case PAN_ANY:
6916 case PAN_NO_FIT:
6917 case PAN_FAMILY_TEXT_DISPLAY:
6918 case PAN_FAMILY_PICTORIAL: /* symbol fonts get treated as if they were text */
6919 /* which is clearly not what the panose spec says. */
6920 default:
6921 if(TM.tmPitchAndFamily == 0 || /* fixed */
6922 pOS2->panose[PAN_PROPORTION_INDEX] == PAN_PROP_MONOSPACED)
6923 TM.tmPitchAndFamily = FF_MODERN;
6924 else
6925 {
6926 switch(pOS2->panose[PAN_SERIFSTYLE_INDEX])
6927 {
6928 case PAN_ANY:
6929 case PAN_NO_FIT:
6930 default:
6931 TM.tmPitchAndFamily |= FF_DONTCARE;
6932 break;
6933
6934 case PAN_SERIF_COVE:
6935 case PAN_SERIF_OBTUSE_COVE:
6936 case PAN_SERIF_SQUARE_COVE:
6937 case PAN_SERIF_OBTUSE_SQUARE_COVE:
6938 case PAN_SERIF_SQUARE:
6939 case PAN_SERIF_THIN:
6940 case PAN_SERIF_BONE:
6941 case PAN_SERIF_EXAGGERATED:
6942 case PAN_SERIF_TRIANGLE:
6943 TM.tmPitchAndFamily |= FF_ROMAN;
6944 break;
6945
6946 case PAN_SERIF_NORMAL_SANS:
6947 case PAN_SERIF_OBTUSE_SANS:
6948 case PAN_SERIF_PERP_SANS:
6949 case PAN_SERIF_FLARED:
6950 case PAN_SERIF_ROUNDED:
6951 TM.tmPitchAndFamily |= FF_SWISS;
6952 break;
6953 }
6954 }
6955 break;
6956 }
6957
6958 if(FT_IS_SCALABLE(ft_face))
6959 TM.tmPitchAndFamily |= TMPF_VECTOR;
6960
6961 if(FT_IS_SFNT(ft_face))
6962 {
6963 if (font->ntmFlags & NTM_PS_OPENTYPE)
6964 TM.tmPitchAndFamily |= TMPF_DEVICE;
6965 else
6966 TM.tmPitchAndFamily |= TMPF_TRUETYPE;
6967 }
6968
6969 TM.tmCharSet = font->charset;
6970
6971 font->potm->otmFiller = 0;
6972 memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
6973 font->potm->otmfsSelection = pOS2->fsSelection;
6974 font->potm->otmfsType = pOS2->fsType;
6975 font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
6976 font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
6977 font->potm->otmItalicAngle = 0; /* POST table */
6978 font->potm->otmEMSquare = ft_face->units_per_EM;
6979 font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
6980 font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
6981 font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
6982 font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
6983 font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
6984 font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
6985 font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
6986 font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
6987 font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
6988 font->potm->otmMacAscent = TM.tmAscent;
6989 font->potm->otmMacDescent = -TM.tmDescent;
6990 font->potm->otmMacLineGap = font->potm->otmLineGap;
6991 font->potm->otmusMinimumPPEM = 0; /* TT Header */
6992 font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
6993 font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
6994 font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
6995 font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
6996 font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
6997 font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
6998 font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
6999 font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
7000 font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
7001 font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
7002 if(!pPost) {
7003 font->potm->otmsUnderscoreSize = 0;
7004 font->potm->otmsUnderscorePosition = 0;
7005 } else {
7006 font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
7007 font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
7008 }
7009 #undef TM
7010
7011 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
7012 cp = (char*)font->potm + sizeof(*font->potm);
7013 font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
7014 strcpyW((WCHAR*)cp, family_nameW);
7015 cp += lenfam;
7016 font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
7017 strcpyW((WCHAR*)cp, style_nameW);
7018 cp += lensty;
7019 font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
7020 strcpyW((WCHAR*)cp, face_nameW);
7021 cp += lenface;
7022 font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
7023 strcpyW((WCHAR*)cp, full_nameW);
7024 ret = TRUE;
7025
7026 end:
7027 HeapFree(GetProcessHeap(), 0, style_nameW);
7028 HeapFree(GetProcessHeap(), 0, family_nameW);
7029 HeapFree(GetProcessHeap(), 0, face_nameW);
7030 HeapFree(GetProcessHeap(), 0, full_nameW);
7031 return ret;
7032 }
7033
7034 /*************************************************************
7035 * freetype_GetGlyphOutline
7036 */
7037 static DWORD freetype_GetGlyphOutline( PHYSDEV dev, UINT glyph, UINT format,
7038 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf, const MAT2 *lpmat )
7039 {
7040 struct freetype_physdev *physdev = get_freetype_dev( dev );
7041 DWORD ret;
7042 ABC abc;
7043
7044 if (!physdev->font)
7045 {
7046 dev = GET_NEXT_PHYSDEV( dev, pGetGlyphOutline );
7047 return dev->funcs->pGetGlyphOutline( dev, glyph, format, lpgm, buflen, buf, lpmat );
7048 }
7049
7050 GDI_CheckNotLock();
7051 EnterCriticalSection( &freetype_cs );
7052 ret = get_glyph_outline( physdev->font, glyph, format, lpgm, &abc, buflen, buf, lpmat );
7053 LeaveCriticalSection( &freetype_cs );
7054 return ret;
7055 }
7056
7057 /*************************************************************
7058 * freetype_GetTextMetrics
7059 */
7060 static BOOL freetype_GetTextMetrics( PHYSDEV dev, TEXTMETRICW *metrics )
7061 {
7062 struct freetype_physdev *physdev = get_freetype_dev( dev );
7063 BOOL ret;
7064
7065 if (!physdev->font)
7066 {
7067 dev = GET_NEXT_PHYSDEV( dev, pGetTextMetrics );
7068 return dev->funcs->pGetTextMetrics( dev, metrics );
7069 }
7070
7071 GDI_CheckNotLock();
7072 EnterCriticalSection( &freetype_cs );
7073 ret = get_text_metrics( physdev->font, metrics );
7074 LeaveCriticalSection( &freetype_cs );
7075 return ret;
7076 }
7077
7078 /*************************************************************
7079 * freetype_GetOutlineTextMetrics
7080 */
7081 static UINT freetype_GetOutlineTextMetrics( PHYSDEV dev, UINT cbSize, OUTLINETEXTMETRICW *potm )
7082 {
7083 struct freetype_physdev *physdev = get_freetype_dev( dev );
7084 UINT ret = 0;
7085
7086 if (!physdev->font)
7087 {
7088 dev = GET_NEXT_PHYSDEV( dev, pGetOutlineTextMetrics );
7089 return dev->funcs->pGetOutlineTextMetrics( dev, cbSize, potm );
7090 }
7091
7092 TRACE("font=%p\n", physdev->font);
7093
7094 if (!FT_IS_SCALABLE( physdev->font->ft_face )) return 0;
7095
7096 GDI_CheckNotLock();
7097 EnterCriticalSection( &freetype_cs );
7098
7099 if (physdev->font->potm || get_outline_text_metrics( physdev->font ))
7100 {
7101 if(cbSize >= physdev->font->potm->otmSize)
7102 {
7103 memcpy(potm, physdev->font->potm, physdev->font->potm->otmSize);
7104 scale_outline_font_metrics(physdev->font, potm);
7105 }
7106 ret = physdev->font->potm->otmSize;
7107 }
7108 LeaveCriticalSection( &freetype_cs );
7109 return ret;
7110 }
7111
7112 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
7113 {
7114 child->font = alloc_font();
7115 child->font->ft_face = OpenFontFace(child->font, child->face, 0, -font->ppem);
7116 if(!child->font->ft_face)
7117 {
7118 free_font(child->font);
7119 child->font = NULL;
7120 return FALSE;
7121 }
7122
7123 child->font->font_desc = font->font_desc;
7124 child->font->ntmFlags = child->face->ntmFlags;
7125 child->font->orientation = font->orientation;
7126 child->font->scale_y = font->scale_y;
7127 child->font->name = strdupW(child->face->family->FamilyName);
7128 child->font->base_font = font;
7129 TRACE("created child font %p for base %p\n", child->font, font);
7130 return TRUE;
7131 }
7132
7133 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
7134 {
7135 FT_UInt g;
7136 CHILD_FONT *child_font;
7137
7138 if(font->base_font)
7139 font = font->base_font;
7140
7141 *linked_font = font;
7142
7143 if((*glyph = get_glyph_index(font, c)))
7144 {
7145 *glyph = get_GSUB_vert_glyph(font, *glyph);
7146 return TRUE;
7147 }
7148
7149 LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
7150 {
7151 if(!child_font->font)
7152 if(!load_child_font(font, child_font))
7153 continue;
7154
7155 if(!child_font->font->ft_face)
7156 continue;
7157 g = get_glyph_index(child_font->font, c);
7158 g = get_GSUB_vert_glyph(child_font->font, g);
7159 if(g)
7160 {
7161 *glyph = g;
7162 *linked_font = child_font->font;
7163 return TRUE;
7164 }
7165 }
7166 return FALSE;
7167 }
7168
7169 /*************************************************************
7170 * freetype_GetCharWidth
7171 */
7172 static BOOL freetype_GetCharWidth( PHYSDEV dev, UINT firstChar, UINT lastChar, LPINT buffer )
7173 {
7174 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7175 UINT c;
7176 GLYPHMETRICS gm;
7177 ABC abc;
7178 struct freetype_physdev *physdev = get_freetype_dev( dev );
7179
7180 if (!physdev->font)
7181 {
7182 dev = GET_NEXT_PHYSDEV( dev, pGetCharWidth );
7183 return dev->funcs->pGetCharWidth( dev, firstChar, lastChar, buffer );
7184 }
7185
7186 TRACE("%p, %d, %d, %p\n", physdev->font, firstChar, lastChar, buffer);
7187
7188 GDI_CheckNotLock();
7189 EnterCriticalSection( &freetype_cs );
7190 for(c = firstChar; c <= lastChar; c++) {
7191 get_glyph_outline( physdev->font, c, GGO_METRICS, &gm, &abc, 0, NULL, &identity );
7192 buffer[c - firstChar] = abc.abcA + abc.abcB + abc.abcC;
7193 }
7194 LeaveCriticalSection( &freetype_cs );
7195 return TRUE;
7196 }
7197
7198 /*************************************************************
7199 * freetype_GetCharABCWidths
7200 */
7201 static BOOL freetype_GetCharABCWidths( PHYSDEV dev, UINT firstChar, UINT lastChar, LPABC buffer )
7202 {
7203 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7204 UINT c;
7205 GLYPHMETRICS gm;
7206 struct freetype_physdev *physdev = get_freetype_dev( dev );
7207
7208 if (!physdev->font)
7209 {
7210 dev = GET_NEXT_PHYSDEV( dev, pGetCharABCWidths );
7211 return dev->funcs->pGetCharABCWidths( dev, firstChar, lastChar, buffer );
7212 }
7213
7214 TRACE("%p, %d, %d, %p\n", physdev->font, firstChar, lastChar, buffer);
7215
7216 GDI_CheckNotLock();
7217 EnterCriticalSection( &freetype_cs );
7218
7219 for(c = firstChar; c <= lastChar; c++, buffer++)
7220 get_glyph_outline( physdev->font, c, GGO_METRICS, &gm, buffer, 0, NULL, &identity );
7221
7222 LeaveCriticalSection( &freetype_cs );
7223 return TRUE;
7224 }
7225
7226 /*************************************************************
7227 * freetype_GetCharABCWidthsI
7228 */
7229 static BOOL freetype_GetCharABCWidthsI( PHYSDEV dev, UINT firstChar, UINT count, LPWORD pgi, LPABC buffer )
7230 {
7231 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7232 UINT c;
7233 GLYPHMETRICS gm;
7234 struct freetype_physdev *physdev = get_freetype_dev( dev );
7235
7236 if (!physdev->font)
7237 {
7238 dev = GET_NEXT_PHYSDEV( dev, pGetCharABCWidthsI );
7239 return dev->funcs->pGetCharABCWidthsI( dev, firstChar, count, pgi, buffer );
7240 }
7241
7242 if(!FT_HAS_HORIZONTAL(physdev->font->ft_face))
7243 return FALSE;
7244
7245 GDI_CheckNotLock();
7246 EnterCriticalSection( &freetype_cs );
7247
7248 for(c = 0; c < count; c++, buffer++)
7249 get_glyph_outline( physdev->font, pgi ? pgi[c] : firstChar + c, GGO_METRICS | GGO_GLYPH_INDEX,
7250 &gm, buffer, 0, NULL, &identity );
7251
7252 LeaveCriticalSection( &freetype_cs );
7253 return TRUE;
7254 }
7255
7256 /*************************************************************
7257 * freetype_GetTextExtentExPoint
7258 */
7259 static BOOL freetype_GetTextExtentExPoint( PHYSDEV dev, LPCWSTR wstr, INT count, LPINT dxs )
7260 {
7261 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7262 INT idx, pos;
7263 ABC abc;
7264 GLYPHMETRICS gm;
7265 struct freetype_physdev *physdev = get_freetype_dev( dev );
7266
7267 if (!physdev->font)
7268 {
7269 dev = GET_NEXT_PHYSDEV( dev, pGetTextExtentExPoint );
7270 return dev->funcs->pGetTextExtentExPoint( dev, wstr, count, dxs );
7271 }
7272
7273 TRACE("%p, %s, %d\n", physdev->font, debugstr_wn(wstr, count), count);
7274
7275 GDI_CheckNotLock();
7276 EnterCriticalSection( &freetype_cs );
7277
7278 for (idx = pos = 0; idx < count; idx++)
7279 {
7280 get_glyph_outline( physdev->font, wstr[idx], GGO_METRICS, &gm, &abc, 0, NULL, &identity );
7281 pos += abc.abcA + abc.abcB + abc.abcC;
7282 dxs[idx] = pos;
7283 }
7284
7285 LeaveCriticalSection( &freetype_cs );
7286 return TRUE;
7287 }
7288
7289 /*************************************************************
7290 * freetype_GetTextExtentExPointI
7291 */
7292 static BOOL freetype_GetTextExtentExPointI( PHYSDEV dev, const WORD *indices, INT count, LPINT dxs )
7293 {
7294 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7295 INT idx, pos;
7296 ABC abc;
7297 GLYPHMETRICS gm;
7298 struct freetype_physdev *physdev = get_freetype_dev( dev );
7299
7300 if (!physdev->font)
7301 {
7302 dev = GET_NEXT_PHYSDEV( dev, pGetTextExtentExPointI );
7303 return dev->funcs->pGetTextExtentExPointI( dev, indices, count, dxs );
7304 }
7305
7306 TRACE("%p, %p, %d\n", physdev->font, indices, count);
7307
7308 GDI_CheckNotLock();
7309 EnterCriticalSection( &freetype_cs );
7310
7311 for (idx = pos = 0; idx < count; idx++)
7312 {
7313 get_glyph_outline( physdev->font, indices[idx], GGO_METRICS | GGO_GLYPH_INDEX,
7314 &gm, &abc, 0, NULL, &identity );
7315 pos += abc.abcA + abc.abcB + abc.abcC;
7316 dxs[idx] = pos;
7317 }
7318
7319 LeaveCriticalSection( &freetype_cs );
7320 return TRUE;
7321 }
7322
7323 /*************************************************************
7324 * freetype_GetFontData
7325 */
7326 static DWORD freetype_GetFontData( PHYSDEV dev, DWORD table, DWORD offset, LPVOID buf, DWORD cbData )
7327 {
7328 struct freetype_physdev *physdev = get_freetype_dev( dev );
7329
7330 if (!physdev->font)
7331 {
7332 dev = GET_NEXT_PHYSDEV( dev, pGetFontData );
7333 return dev->funcs->pGetFontData( dev, table, offset, buf, cbData );
7334 }
7335
7336 TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
7337 physdev->font, LOBYTE(LOWORD(table)), HIBYTE(LOWORD(table)),
7338 LOBYTE(HIWORD(table)), HIBYTE(HIWORD(table)), offset, buf, cbData);
7339
7340 return get_font_data( physdev->font, table, offset, buf, cbData );
7341 }
7342
7343 /*************************************************************
7344 * freetype_GetTextFace
7345 */
7346 static INT freetype_GetTextFace( PHYSDEV dev, INT count, LPWSTR str )
7347 {
7348 INT n;
7349 struct freetype_physdev *physdev = get_freetype_dev( dev );
7350
7351 if (!physdev->font)
7352 {
7353 dev = GET_NEXT_PHYSDEV( dev, pGetTextFace );
7354 return dev->funcs->pGetTextFace( dev, count, str );
7355 }
7356
7357 n = strlenW(physdev->font->name) + 1;
7358 if (str)
7359 {
7360 lstrcpynW(str, physdev->font->name, count);
7361 n = min(count, n);
7362 }
7363 return n;
7364 }
7365
7366 /*************************************************************
7367 * freetype_GetTextCharsetInfo
7368 */
7369 static UINT freetype_GetTextCharsetInfo( PHYSDEV dev, LPFONTSIGNATURE fs, DWORD flags )
7370 {
7371 struct freetype_physdev *physdev = get_freetype_dev( dev );
7372
7373 if (!physdev->font)
7374 {
7375 dev = GET_NEXT_PHYSDEV( dev, pGetTextCharsetInfo );
7376 return dev->funcs->pGetTextCharsetInfo( dev, fs, flags );
7377 }
7378 if (fs) *fs = physdev->font->fs;
7379 return physdev->font->charset;
7380 }
7381
7382 /* Retrieve a list of supported Unicode ranges for a given font.
7383 * Can be called with NULL gs to calculate the buffer size. Returns
7384 * the number of ranges found.
7385 */
7386 static DWORD get_font_unicode_ranges(FT_Face face, GLYPHSET *gs)
7387 {
7388 DWORD num_ranges = 0;
7389
7390 if (face->charmap->encoding == FT_ENCODING_UNICODE)
7391 {
7392 FT_UInt glyph_code;
7393 FT_ULong char_code, char_code_prev;
7394
7395 glyph_code = 0;
7396 char_code_prev = char_code = pFT_Get_First_Char(face, &glyph_code);
7397
7398 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
7399 face->num_glyphs, glyph_code, char_code);
7400
7401 if (!glyph_code) return 0;
7402
7403 if (gs)
7404 {
7405 gs->ranges[0].wcLow = (USHORT)char_code;
7406 gs->ranges[0].cGlyphs = 0;
7407 gs->cGlyphsSupported = 0;
7408 }
7409
7410 num_ranges = 1;
7411 while (glyph_code)
7412 {
7413 if (char_code < char_code_prev)
7414 {
7415 ERR("expected increasing char code from FT_Get_Next_Char\n");
7416 return 0;
7417 }
7418 if (char_code - char_code_prev > 1)
7419 {
7420 num_ranges++;
7421 if (gs)
7422 {
7423 gs->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
7424 gs->ranges[num_ranges - 1].cGlyphs = 1;
7425 gs->cGlyphsSupported++;
7426 }
7427 }
7428 else if (gs)
7429 {
7430 gs->ranges[num_ranges - 1].cGlyphs++;
7431 gs->cGlyphsSupported++;
7432 }
7433 char_code_prev = char_code;
7434 char_code = pFT_Get_Next_Char(face, char_code, &glyph_code);
7435 }
7436 }
7437 else
7438 FIXME("encoding %u not supported\n", face->charmap->encoding);
7439
7440 return num_ranges;
7441 }
7442
7443 /*************************************************************
7444 * freetype_GetFontUnicodeRanges
7445 */
7446 static DWORD freetype_GetFontUnicodeRanges( PHYSDEV dev, LPGLYPHSET glyphset )
7447 {
7448 struct freetype_physdev *physdev = get_freetype_dev( dev );
7449 DWORD size, num_ranges;
7450
7451 if (!physdev->font)
7452 {
7453 dev = GET_NEXT_PHYSDEV( dev, pGetFontUnicodeRanges );
7454 return dev->funcs->pGetFontUnicodeRanges( dev, glyphset );
7455 }
7456
7457 num_ranges = get_font_unicode_ranges(physdev->font->ft_face, glyphset);
7458 size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
7459 if (glyphset)
7460 {
7461 glyphset->cbThis = size;
7462 glyphset->cRanges = num_ranges;
7463 glyphset->flAccel = 0;
7464 }
7465 return size;
7466 }
7467
7468 /*************************************************************
7469 * freetype_FontIsLinked
7470 */
7471 static BOOL freetype_FontIsLinked( PHYSDEV dev )
7472 {
7473 struct freetype_physdev *physdev = get_freetype_dev( dev );
7474 BOOL ret;
7475
7476 if (!physdev->font)
7477 {
7478 dev = GET_NEXT_PHYSDEV( dev, pFontIsLinked );
7479 return dev->funcs->pFontIsLinked( dev );
7480 }
7481
7482 GDI_CheckNotLock();
7483 EnterCriticalSection( &freetype_cs );
7484 ret = !list_empty(&physdev->font->child_fonts);
7485 LeaveCriticalSection( &freetype_cs );
7486 return ret;
7487 }
7488
7489 /*************************************************************************
7490 * GetRasterizerCaps (GDI32.@)
7491 */
7492 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
7493 {
7494 lprs->nSize = sizeof(RASTERIZER_STATUS);
7495 lprs->wFlags = TT_AVAILABLE | TT_ENABLED;
7496 lprs->nLanguageID = 0;
7497 return TRUE;
7498 }
7499
7500 /*************************************************************
7501 * freetype_GdiRealizationInfo
7502 */
7503 static BOOL freetype_GdiRealizationInfo( PHYSDEV dev, void *ptr )
7504 {
7505 struct freetype_physdev *physdev = get_freetype_dev( dev );
7506 realization_info_t *info = ptr;
7507
7508 if (!physdev->font)
7509 {
7510 dev = GET_NEXT_PHYSDEV( dev, pGdiRealizationInfo );
7511 return dev->funcs->pGdiRealizationInfo( dev, ptr );
7512 }
7513
7514 FIXME("(%p, %p): stub!\n", physdev->font, info);
7515
7516 info->flags = 1;
7517 if(FT_IS_SCALABLE(physdev->font->ft_face))
7518 info->flags |= 2;
7519
7520 info->cache_num = physdev->font->cache_num;
7521 info->unknown2 = -1;
7522 return TRUE;
7523 }
7524
7525 /*************************************************************************
7526 * Kerning support for TrueType fonts
7527 */
7528 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
7529
7530 struct TT_kern_table
7531 {
7532 USHORT version;
7533 USHORT nTables;
7534 };
7535
7536 struct TT_kern_subtable
7537 {
7538 USHORT version;
7539 USHORT length;
7540 union
7541 {
7542 USHORT word;
7543 struct
7544 {
7545 USHORT horizontal : 1;
7546 USHORT minimum : 1;
7547 USHORT cross_stream: 1;
7548 USHORT override : 1;
7549 USHORT reserved1 : 4;
7550 USHORT format : 8;
7551 } bits;
7552 } coverage;
7553 };
7554
7555 struct TT_format0_kern_subtable
7556 {
7557 USHORT nPairs;
7558 USHORT searchRange;
7559 USHORT entrySelector;
7560 USHORT rangeShift;
7561 };
7562
7563 struct TT_kern_pair
7564 {
7565 USHORT left;
7566 USHORT right;
7567 short value;
7568 };
7569
7570 static DWORD parse_format0_kern_subtable(GdiFont *font,
7571 const struct TT_format0_kern_subtable *tt_f0_ks,
7572 const USHORT *glyph_to_char,
7573 KERNINGPAIR *kern_pair, DWORD cPairs)
7574 {
7575 USHORT i, nPairs;
7576 const struct TT_kern_pair *tt_kern_pair;
7577
7578 TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
7579
7580 nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
7581
7582 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
7583 nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
7584 GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
7585
7586 if (!kern_pair || !cPairs)
7587 return nPairs;
7588
7589 tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
7590
7591 nPairs = min(nPairs, cPairs);
7592
7593 for (i = 0; i < nPairs; i++)
7594 {
7595 kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
7596 kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
7597 /* this algorithm appears to better match what Windows does */
7598 kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
7599 if (kern_pair->iKernAmount < 0)
7600 {
7601 kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
7602 kern_pair->iKernAmount -= font->ppem;
7603 }
7604 else if (kern_pair->iKernAmount > 0)
7605 {
7606 kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
7607 kern_pair->iKernAmount += font->ppem;
7608 }
7609 kern_pair->iKernAmount /= font->ft_face->units_per_EM;
7610
7611 TRACE("left %u right %u value %d\n",
7612 kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
7613
7614 kern_pair++;
7615 }
7616 TRACE("copied %u entries\n", nPairs);
7617 return nPairs;
7618 }
7619
7620 /*************************************************************
7621 * freetype_GetKerningPairs
7622 */
7623 static DWORD freetype_GetKerningPairs( PHYSDEV dev, DWORD cPairs, KERNINGPAIR *kern_pair )
7624 {
7625 DWORD length;
7626 void *buf;
7627 const struct TT_kern_table *tt_kern_table;
7628 const struct TT_kern_subtable *tt_kern_subtable;
7629 USHORT i, nTables;
7630 USHORT *glyph_to_char;
7631 GdiFont *font;
7632 struct freetype_physdev *physdev = get_freetype_dev( dev );
7633
7634 if (!(font = physdev->font))
7635 {
7636 dev = GET_NEXT_PHYSDEV( dev, pGetKerningPairs );
7637 return dev->funcs->pGetKerningPairs( dev, cPairs, kern_pair );
7638 }
7639
7640 GDI_CheckNotLock();
7641 EnterCriticalSection( &freetype_cs );
7642 if (font->total_kern_pairs != (DWORD)-1)
7643 {
7644 if (cPairs && kern_pair)
7645 {
7646 cPairs = min(cPairs, font->total_kern_pairs);
7647 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
7648 }
7649 else cPairs = font->total_kern_pairs;
7650
7651 LeaveCriticalSection( &freetype_cs );
7652 return cPairs;
7653 }
7654
7655 font->total_kern_pairs = 0;
7656
7657 length = get_font_data(font, MS_KERN_TAG, 0, NULL, 0);
7658
7659 if (length == GDI_ERROR)
7660 {
7661 TRACE("no kerning data in the font\n");
7662 LeaveCriticalSection( &freetype_cs );
7663 return 0;
7664 }
7665
7666 buf = HeapAlloc(GetProcessHeap(), 0, length);
7667 if (!buf)
7668 {
7669 WARN("Out of memory\n");
7670 LeaveCriticalSection( &freetype_cs );
7671 return 0;
7672 }
7673
7674 get_font_data(font, MS_KERN_TAG, 0, buf, length);
7675
7676 /* build a glyph index to char code map */
7677 glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
7678 if (!glyph_to_char)
7679 {
7680 WARN("Out of memory allocating a glyph index to char code map\n");
7681 HeapFree(GetProcessHeap(), 0, buf);
7682 LeaveCriticalSection( &freetype_cs );
7683 return 0;
7684 }
7685
7686 if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE)
7687 {
7688 FT_UInt glyph_code;
7689 FT_ULong char_code;
7690
7691 glyph_code = 0;
7692 char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
7693
7694 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
7695 font->ft_face->num_glyphs, glyph_code, char_code);
7696
7697 while (glyph_code)
7698 {
7699 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
7700
7701 /* FIXME: This doesn't match what Windows does: it does some fancy
7702 * things with duplicate glyph index to char code mappings, while
7703 * we just avoid overriding existing entries.
7704 */
7705 if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
7706 glyph_to_char[glyph_code] = (USHORT)char_code;
7707
7708 char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
7709 }
7710 }
7711 else
7712 {
7713 ULONG n;
7714
7715 FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
7716 for (n = 0; n <= 65535; n++)
7717 glyph_to_char[n] = (USHORT)n;
7718 }
7719
7720 tt_kern_table = buf;
7721 nTables = GET_BE_WORD(tt_kern_table->nTables);
7722 TRACE("version %u, nTables %u\n",
7723 GET_BE_WORD(tt_kern_table->version), nTables);
7724
7725 tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
7726
7727 for (i = 0; i < nTables; i++)
7728 {
7729 struct TT_kern_subtable tt_kern_subtable_copy;
7730
7731 tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
7732 tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
7733 tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
7734
7735 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
7736 tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
7737 tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
7738
7739 /* According to the TrueType specification this is the only format
7740 * that will be properly interpreted by Windows and OS/2
7741 */
7742 if (tt_kern_subtable_copy.coverage.bits.format == 0)
7743 {
7744 DWORD new_chunk, old_total = font->total_kern_pairs;
7745
7746 new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
7747 glyph_to_char, NULL, 0);
7748 font->total_kern_pairs += new_chunk;
7749
7750 if (!font->kern_pairs)
7751 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
7752 font->total_kern_pairs * sizeof(*font->kern_pairs));
7753 else
7754 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
7755 font->total_kern_pairs * sizeof(*font->kern_pairs));
7756
7757 parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
7758 glyph_to_char, font->kern_pairs + old_total, new_chunk);
7759 }
7760 else
7761 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
7762
7763 tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
7764 }
7765
7766 HeapFree(GetProcessHeap(), 0, glyph_to_char);
7767 HeapFree(GetProcessHeap(), 0, buf);
7768
7769 if (cPairs && kern_pair)
7770 {
7771 cPairs = min(cPairs, font->total_kern_pairs);
7772 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
7773 }
7774 else cPairs = font->total_kern_pairs;
7775
7776 LeaveCriticalSection( &freetype_cs );
7777 return cPairs;
7778 }
7779
7780 static const struct gdi_dc_funcs freetype_funcs =
7781 {
7782 NULL, /* pAbortDoc */
7783 NULL, /* pAbortPath */
7784 NULL, /* pAlphaBlend */
7785 NULL, /* pAngleArc */
7786 NULL, /* pArc */
7787 NULL, /* pArcTo */
7788 NULL, /* pBeginPath */
7789 NULL, /* pBlendImage */
7790 NULL, /* pChord */
7791 NULL, /* pCloseFigure */
7792 NULL, /* pCreateCompatibleDC */
7793 freetype_CreateDC, /* pCreateDC */
7794 freetype_DeleteDC, /* pDeleteDC */
7795 NULL, /* pDeleteObject */
7796 NULL, /* pDeviceCapabilities */
7797 NULL, /* pEllipse */
7798 NULL, /* pEndDoc */
7799 NULL, /* pEndPage */
7800 NULL, /* pEndPath */
7801 freetype_EnumFonts, /* pEnumFonts */
7802 NULL, /* pEnumICMProfiles */
7803 NULL, /* pExcludeClipRect */
7804 NULL, /* pExtDeviceMode */
7805 NULL, /* pExtEscape */
7806 NULL, /* pExtFloodFill */
7807 NULL, /* pExtSelectClipRgn */
7808 NULL, /* pExtTextOut */
7809 NULL, /* pFillPath */
7810 NULL, /* pFillRgn */
7811 NULL, /* pFlattenPath */
7812 freetype_FontIsLinked, /* pFontIsLinked */
7813 NULL, /* pFrameRgn */
7814 NULL, /* pGdiComment */
7815 freetype_GdiRealizationInfo, /* pGdiRealizationInfo */
7816 NULL, /* pGetBoundsRect */
7817 freetype_GetCharABCWidths, /* pGetCharABCWidths */
7818 freetype_GetCharABCWidthsI, /* pGetCharABCWidthsI */
7819 freetype_GetCharWidth, /* pGetCharWidth */
7820 NULL, /* pGetDeviceCaps */
7821 NULL, /* pGetDeviceGammaRamp */
7822 freetype_GetFontData, /* pGetFontData */
7823 freetype_GetFontUnicodeRanges, /* pGetFontUnicodeRanges */
7824 freetype_GetGlyphIndices, /* pGetGlyphIndices */
7825 freetype_GetGlyphOutline, /* pGetGlyphOutline */
7826 NULL, /* pGetICMProfile */
7827 NULL, /* pGetImage */
7828 freetype_GetKerningPairs, /* pGetKerningPairs */
7829 NULL, /* pGetNearestColor */
7830 freetype_GetOutlineTextMetrics, /* pGetOutlineTextMetrics */
7831 NULL, /* pGetPixel */
7832 NULL, /* pGetSystemPaletteEntries */
7833 freetype_GetTextCharsetInfo, /* pGetTextCharsetInfo */
7834 freetype_GetTextExtentExPoint, /* pGetTextExtentExPoint */
7835 freetype_GetTextExtentExPointI, /* pGetTextExtentExPointI */
7836 freetype_GetTextFace, /* pGetTextFace */
7837 freetype_GetTextMetrics, /* pGetTextMetrics */
7838 NULL, /* pGradientFill */
7839 NULL, /* pIntersectClipRect */
7840 NULL, /* pInvertRgn */
7841 NULL, /* pLineTo */
7842 NULL, /* pModifyWorldTransform */
7843 NULL, /* pMoveTo */
7844 NULL, /* pOffsetClipRgn */
7845 NULL, /* pOffsetViewportOrg */
7846 NULL, /* pOffsetWindowOrg */
7847 NULL, /* pPaintRgn */
7848 NULL, /* pPatBlt */
7849 NULL, /* pPie */
7850 NULL, /* pPolyBezier */
7851 NULL, /* pPolyBezierTo */
7852 NULL, /* pPolyDraw */
7853 NULL, /* pPolyPolygon */
7854 NULL, /* pPolyPolyline */
7855 NULL, /* pPolygon */
7856 NULL, /* pPolyline */
7857 NULL, /* pPolylineTo */
7858 NULL, /* pPutImage */
7859 NULL, /* pRealizeDefaultPalette */
7860 NULL, /* pRealizePalette */
7861 NULL, /* pRectangle */
7862 NULL, /* pResetDC */
7863 NULL, /* pRestoreDC */
7864 NULL, /* pRoundRect */
7865 NULL, /* pSaveDC */
7866 NULL, /* pScaleViewportExt */
7867 NULL, /* pScaleWindowExt */
7868 NULL, /* pSelectBitmap */
7869 NULL, /* pSelectBrush */
7870 NULL, /* pSelectClipPath */
7871 freetype_SelectFont, /* pSelectFont */
7872 NULL, /* pSelectPalette */
7873 NULL, /* pSelectPen */
7874 NULL, /* pSetArcDirection */
7875 NULL, /* pSetBkColor */
7876 NULL, /* pSetBkMode */
7877 NULL, /* pSetDCBrushColor */
7878 NULL, /* pSetDCPenColor */
7879 NULL, /* pSetDIBColorTable */
7880 NULL, /* pSetDIBitsToDevice */
7881 NULL, /* pSetDeviceClipping */
7882 NULL, /* pSetDeviceGammaRamp */
7883 NULL, /* pSetLayout */
7884 NULL, /* pSetMapMode */
7885 NULL, /* pSetMapperFlags */
7886 NULL, /* pSetPixel */
7887 NULL, /* pSetPolyFillMode */
7888 NULL, /* pSetROP2 */
7889 NULL, /* pSetRelAbs */
7890 NULL, /* pSetStretchBltMode */
7891 NULL, /* pSetTextAlign */
7892 NULL, /* pSetTextCharacterExtra */
7893 NULL, /* pSetTextColor */
7894 NULL, /* pSetTextJustification */
7895 NULL, /* pSetViewportExt */
7896 NULL, /* pSetViewportOrg */
7897 NULL, /* pSetWindowExt */
7898 NULL, /* pSetWindowOrg */
7899 NULL, /* pSetWorldTransform */
7900 NULL, /* pStartDoc */
7901 NULL, /* pStartPage */
7902 NULL, /* pStretchBlt */
7903 NULL, /* pStretchDIBits */
7904 NULL, /* pStrokeAndFillPath */
7905 NULL, /* pStrokePath */
7906 NULL, /* pUnrealizePalette */
7907 NULL, /* pWidenPath */
7908 NULL, /* wine_get_wgl_driver */
7909 GDI_PRIORITY_FONT_DRV /* priority */
7910 };
7911
7912 #else /* HAVE_FREETYPE */
7913
7914 /*************************************************************************/
7915
7916 BOOL WineEngInit(void)
7917 {
7918 return FALSE;
7919 }
7920
7921 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
7922 {
7923 FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
7924 return 1;
7925 }
7926
7927 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
7928 {
7929 FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
7930 return TRUE;
7931 }
7932
7933 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
7934 {
7935 FIXME("(%p, %u, %p, %p): stub\n", pbFont, cbFont, pdv, pcFonts);
7936 return NULL;
7937 }
7938
7939 BOOL WineEngCreateScalableFontResource( DWORD hidden, LPCWSTR resource,
7940 LPCWSTR font_file, LPCWSTR font_path )
7941 {
7942 FIXME("stub\n");
7943 return FALSE;
7944 }
7945
7946 /*************************************************************************
7947 * GetRasterizerCaps (GDI32.@)
7948 */
7949 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
7950 {
7951 lprs->nSize = sizeof(RASTERIZER_STATUS);
7952 lprs->wFlags = 0;
7953 lprs->nLanguageID = 0;
7954 return TRUE;
7955 }
7956
7957 #endif /* HAVE_FREETYPE */
Windows API implementation