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