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