?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Fix a build failure on Mac OS X.
[wine/multimedia.git] / dlls / gdi32 / freetype.c
blobef2f152053db63d361bb35de0c3ab347bd6e73d7
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 CHAR familyA[400];
1884
1885 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1886 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
1887 {
1888 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1889 &valuelen, &datalen, NULL, NULL);
1890
1891 valuelen++; /* returned value doesn't include room for '\0' */
1892 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1893 data = HeapAlloc(GetProcessHeap(), 0, datalen);
1894
1895 dlen = datalen;
1896 vlen = valuelen;
1897 while(RegEnumValueW(hkey, i++, value, &vlen, NULL, &type, data,
1898 &dlen) == ERROR_SUCCESS) {
1899 TRACE("Got %s=%s\n", debugstr_w(value), debugstr_w(data));
1900 /* "NewName"="Oldname" */
1901 WideCharToMultiByte(CP_ACP, 0, value, -1, familyA, sizeof(familyA), NULL, NULL);
1902
1903 if(!find_family_from_any_name(value))
1904 {
1905 /* Find the old family and hence all of the font files
1906 in that family */
1907 const Family * const family = find_family_from_any_name(data);
1908 if (family != NULL)
1909 {
1910 const struct list *face_elem_ptr;
1911 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1912 const Face * const face = LIST_ENTRY(face_elem_ptr, Face, entry);
1913 TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
1914 debugstr_w(face->StyleName), familyA);
1915 /* Now add a new entry with the new family name */
1916 AddFontToList(face->file, face->font_data_ptr, face->font_data_size,
1917 familyA, family->FamilyName,
1918 ADDFONT_FORCE_BITMAP | (face->external ? ADDFONT_EXTERNAL_FONT : 0));
1919 }
1920 }
1921 else
1922 {
1923 TRACE("%s is not available. Skip this replacement.\n", debugstr_w(data));
1924 }
1925 }
1926 else
1927 {
1928 TRACE("%s is available. Skip this replacement.\n", debugstr_w(value));
1929 }
1930 /* reset dlen and vlen */
1931 dlen = datalen;
1932 vlen = valuelen;
1933 }
1934 HeapFree(GetProcessHeap(), 0, data);
1935 HeapFree(GetProcessHeap(), 0, value);
1936 RegCloseKey(hkey);
1937 }
1938 }
1939
1940 static const WCHAR *font_links_list[] =
1941 {
1942 Lucida_Sans_Unicode,
1943 Microsoft_Sans_Serif,
1944 Tahoma
1945 };
1946
1947 static const struct font_links_defaults_list
1948 {
1949 /* Keyed off substitution for "MS Shell Dlg" */
1950 const WCHAR *shelldlg;
1951 /* Maximum of four substitutes, plus terminating NULL pointer */
1952 const WCHAR *substitutes[5];
1953 } font_links_defaults_list[] =
1954 {
1955 /* Non East-Asian */
1956 { Tahoma, /* FIXME unverified ordering */
1957 { MS_UI_Gothic, SimSun, Gulim, PMingLiU, NULL }
1958 },
1959 /* Below lists are courtesy of
1960 * http://blogs.msdn.com/michkap/archive/2005/06/18/430507.aspx
1961 */
1962 /* Japanese */
1963 { MS_UI_Gothic,
1964 { MS_UI_Gothic, PMingLiU, SimSun, Gulim, NULL }
1965 },
1966 /* Chinese Simplified */
1967 { SimSun,
1968 { SimSun, PMingLiU, MS_UI_Gothic, Batang, NULL }
1969 },
1970 /* Korean */
1971 { Gulim,
1972 { Gulim, PMingLiU, MS_UI_Gothic, SimSun, NULL }
1973 },
1974 /* Chinese Traditional */
1975 { PMingLiU,
1976 { PMingLiU, SimSun, MS_UI_Gothic, Batang, NULL }
1977 }
1978 };
1979
1980
1981 static void populate_system_links(const WCHAR *name, const WCHAR *const *values)
1982 {
1983 const WCHAR *value;
1984 int i;
1985 FontSubst *psub;
1986 Family *family;
1987 Face *face;
1988 const char *file;
1989 WCHAR *fileW;
1990 FONTSIGNATURE fs;
1991
1992 if (values)
1993 {
1994 SYSTEM_LINKS *font_link;
1995 BOOL existing = FALSE;
1996
1997 memset(&fs, 0, sizeof(fs));
1998 psub = get_font_subst(&font_subst_list, name, -1);
1999 /* Don't store fonts that are only substitutes for other fonts */
2000 if(psub)
2001 {
2002 TRACE("%s: Internal SystemLink entry for substituted font, ignoring\n", debugstr_w(name));
2003 return;
2004 }
2005
2006 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2007 {
2008 if(!strcmpiW(font_link->font_name, name))
2009 {
2010 existing = TRUE;
2011 break;
2012 }
2013 }
2014
2015 if (!existing)
2016 {
2017 font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
2018 font_link->font_name = strdupW(name);
2019 list_init(&font_link->links);
2020 }
2021
2022 for (i = 0; values[i] != NULL; i++)
2023 {
2024 CHILD_FONT *child_font;
2025
2026 value = values[i];
2027 if (!strcmpiW(name,value))
2028 continue;
2029 psub = get_font_subst(&font_subst_list, value, -1);
2030 if(psub)
2031 value = psub->to.name;
2032 family = find_family_from_name(value);
2033 if (!family)
2034 continue;
2035 file = NULL;
2036 /* Use first extant filename for this Family */
2037 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
2038 {
2039 if (!face->file)
2040 continue;
2041 file = strrchr(face->file, '/');
2042 if (!file)
2043 file = face->file;
2044 else
2045 file++;
2046 break;
2047 }
2048 if (!file)
2049 continue;
2050 fileW = towstr(CP_UNIXCP, file);
2051
2052 face = find_face_from_filename(fileW, value);
2053 if(!face)
2054 {
2055 TRACE("Unable to find file %s face name %s\n", debugstr_w(fileW), debugstr_w(value));
2056 continue;
2057 }
2058
2059 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2060 child_font->face = face;
2061 child_font->font = NULL;
2062 fs.fsCsb[0] |= face->fs.fsCsb[0];
2063 fs.fsCsb[1] |= face->fs.fsCsb[1];
2064 TRACE("Adding file %s index %ld\n", child_font->face->file, child_font->face->face_index);
2065 list_add_tail(&font_link->links, &child_font->entry);
2066
2067 TRACE("added internal SystemLink for %s to %s in %s\n", debugstr_w(name), debugstr_w(value),debugstr_w(fileW));
2068 HeapFree(GetProcessHeap(), 0, fileW);
2069 }
2070
2071 family = find_family_from_name(font_link->font_name);
2072 if(family)
2073 {
2074 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
2075 {
2076 face->fs_links = fs;
2077 }
2078 }
2079 if (!existing)
2080 list_add_tail(&system_links, &font_link->entry);
2081 }
2082 }
2083
2084
2085 /*************************************************************
2086 * init_system_links
2087 */
2088 static BOOL init_system_links(void)
2089 {
2090 HKEY hkey;
2091 BOOL ret = FALSE;
2092 DWORD type, max_val, max_data, val_len, data_len, index;
2093 WCHAR *value, *data;
2094 WCHAR *entry, *next;
2095 SYSTEM_LINKS *font_link, *system_font_link;
2096 CHILD_FONT *child_font;
2097 static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
2098 static const WCHAR System[] = {'S','y','s','t','e','m',0};
2099 static const WCHAR MS_Shell_Dlg[] = {'M','S',' ','S','h','e','l','l',' ','D','l','g',0};
2100 FONTSIGNATURE fs;
2101 Family *family;
2102 Face *face;
2103 FontSubst *psub;
2104 UINT i, j;
2105
2106 if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
2107 {
2108 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
2109 value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
2110 data = HeapAlloc(GetProcessHeap(), 0, max_data);
2111 val_len = max_val + 1;
2112 data_len = max_data;
2113 index = 0;
2114 while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
2115 {
2116 memset(&fs, 0, sizeof(fs));
2117 psub = get_font_subst(&font_subst_list, value, -1);
2118 /* Don't store fonts that are only substitutes for other fonts */
2119 if(psub)
2120 {
2121 TRACE("%s: SystemLink entry for substituted font, ignoring\n", debugstr_w(value));
2122 goto next;
2123 }
2124 font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
2125 font_link->font_name = strdupW(value);
2126 list_init(&font_link->links);
2127 for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
2128 {
2129 WCHAR *face_name;
2130 CHILD_FONT *child_font;
2131
2132 TRACE("%s: %s\n", debugstr_w(value), debugstr_w(entry));
2133
2134 next = entry + strlenW(entry) + 1;
2135
2136 face_name = strchrW(entry, ',');
2137 if(face_name)
2138 {
2139 *face_name++ = 0;
2140 while(isspaceW(*face_name))
2141 face_name++;
2142
2143 psub = get_font_subst(&font_subst_list, face_name, -1);
2144 if(psub)
2145 face_name = psub->to.name;
2146 }
2147 face = find_face_from_filename(entry, face_name);
2148 if(!face)
2149 {
2150 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
2151 continue;
2152 }
2153
2154 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2155 child_font->face = face;
2156 child_font->font = NULL;
2157 fs.fsCsb[0] |= face->fs.fsCsb[0];
2158 fs.fsCsb[1] |= face->fs.fsCsb[1];
2159 TRACE("Adding file %s index %ld\n", child_font->face->file, child_font->face->face_index);
2160 list_add_tail(&font_link->links, &child_font->entry);
2161 }
2162 family = find_family_from_name(font_link->font_name);
2163 if(family)
2164 {
2165 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
2166 {
2167 face->fs_links = fs;
2168 }
2169 }
2170 list_add_tail(&system_links, &font_link->entry);
2171 next:
2172 val_len = max_val + 1;
2173 data_len = max_data;
2174 }
2175
2176 HeapFree(GetProcessHeap(), 0, value);
2177 HeapFree(GetProcessHeap(), 0, data);
2178 RegCloseKey(hkey);
2179 }
2180
2181
2182 psub = get_font_subst(&font_subst_list, MS_Shell_Dlg, -1);
2183 if (!psub) {
2184 WARN("could not find FontSubstitute for MS Shell Dlg\n");
2185 goto skip_internal;
2186 }
2187
2188 for (i = 0; i < sizeof(font_links_defaults_list)/sizeof(font_links_defaults_list[0]); i++)
2189 {
2190 const FontSubst *psub2;
2191 psub2 = get_font_subst(&font_subst_list, font_links_defaults_list[i].shelldlg, -1);
2192
2193 if ((!strcmpiW(font_links_defaults_list[i].shelldlg, psub->to.name) || (psub2 && !strcmpiW(psub2->to.name,psub->to.name))))
2194 {
2195 for (j = 0; j < sizeof(font_links_list)/sizeof(font_links_list[0]); j++)
2196 populate_system_links(font_links_list[j], font_links_defaults_list[i].substitutes);
2197
2198 if (!strcmpiW(psub->to.name, font_links_defaults_list[i].substitutes[0]))
2199 populate_system_links(psub->to.name, font_links_defaults_list[i].substitutes);
2200 }
2201 else if (strcmpiW(psub->to.name, font_links_defaults_list[i].substitutes[0]))
2202 {
2203 populate_system_links(font_links_defaults_list[i].substitutes[0], NULL);
2204 }
2205 }
2206
2207 skip_internal:
2208
2209 /* Explicitly add an entry for the system font, this links to Tahoma and any links
2210 that Tahoma has */
2211
2212 system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
2213 system_font_link->font_name = strdupW(System);
2214 list_init(&system_font_link->links);
2215 memset(&fs, 0, sizeof(fs));
2216
2217 face = find_face_from_filename(tahoma_ttf, Tahoma);
2218 if(face)
2219 {
2220 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2221 child_font->face = face;
2222 child_font->font = NULL;
2223 fs.fsCsb[0] |= face->fs.fsCsb[0];
2224 fs.fsCsb[1] |= face->fs.fsCsb[1];
2225 TRACE("Found Tahoma in %s index %ld\n", child_font->face->file, child_font->face->face_index);
2226 list_add_tail(&system_font_link->links, &child_font->entry);
2227 }
2228 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2229 {
2230 if(!strcmpiW(font_link->font_name, Tahoma))
2231 {
2232 CHILD_FONT *font_link_entry;
2233 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2234 {
2235 CHILD_FONT *new_child;
2236 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
2237 new_child->face = font_link_entry->face;
2238 new_child->font = NULL;
2239 fs.fsCsb[0] |= font_link_entry->face->fs.fsCsb[0];
2240 fs.fsCsb[1] |= font_link_entry->face->fs.fsCsb[1];
2241 list_add_tail(&system_font_link->links, &new_child->entry);
2242 }
2243 break;
2244 }
2245 }
2246 family = find_family_from_name(system_font_link->font_name);
2247 if(family)
2248 {
2249 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
2250 {
2251 face->fs_links = fs;
2252 }
2253 }
2254 list_add_tail(&system_links, &system_font_link->entry);
2255 return ret;
2256 }
2257
2258 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
2259 {
2260 DIR *dir;
2261 struct dirent *dent;
2262 char path[MAX_PATH];
2263
2264 TRACE("Loading fonts from %s\n", debugstr_a(dirname));
2265
2266 dir = opendir(dirname);
2267 if(!dir) {
2268 WARN("Can't open directory %s\n", debugstr_a(dirname));
2269 return FALSE;
2270 }
2271 while((dent = readdir(dir)) != NULL) {
2272 struct stat statbuf;
2273
2274 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
2275 continue;
2276
2277 TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
2278
2279 sprintf(path, "%s/%s", dirname, dent->d_name);
2280
2281 if(stat(path, &statbuf) == -1)
2282 {
2283 WARN("Can't stat %s\n", debugstr_a(path));
2284 continue;
2285 }
2286 if(S_ISDIR(statbuf.st_mode))
2287 ReadFontDir(path, external_fonts);
2288 else
2289 {
2290 DWORD addfont_flags = ADDFONT_ADD_TO_CACHE;
2291 if(external_fonts) addfont_flags |= ADDFONT_EXTERNAL_FONT;
2292 AddFontFileToList(path, NULL, NULL, addfont_flags);
2293 }
2294 }
2295 closedir(dir);
2296 return TRUE;
2297 }
2298
2299 #ifdef SONAME_LIBFONTCONFIG
2300 static void load_fontconfig_fonts(void)
2301 {
2302 void *fc_handle = NULL;
2303 FcConfig *config;
2304 FcPattern *pat;
2305 FcObjectSet *os;
2306 FcFontSet *fontset;
2307 int i, len;
2308 char *file;
2309 const char *ext;
2310
2311 fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
2312 if(!fc_handle) {
2313 TRACE("Wine cannot find the fontconfig library (%s).\n",
2314 SONAME_LIBFONTCONFIG);
2315 return;
2316 }
2317 #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;}
2318 LOAD_FUNCPTR(FcConfigGetCurrent);
2319 LOAD_FUNCPTR(FcFontList);
2320 LOAD_FUNCPTR(FcFontSetDestroy);
2321 LOAD_FUNCPTR(FcInit);
2322 LOAD_FUNCPTR(FcObjectSetAdd);
2323 LOAD_FUNCPTR(FcObjectSetCreate);
2324 LOAD_FUNCPTR(FcObjectSetDestroy);
2325 LOAD_FUNCPTR(FcPatternCreate);
2326 LOAD_FUNCPTR(FcPatternDestroy);
2327 LOAD_FUNCPTR(FcPatternGetBool);
2328 LOAD_FUNCPTR(FcPatternGetString);
2329 #undef LOAD_FUNCPTR
2330
2331 if(!pFcInit()) return;
2332
2333 config = pFcConfigGetCurrent();
2334 pat = pFcPatternCreate();
2335 os = pFcObjectSetCreate();
2336 pFcObjectSetAdd(os, FC_FILE);
2337 pFcObjectSetAdd(os, FC_SCALABLE);
2338 fontset = pFcFontList(config, pat, os);
2339 if(!fontset) return;
2340 for(i = 0; i < fontset->nfont; i++) {
2341 FcBool scalable;
2342
2343 if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
2344 continue;
2345 TRACE("fontconfig: %s\n", file);
2346
2347 /* We're just interested in OT/TT fonts for now, so this hack just
2348 picks up the scalable fonts without extensions .pf[ab] to save time
2349 loading every other font */
2350
2351 if(pFcPatternGetBool(fontset->fonts[i], FC_SCALABLE, 0, &scalable) == FcResultMatch && !scalable)
2352 {
2353 TRACE("not scalable\n");
2354 continue;
2355 }
2356
2357 len = strlen( file );
2358 if(len < 4) continue;
2359 ext = &file[ len - 3 ];
2360 if(strcasecmp(ext, "pfa") && strcasecmp(ext, "pfb"))
2361 AddFontFileToList(file, NULL, NULL, ADDFONT_EXTERNAL_FONT | ADDFONT_ADD_TO_CACHE);
2362 }
2363 pFcFontSetDestroy(fontset);
2364 pFcObjectSetDestroy(os);
2365 pFcPatternDestroy(pat);
2366 sym_not_found:
2367 return;
2368 }
2369
2370 #elif defined(HAVE_CARBON_CARBON_H)
2371
2372 static void load_mac_font_callback(const void *value, void *context)
2373 {
2374 CFStringRef pathStr = value;
2375 CFIndex len;
2376 char* path;
2377
2378 len = CFStringGetMaximumSizeOfFileSystemRepresentation(pathStr);
2379 path = HeapAlloc(GetProcessHeap(), 0, len);
2380 if (path && CFStringGetFileSystemRepresentation(pathStr, path, len))
2381 {
2382 TRACE("font file %s\n", path);
2383 AddFontFileToList(path, NULL, NULL, ADDFONT_EXTERNAL_FONT | ADDFONT_ADD_TO_CACHE);
2384 }
2385 HeapFree(GetProcessHeap(), 0, path);
2386 }
2387
2388 static void load_mac_fonts(void)
2389 {
2390 CFStringRef removeDupesKey;
2391 CFBooleanRef removeDupesValue;
2392 CFDictionaryRef options;
2393 CTFontCollectionRef col;
2394 CFArrayRef descs;
2395 CFMutableSetRef paths;
2396 CFIndex i;
2397
2398 removeDupesKey = kCTFontCollectionRemoveDuplicatesOption;
2399 removeDupesValue = kCFBooleanTrue;
2400 options = CFDictionaryCreate(NULL, (const void**)&removeDupesKey, (const void**)&removeDupesValue, 1,
2401 &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
2402 col = CTFontCollectionCreateFromAvailableFonts(options);
2403 if (options) CFRelease(options);
2404 if (!col)
2405 {
2406 WARN("CTFontCollectionCreateFromAvailableFonts failed\n");
2407 return;
2408 }
2409
2410 descs = CTFontCollectionCreateMatchingFontDescriptors(col);
2411 CFRelease(col);
2412 if (!descs)
2413 {
2414 WARN("CTFontCollectionCreateMatchingFontDescriptors failed\n");
2415 return;
2416 }
2417
2418 paths = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
2419 if (!paths)
2420 {
2421 WARN("CFSetCreateMutable failed\n");
2422 CFRelease(descs);
2423 return;
2424 }
2425
2426 for (i = 0; i < CFArrayGetCount(descs); i++)
2427 {
2428 CTFontDescriptorRef desc;
2429 CTFontRef font;
2430 ATSFontRef atsFont;
2431 OSStatus status;
2432 FSRef fsref;
2433 CFURLRef url;
2434 CFStringRef ext;
2435 CFStringRef path;
2436
2437 desc = CFArrayGetValueAtIndex(descs, i);
2438
2439 /* CTFontDescriptor doesn't support kCTFontURLAttribute until 10.6, so
2440 we have to go CFFontDescriptor -> CTFont -> ATSFont -> FSRef -> CFURL. */
2441 font = CTFontCreateWithFontDescriptor(desc, 0, NULL);
2442 if (!font) continue;
2443
2444 atsFont = CTFontGetPlatformFont(font, NULL);
2445 if (!atsFont)
2446 {
2447 CFRelease(font);
2448 continue;
2449 }
2450
2451 status = ATSFontGetFileReference(atsFont, &fsref);
2452 CFRelease(font);
2453 if (status != noErr) continue;
2454
2455 url = CFURLCreateFromFSRef(NULL, &fsref);
2456 if (!url) continue;
2457
2458 ext = CFURLCopyPathExtension(url);
2459 if (ext)
2460 {
2461 BOOL skip = (CFStringCompare(ext, CFSTR("pfa"), kCFCompareCaseInsensitive) == kCFCompareEqualTo ||
2462 CFStringCompare(ext, CFSTR("pfb"), kCFCompareCaseInsensitive) == kCFCompareEqualTo);
2463 CFRelease(ext);
2464 if (skip)
2465 {
2466 CFRelease(url);
2467 continue;
2468 }
2469 }
2470
2471 path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
2472 CFRelease(url);
2473 if (!path) continue;
2474
2475 CFSetAddValue(paths, path);
2476 CFRelease(path);
2477 }
2478
2479 CFRelease(descs);
2480
2481 CFSetApplyFunction(paths, load_mac_font_callback, NULL);
2482 CFRelease(paths);
2483 }
2484
2485 #endif
2486
2487 static BOOL load_font_from_data_dir(LPCWSTR file)
2488 {
2489 BOOL ret = FALSE;
2490 const char *data_dir = wine_get_data_dir();
2491
2492 if (!data_dir) data_dir = wine_get_build_dir();
2493
2494 if (data_dir)
2495 {
2496 INT len;
2497 char *unix_name;
2498
2499 len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
2500
2501 unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
2502
2503 strcpy(unix_name, data_dir);
2504 strcat(unix_name, "/fonts/");
2505
2506 WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
2507
2508 EnterCriticalSection( &freetype_cs );
2509 ret = AddFontFileToList(unix_name, NULL, NULL, ADDFONT_FORCE_BITMAP | ADDFONT_ADD_TO_CACHE);
2510 LeaveCriticalSection( &freetype_cs );
2511 HeapFree(GetProcessHeap(), 0, unix_name);
2512 }
2513 return ret;
2514 }
2515
2516 static BOOL load_font_from_winfonts_dir(LPCWSTR file)
2517 {
2518 static const WCHAR slashW[] = {'\\','\0'};
2519 BOOL ret = FALSE;
2520 WCHAR windowsdir[MAX_PATH];
2521 char *unixname;
2522
2523 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2524 strcatW(windowsdir, fontsW);
2525 strcatW(windowsdir, slashW);
2526 strcatW(windowsdir, file);
2527 if ((unixname = wine_get_unix_file_name(windowsdir))) {
2528 EnterCriticalSection( &freetype_cs );
2529 ret = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2530 LeaveCriticalSection( &freetype_cs );
2531 HeapFree(GetProcessHeap(), 0, unixname);
2532 }
2533 return ret;
2534 }
2535
2536 static void load_system_fonts(void)
2537 {
2538 HKEY hkey;
2539 WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
2540 const WCHAR * const *value;
2541 DWORD dlen, type;
2542 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
2543 char *unixname;
2544
2545 if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
2546 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2547 strcatW(windowsdir, fontsW);
2548 for(value = SystemFontValues; *value; value++) {
2549 dlen = sizeof(data);
2550 if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
2551 type == REG_SZ) {
2552 BOOL added = FALSE;
2553
2554 sprintfW(pathW, fmtW, windowsdir, data);
2555 if((unixname = wine_get_unix_file_name(pathW))) {
2556 added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP | ADDFONT_ADD_TO_CACHE);
2557 HeapFree(GetProcessHeap(), 0, unixname);
2558 }
2559 if (!added)
2560 load_font_from_data_dir(data);
2561 }
2562 }
2563 RegCloseKey(hkey);
2564 }
2565 }
2566
2567 /*************************************************************
2568 *
2569 * This adds registry entries for any externally loaded fonts
2570 * (fonts from fontconfig or FontDirs). It also deletes entries
2571 * of no longer existing fonts.
2572 *
2573 */
2574 static void update_reg_entries(void)
2575 {
2576 HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
2577 LPWSTR valueW;
2578 DWORD len, len_fam;
2579 Family *family;
2580 Face *face;
2581 struct list *family_elem_ptr, *face_elem_ptr;
2582 WCHAR *file;
2583 static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
2584 static const WCHAR spaceW[] = {' ', '\0'};
2585 char *path;
2586
2587 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
2588 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
2589 ERR("Can't create Windows font reg key\n");
2590 goto end;
2591 }
2592
2593 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
2594 0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
2595 ERR("Can't create Windows font reg key\n");
2596 goto end;
2597 }
2598
2599 if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
2600 0, NULL, 0, KEY_ALL_ACCESS, NULL, &external_key, NULL) != ERROR_SUCCESS) {
2601 ERR("Can't create external font reg key\n");
2602 goto end;
2603 }
2604
2605 /* enumerate the fonts and add external ones to the two keys */
2606
2607 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2608 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2609 len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
2610 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2611 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2612 if(!face->external) continue;
2613 len = len_fam;
2614 if (!(face->ntmFlags & NTM_REGULAR))
2615 len = len_fam + strlenW(face->StyleName) + 1;
2616 valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2617 strcpyW(valueW, family->FamilyName);
2618 if(len != len_fam) {
2619 strcatW(valueW, spaceW);
2620 strcatW(valueW, face->StyleName);
2621 }
2622 strcatW(valueW, TrueType);
2623
2624 file = wine_get_dos_file_name(face->file);
2625 if(file)
2626 len = strlenW(file) + 1;
2627 else
2628 {
2629 if((path = strrchr(face->file, '/')) == NULL)
2630 path = face->file;
2631 else
2632 path++;
2633 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
2634
2635 file = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2636 MultiByteToWideChar(CP_ACP, 0, path, -1, file, len);
2637 }
2638 RegSetValueExW(winnt_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2639 RegSetValueExW(win9x_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2640 RegSetValueExW(external_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2641
2642 HeapFree(GetProcessHeap(), 0, file);
2643 HeapFree(GetProcessHeap(), 0, valueW);
2644 }
2645 }
2646 end:
2647 if(external_key) RegCloseKey(external_key);
2648 if(win9x_key) RegCloseKey(win9x_key);
2649 if(winnt_key) RegCloseKey(winnt_key);
2650 return;
2651 }
2652
2653 static void delete_external_font_keys(void)
2654 {
2655 HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
2656 DWORD dlen, vlen, datalen, valuelen, i, type;
2657 LPWSTR valueW;
2658 LPVOID data;
2659
2660 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
2661 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
2662 ERR("Can't create Windows font reg key\n");
2663 goto end;
2664 }
2665
2666 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
2667 0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
2668 ERR("Can't create Windows font reg key\n");
2669 goto end;
2670 }
2671
2672 if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &external_key) != ERROR_SUCCESS) {
2673 ERR("Can't create external font reg key\n");
2674 goto end;
2675 }
2676
2677 /* Delete all external fonts added last time */
2678
2679 RegQueryInfoKeyW(external_key, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2680 &valuelen, &datalen, NULL, NULL);
2681 valuelen++; /* returned value doesn't include room for '\0' */
2682 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2683 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
2684
2685 dlen = datalen * sizeof(WCHAR);
2686 vlen = valuelen;
2687 i = 0;
2688 while(RegEnumValueW(external_key, i++, valueW, &vlen, NULL, &type, data,
2689 &dlen) == ERROR_SUCCESS) {
2690
2691 RegDeleteValueW(winnt_key, valueW);
2692 RegDeleteValueW(win9x_key, valueW);
2693 /* reset dlen and vlen */
2694 dlen = datalen;
2695 vlen = valuelen;
2696 }
2697 HeapFree(GetProcessHeap(), 0, data);
2698 HeapFree(GetProcessHeap(), 0, valueW);
2699
2700 /* Delete the old external fonts key */
2701 RegCloseKey(external_key);
2702 RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
2703
2704 end:
2705 if(win9x_key) RegCloseKey(win9x_key);
2706 if(winnt_key) RegCloseKey(winnt_key);
2707 }
2708
2709 /*************************************************************
2710 * WineEngAddFontResourceEx
2711 *
2712 */
2713 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2714 {
2715 INT ret = 0;
2716
2717 GDI_CheckNotLock();
2718
2719 if (ft_handle) /* do it only if we have freetype up and running */
2720 {
2721 char *unixname;
2722
2723 if(flags)
2724 FIXME("Ignoring flags %x\n", flags);
2725
2726 if((unixname = wine_get_unix_file_name(file)))
2727 {
2728 DWORD addfont_flags = ADDFONT_FORCE_BITMAP;
2729
2730 if(!(flags & FR_PRIVATE)) addfont_flags |= ADDFONT_ADD_TO_CACHE;
2731 EnterCriticalSection( &freetype_cs );
2732 ret = AddFontFileToList(unixname, NULL, NULL, addfont_flags);
2733 LeaveCriticalSection( &freetype_cs );
2734 HeapFree(GetProcessHeap(), 0, unixname);
2735 }
2736 if (!ret && !strchrW(file, '\\')) {
2737 /* Try in %WINDIR%/fonts, needed for Fotobuch Designer */
2738 ret = load_font_from_winfonts_dir(file);
2739 if (!ret) {
2740 /* Try in datadir/fonts (or builddir/fonts),
2741 * needed for Magic the Gathering Online
2742 */
2743 ret = load_font_from_data_dir(file);
2744 }
2745 }
2746 }
2747 return ret;
2748 }
2749
2750 /*************************************************************
2751 * WineEngAddFontMemResourceEx
2752 *
2753 */
2754 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
2755 {
2756 GDI_CheckNotLock();
2757
2758 if (ft_handle) /* do it only if we have freetype up and running */
2759 {
2760 PVOID pFontCopy = HeapAlloc(GetProcessHeap(), 0, cbFont);
2761
2762 TRACE("Copying %d bytes of data from %p to %p\n", cbFont, pbFont, pFontCopy);
2763 memcpy(pFontCopy, pbFont, cbFont);
2764
2765 EnterCriticalSection( &freetype_cs );
2766 *pcFonts = AddFontToList(NULL, pFontCopy, cbFont, NULL, NULL, ADDFONT_FORCE_BITMAP);
2767 LeaveCriticalSection( &freetype_cs );
2768
2769 if (*pcFonts == 0)
2770 {
2771 TRACE("AddFontToList failed\n");
2772 HeapFree(GetProcessHeap(), 0, pFontCopy);
2773 return 0;
2774 }
2775 /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
2776 * For now return something unique but quite random
2777 */
2778 TRACE("Returning handle %lx\n", ((INT_PTR)pFontCopy)^0x87654321);
2779 return (HANDLE)(((INT_PTR)pFontCopy)^0x87654321);
2780 }
2781
2782 *pcFonts = 0;
2783 return 0;
2784 }
2785
2786 /*************************************************************
2787 * WineEngRemoveFontResourceEx
2788 *
2789 */
2790 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2791 {
2792 GDI_CheckNotLock();
2793 FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
2794 return TRUE;
2795 }
2796
2797 static const struct nls_update_font_list
2798 {
2799 UINT ansi_cp, oem_cp;
2800 const char *oem, *fixed, *system;
2801 const char *courier, *serif, *small, *sserif;
2802 /* these are for font substitutes */
2803 const char *shelldlg, *tmsrmn;
2804 const char *fixed_0, *system_0, *courier_0, *serif_0, *small_0, *sserif_0,
2805 *helv_0, *tmsrmn_0;
2806 const struct subst
2807 {
2808 const char *from, *to;
2809 } arial_0, courier_new_0, times_new_roman_0;
2810 } nls_update_font_list[] =
2811 {
2812 /* Latin 1 (United States) */
2813 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
2814 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2815 "Tahoma","Times New Roman",
2816 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2817 { 0 }, { 0 }, { 0 }
2818 },
2819 /* Latin 1 (Multilingual) */
2820 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
2821 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2822 "Tahoma","Times New Roman", /* FIXME unverified */
2823 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2824 { 0 }, { 0 }, { 0 }
2825 },
2826 /* Eastern Europe */
2827 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
2828 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
2829 "Tahoma","Times New Roman", /* FIXME unverified */
2830 "Fixedsys,238", "System,238",
2831 "Courier New,238", "MS Serif,238", "Small Fonts,238",
2832 "MS Sans Serif,238", "MS Sans Serif,238", "MS Serif,238",
2833 { "Arial CE,0", "Arial,238" },
2834 { "Courier New CE,0", "Courier New,238" },
2835 { "Times New Roman CE,0", "Times New Roman,238" }
2836 },
2837 /* Cyrillic */
2838 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
2839 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
2840 "Tahoma","Times New Roman", /* FIXME unverified */
2841 "Fixedsys,204", "System,204",
2842 "Courier New,204", "MS Serif,204", "Small Fonts,204",
2843 "MS Sans Serif,204", "MS Sans Serif,204", "MS Serif,204",
2844 { "Arial Cyr,0", "Arial,204" },
2845 { "Courier New Cyr,0", "Courier New,204" },
2846 { "Times New Roman Cyr,0", "Times New Roman,204" }
2847 },
2848 /* Greek */
2849 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
2850 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
2851 "Tahoma","Times New Roman", /* FIXME unverified */
2852 "Fixedsys,161", "System,161",
2853 "Courier New,161", "MS Serif,161", "Small Fonts,161",
2854 "MS Sans Serif,161", "MS Sans Serif,161", "MS Serif,161",
2855 { "Arial Greek,0", "Arial,161" },
2856 { "Courier New Greek,0", "Courier New,161" },
2857 { "Times New Roman Greek,0", "Times New Roman,161" }
2858 },
2859 /* Turkish */
2860 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
2861 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
2862 "Tahoma","Times New Roman", /* FIXME unverified */
2863 "Fixedsys,162", "System,162",
2864 "Courier New,162", "MS Serif,162", "Small Fonts,162",
2865 "MS Sans Serif,162", "MS Sans Serif,162", "MS Serif,162",
2866 { "Arial Tur,0", "Arial,162" },
2867 { "Courier New Tur,0", "Courier New,162" },
2868 { "Times New Roman Tur,0", "Times New Roman,162" }
2869 },
2870 /* Hebrew */
2871 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
2872 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
2873 "Tahoma","Times New Roman", /* FIXME unverified */
2874 "Fixedsys,177", "System,177",
2875 "Courier New,177", "MS Serif,177", "Small Fonts,177",
2876 "MS Sans Serif,177", "MS Sans Serif,177", "MS Serif,177",
2877 { 0 }, { 0 }, { 0 }
2878 },
2879 /* Arabic */
2880 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
2881 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
2882 "Tahoma","Times New Roman", /* FIXME unverified */
2883 "Fixedsys,178", "System,178",
2884 "Courier New,178", "MS Serif,178", "Small Fonts,178",
2885 "MS Sans Serif,178", "MS Sans Serif,178", "MS Serif,178",
2886 { 0 }, { 0 }, { 0 }
2887 },
2888 /* Baltic */
2889 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
2890 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
2891 "Tahoma","Times New Roman", /* FIXME unverified */
2892 "Fixedsys,186", "System,186",
2893 "Courier New,186", "MS Serif,186", "Small Fonts,186",
2894 "MS Sans Serif,186", "MS Sans Serif,186", "MS Serif,186",
2895 { "Arial Baltic,0", "Arial,186" },
2896 { "Courier New Baltic,0", "Courier New,186" },
2897 { "Times New Roman Baltic,0", "Times New Roman,186" }
2898 },
2899 /* Vietnamese */
2900 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
2901 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2902 "Tahoma","Times New Roman", /* FIXME unverified */
2903 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2904 { 0 }, { 0 }, { 0 }
2905 },
2906 /* Thai */
2907 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
2908 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
2909 "Tahoma","Times New Roman", /* FIXME unverified */
2910 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2911 { 0 }, { 0 }, { 0 }
2912 },
2913 /* Japanese */
2914 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
2915 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
2916 "MS UI Gothic","MS Serif",
2917 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2918 { 0 }, { 0 }, { 0 }
2919 },
2920 /* Chinese Simplified */
2921 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
2922 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2923 "SimSun", "NSimSun",
2924 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2925 { 0 }, { 0 }, { 0 }
2926 },
2927 /* Korean */
2928 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
2929 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2930 "Gulim", "Batang",
2931 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2932 { 0 }, { 0 }, { 0 }
2933 },
2934 /* Chinese Traditional */
2935 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
2936 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2937 "PMingLiU", "MingLiU",
2938 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2939 { 0 }, { 0 }, { 0 }
2940 }
2941 };
2942
2943 static inline BOOL is_dbcs_ansi_cp(UINT ansi_cp)
2944 {
2945 return ( ansi_cp == 932 /* CP932 for Japanese */
2946 || ansi_cp == 936 /* CP936 for Chinese Simplified */
2947 || ansi_cp == 949 /* CP949 for Korean */
2948 || ansi_cp == 950 ); /* CP950 for Chinese Traditional */
2949 }
2950
2951 static inline HKEY create_fonts_NT_registry_key(void)
2952 {
2953 HKEY hkey = 0;
2954
2955 RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
2956 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2957 return hkey;
2958 }
2959
2960 static inline HKEY create_fonts_9x_registry_key(void)
2961 {
2962 HKEY hkey = 0;
2963
2964 RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
2965 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2966 return hkey;
2967 }
2968
2969 static inline HKEY create_config_fonts_registry_key(void)
2970 {
2971 HKEY hkey = 0;
2972
2973 RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
2974 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2975 return hkey;
2976 }
2977
2978 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl)
2979 {
2980 RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
2981 RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
2982 RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)fl->sserif, strlen(fl->sserif)+1);
2983 RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
2984 }
2985
2986 static void set_value_key(HKEY hkey, const char *name, const char *value)
2987 {
2988 if (value)
2989 RegSetValueExA(hkey, name, 0, REG_SZ, (const BYTE *)value, strlen(value) + 1);
2990 else if (name)
2991 RegDeleteValueA(hkey, name);
2992 }
2993
2994 static void update_font_info(void)
2995 {
2996 char buf[40], cpbuf[40];
2997 DWORD len, type;
2998 HKEY hkey = 0;
2999 UINT i, ansi_cp = 0, oem_cp = 0;
3000 BOOL done = FALSE;
3001
3002 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL) != ERROR_SUCCESS)
3003 return;
3004
3005 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
3006 (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
3007 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
3008 (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
3009 sprintf( cpbuf, "%u,%u", ansi_cp, oem_cp );
3010
3011 /* Setup Default_Fallback usage for DBCS ANSI codepages */
3012 if (is_dbcs_ansi_cp(ansi_cp))
3013 use_default_fallback = TRUE;
3014
3015 len = sizeof(buf);
3016 if (RegQueryValueExA(hkey, "Codepages", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
3017 {
3018 if (!strcmp( buf, cpbuf )) /* already set correctly */
3019 {
3020 RegCloseKey(hkey);
3021 return;
3022 }
3023 TRACE("updating registry, codepages changed %s -> %u,%u\n", buf, ansi_cp, oem_cp);
3024 }
3025 else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp, oem_cp);
3026
3027 RegSetValueExA(hkey, "Codepages", 0, REG_SZ, (const BYTE *)cpbuf, strlen(cpbuf)+1);
3028 RegCloseKey(hkey);
3029
3030 for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
3031 {
3032 HKEY hkey;
3033
3034 if (nls_update_font_list[i].ansi_cp == ansi_cp &&
3035 nls_update_font_list[i].oem_cp == oem_cp)
3036 {
3037 hkey = create_config_fonts_registry_key();
3038 RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
3039 RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
3040 RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
3041 RegCloseKey(hkey);
3042
3043 hkey = create_fonts_NT_registry_key();
3044 add_font_list(hkey, &nls_update_font_list[i]);
3045 RegCloseKey(hkey);
3046
3047 hkey = create_fonts_9x_registry_key();
3048 add_font_list(hkey, &nls_update_font_list[i]);
3049 RegCloseKey(hkey);
3050
3051 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
3052 {
3053 RegSetValueExA(hkey, "MS Shell Dlg", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].shelldlg,
3054 strlen(nls_update_font_list[i].shelldlg)+1);
3055 RegSetValueExA(hkey, "Tms Rmn", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].tmsrmn,
3056 strlen(nls_update_font_list[i].tmsrmn)+1);
3057
3058 set_value_key(hkey, "Fixedsys,0", nls_update_font_list[i].fixed_0);
3059 set_value_key(hkey, "System,0", nls_update_font_list[i].system_0);
3060 set_value_key(hkey, "Courier,0", nls_update_font_list[i].courier_0);
3061 set_value_key(hkey, "MS Serif,0", nls_update_font_list[i].serif_0);
3062 set_value_key(hkey, "Small Fonts,0", nls_update_font_list[i].small_0);
3063 set_value_key(hkey, "MS Sans Serif,0", nls_update_font_list[i].sserif_0);
3064 set_value_key(hkey, "Helv,0", nls_update_font_list[i].helv_0);
3065 set_value_key(hkey, "Tms Rmn,0", nls_update_font_list[i].tmsrmn_0);
3066
3067 set_value_key(hkey, nls_update_font_list[i].arial_0.from, nls_update_font_list[i].arial_0.to);
3068 set_value_key(hkey, nls_update_font_list[i].courier_new_0.from, nls_update_font_list[i].courier_new_0.to);
3069 set_value_key(hkey, nls_update_font_list[i].times_new_roman_0.from, nls_update_font_list[i].times_new_roman_0.to);
3070
3071 RegCloseKey(hkey);
3072 }
3073 done = TRUE;
3074 }
3075 else
3076 {
3077 /* Delete the FontSubstitutes from other locales */
3078 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
3079 {
3080 set_value_key(hkey, nls_update_font_list[i].arial_0.from, NULL);
3081 set_value_key(hkey, nls_update_font_list[i].courier_new_0.from, NULL);
3082 set_value_key(hkey, nls_update_font_list[i].times_new_roman_0.from, NULL);
3083 RegCloseKey(hkey);
3084 }
3085 }
3086 }
3087 if (!done)
3088 FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp, oem_cp);
3089 }
3090
3091 static BOOL init_freetype(void)
3092 {
3093 ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
3094 if(!ft_handle) {
3095 WINE_MESSAGE(
3096 "Wine cannot find the FreeType font library. To enable Wine to\n"
3097 "use TrueType fonts please install a version of FreeType greater than\n"
3098 "or equal to 2.0.5.\n"
3099 "http://www.freetype.org\n");
3100 return FALSE;
3101 }
3102
3103 #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;}
3104
3105 LOAD_FUNCPTR(FT_Done_Face)
3106 LOAD_FUNCPTR(FT_Get_Char_Index)
3107 LOAD_FUNCPTR(FT_Get_First_Char)
3108 LOAD_FUNCPTR(FT_Get_Module)
3109 LOAD_FUNCPTR(FT_Get_Next_Char)
3110 LOAD_FUNCPTR(FT_Get_Sfnt_Name)
3111 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
3112 LOAD_FUNCPTR(FT_Get_Sfnt_Table)
3113 LOAD_FUNCPTR(FT_Get_WinFNT_Header)
3114 LOAD_FUNCPTR(FT_Init_FreeType)
3115 LOAD_FUNCPTR(FT_Library_Version)
3116 LOAD_FUNCPTR(FT_Load_Glyph)
3117 LOAD_FUNCPTR(FT_Load_Sfnt_Table)
3118 LOAD_FUNCPTR(FT_Matrix_Multiply)
3119 #ifndef FT_MULFIX_INLINED
3120 LOAD_FUNCPTR(FT_MulFix)
3121 #endif
3122 LOAD_FUNCPTR(FT_New_Face)
3123 LOAD_FUNCPTR(FT_New_Memory_Face)
3124 LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
3125 LOAD_FUNCPTR(FT_Outline_Transform)
3126 LOAD_FUNCPTR(FT_Outline_Translate)
3127 LOAD_FUNCPTR(FT_Render_Glyph)
3128 LOAD_FUNCPTR(FT_Select_Charmap)
3129 LOAD_FUNCPTR(FT_Set_Charmap)
3130 LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
3131 LOAD_FUNCPTR(FT_Vector_Transform)
3132 LOAD_FUNCPTR(FT_Vector_Unit)
3133 #undef LOAD_FUNCPTR
3134 /* Don't warn if these ones are missing */
3135 pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
3136 #ifdef HAVE_FREETYPE_FTLCDFIL_H
3137 pFT_Library_SetLcdFilter = wine_dlsym(ft_handle, "FT_Library_SetLcdFilter", NULL, 0);
3138 #endif
3139
3140 if(pFT_Init_FreeType(&library) != 0) {
3141 ERR("Can't init FreeType library\n");
3142 wine_dlclose(ft_handle, NULL, 0);
3143 ft_handle = NULL;
3144 return FALSE;
3145 }
3146 pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
3147
3148 TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
3149 FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
3150 ((FT_Version.minor << 8) & 0x00ff00) |
3151 ((FT_Version.patch ) & 0x0000ff);
3152
3153 font_driver = &freetype_funcs;
3154 return TRUE;
3155
3156 sym_not_found:
3157 WINE_MESSAGE(
3158 "Wine cannot find certain functions that it needs inside the FreeType\n"
3159 "font library. To enable Wine to use TrueType fonts please upgrade\n"
3160 "FreeType to at least version 2.1.4.\n"
3161 "http://www.freetype.org\n");
3162 wine_dlclose(ft_handle, NULL, 0);
3163 ft_handle = NULL;
3164 return FALSE;
3165 }
3166
3167 static void init_font_list(void)
3168 {
3169 static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
3170 static const WCHAR pathW[] = {'P','a','t','h',0};
3171 HKEY hkey;
3172 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
3173 WCHAR windowsdir[MAX_PATH];
3174 char *unixname;
3175 const char *data_dir;
3176
3177 delete_external_font_keys();
3178
3179 /* load the system bitmap fonts */
3180 load_system_fonts();
3181
3182 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
3183 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
3184 strcatW(windowsdir, fontsW);
3185 if((unixname = wine_get_unix_file_name(windowsdir)))
3186 {
3187 ReadFontDir(unixname, FALSE);
3188 HeapFree(GetProcessHeap(), 0, unixname);
3189 }
3190
3191 /* load the system truetype fonts */
3192 data_dir = wine_get_data_dir();
3193 if (!data_dir) data_dir = wine_get_build_dir();
3194 if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/"))))
3195 {
3196 strcpy(unixname, data_dir);
3197 strcat(unixname, "/fonts/");
3198 ReadFontDir(unixname, TRUE);
3199 HeapFree(GetProcessHeap(), 0, unixname);
3200 }
3201
3202 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
3203 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
3204 full path as the entry. Also look for any .fon fonts, since ReadFontDir
3205 will skip these. */
3206 if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
3207 is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
3208 &hkey) == ERROR_SUCCESS)
3209 {
3210 LPWSTR data, valueW;
3211 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3212 &valuelen, &datalen, NULL, NULL);
3213
3214 valuelen++; /* returned value doesn't include room for '\0' */
3215 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
3216 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
3217 if (valueW && data)
3218 {
3219 dlen = datalen * sizeof(WCHAR);
3220 vlen = valuelen;
3221 while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, (LPBYTE)data,
3222 &dlen) == ERROR_SUCCESS)
3223 {
3224 if(data[0] && (data[1] == ':'))
3225 {
3226 if((unixname = wine_get_unix_file_name(data)))
3227 {
3228 AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP | ADDFONT_ADD_TO_CACHE);
3229 HeapFree(GetProcessHeap(), 0, unixname);
3230 }
3231 }
3232 else if(dlen / 2 >= 6 && !strcmpiW(data + dlen / 2 - 5, dot_fonW))
3233 {
3234 WCHAR pathW[MAX_PATH];
3235 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
3236 BOOL added = FALSE;
3237
3238 sprintfW(pathW, fmtW, windowsdir, data);
3239 if((unixname = wine_get_unix_file_name(pathW)))
3240 {
3241 added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP | ADDFONT_ADD_TO_CACHE);
3242 HeapFree(GetProcessHeap(), 0, unixname);
3243 }
3244 if (!added)
3245 load_font_from_data_dir(data);
3246 }
3247 /* reset dlen and vlen */
3248 dlen = datalen;
3249 vlen = valuelen;
3250 }
3251 }
3252 HeapFree(GetProcessHeap(), 0, data);
3253 HeapFree(GetProcessHeap(), 0, valueW);
3254 RegCloseKey(hkey);
3255 }
3256
3257 #ifdef SONAME_LIBFONTCONFIG
3258 load_fontconfig_fonts();
3259 #elif defined(HAVE_CARBON_CARBON_H)
3260 load_mac_fonts();
3261 #endif
3262
3263 /* then look in any directories that we've specified in the config file */
3264 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
3265 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
3266 {
3267 DWORD len;
3268 LPWSTR valueW;
3269 LPSTR valueA, ptr;
3270
3271 if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
3272 {
3273 len += sizeof(WCHAR);
3274 valueW = HeapAlloc( GetProcessHeap(), 0, len );
3275 if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
3276 {
3277 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
3278 valueA = HeapAlloc( GetProcessHeap(), 0, len );
3279 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
3280 TRACE( "got font path %s\n", debugstr_a(valueA) );
3281 ptr = valueA;
3282 while (ptr)
3283 {
3284 const char* home;
3285 LPSTR next = strchr( ptr, ':' );
3286 if (next) *next++ = 0;
3287 if (ptr[0] == '~' && ptr[1] == '/' && (home = getenv( "HOME" )) &&
3288 (unixname = HeapAlloc( GetProcessHeap(), 0, strlen(ptr) + strlen(home) )))
3289 {
3290 strcpy( unixname, home );
3291 strcat( unixname, ptr + 1 );
3292 ReadFontDir( unixname, TRUE );
3293 HeapFree( GetProcessHeap(), 0, unixname );
3294 }
3295 else
3296 ReadFontDir( ptr, TRUE );
3297 ptr = next;
3298 }
3299 HeapFree( GetProcessHeap(), 0, valueA );
3300 }
3301 HeapFree( GetProcessHeap(), 0, valueW );
3302 }
3303 RegCloseKey(hkey);
3304 }
3305 }
3306
3307 static BOOL move_to_front(const WCHAR *name)
3308 {
3309 Family *family, *cursor2;
3310 LIST_FOR_EACH_ENTRY_SAFE(family, cursor2, &font_list, Family, entry)
3311 {
3312 if(!strcmpiW(family->FamilyName, name))
3313 {
3314 list_remove(&family->entry);
3315 list_add_head(&font_list, &family->entry);
3316 return TRUE;
3317 }
3318 }
3319 return FALSE;
3320 }
3321
3322 static BOOL set_default(const WCHAR **name_list)
3323 {
3324 while (*name_list)
3325 {
3326 if (move_to_front(*name_list)) return TRUE;
3327 name_list++;
3328 }
3329
3330 return FALSE;
3331 }
3332
3333 static void reorder_font_list(void)
3334 {
3335 set_default( default_serif_list );
3336 set_default( default_fixed_list );
3337 set_default( default_sans_list );
3338 }
3339
3340 /*************************************************************
3341 * WineEngInit
3342 *
3343 * Initialize FreeType library and create a list of available faces
3344 */
3345 BOOL WineEngInit(void)
3346 {
3347 HKEY hkey_font_cache;
3348 DWORD disposition;
3349 HANDLE font_mutex;
3350
3351 /* update locale dependent font info in registry */
3352 update_font_info();
3353
3354 if(!init_freetype()) return FALSE;
3355
3356 if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL)
3357 {
3358 ERR("Failed to create font mutex\n");
3359 return FALSE;
3360 }
3361 WaitForSingleObject(font_mutex, INFINITE);
3362
3363 create_font_cache_key(&hkey_font_cache, &disposition);
3364
3365 if(disposition == REG_CREATED_NEW_KEY)
3366 init_font_list();
3367 else
3368 load_font_list_from_cache(hkey_font_cache);
3369
3370 RegCloseKey(hkey_font_cache);
3371
3372 reorder_font_list();
3373
3374 DumpFontList();
3375 LoadSubstList();
3376 DumpSubstList();
3377 LoadReplaceList();
3378
3379 if(disposition == REG_CREATED_NEW_KEY)
3380 update_reg_entries();
3381
3382 init_system_links();
3383
3384 ReleaseMutex(font_mutex);
3385 return TRUE;
3386 }
3387
3388
3389 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
3390 {
3391 TT_OS2 *pOS2;
3392 TT_HoriHeader *pHori;
3393
3394 LONG ppem;
3395
3396 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
3397 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
3398
3399 if(height == 0) height = 16;
3400
3401 /* Calc. height of EM square:
3402 *
3403 * For +ve lfHeight we have
3404 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
3405 * Re-arranging gives:
3406 * ppem = units_per_em * lfheight / (winAscent + winDescent)
3407 *
3408 * For -ve lfHeight we have
3409 * |lfHeight| = ppem
3410 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
3411 * with il = winAscent + winDescent - units_per_em]
3412 *
3413 */
3414
3415 if(height > 0) {
3416 if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
3417 ppem = MulDiv(ft_face->units_per_EM, height,
3418 pHori->Ascender - pHori->Descender);
3419 else
3420 ppem = MulDiv(ft_face->units_per_EM, height,
3421 pOS2->usWinAscent + pOS2->usWinDescent);
3422 }
3423 else
3424 ppem = -height;
3425
3426 return ppem;
3427 }
3428
3429 static struct font_mapping *map_font_file( const char *name )
3430 {
3431 struct font_mapping *mapping;
3432 struct stat st;
3433 int fd;
3434
3435 if ((fd = open( name, O_RDONLY )) == -1) return NULL;
3436 if (fstat( fd, &st ) == -1) goto error;
3437
3438 LIST_FOR_EACH_ENTRY( mapping, &mappings_list, struct font_mapping, entry )
3439 {
3440 if (mapping->dev == st.st_dev && mapping->ino == st.st_ino)
3441 {
3442 mapping->refcount++;
3443 close( fd );
3444 return mapping;
3445 }
3446 }
3447 if (!(mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping) )))
3448 goto error;
3449
3450 mapping->data = mmap( NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );
3451 close( fd );
3452
3453 if (mapping->data == MAP_FAILED)
3454 {
3455 HeapFree( GetProcessHeap(), 0, mapping );
3456 return NULL;
3457 }
3458 mapping->refcount = 1;
3459 mapping->dev = st.st_dev;
3460 mapping->ino = st.st_ino;
3461 mapping->size = st.st_size;
3462 list_add_tail( &mappings_list, &mapping->entry );
3463 return mapping;
3464
3465 error:
3466 close( fd );
3467 return NULL;
3468 }
3469
3470 static void unmap_font_file( struct font_mapping *mapping )
3471 {
3472 if (!--mapping->refcount)
3473 {
3474 list_remove( &mapping->entry );
3475 munmap( mapping->data, mapping->size );
3476 HeapFree( GetProcessHeap(), 0, mapping );
3477 }
3478 }
3479
3480 static LONG load_VDMX(GdiFont*, LONG);
3481
3482 static FT_Face OpenFontFace(GdiFont *font, Face *face, LONG width, LONG height)
3483 {
3484 FT_Error err;
3485 FT_Face ft_face;
3486 void *data_ptr;
3487 DWORD data_size;
3488
3489 TRACE("%s/%p, %ld, %d x %d\n", debugstr_a(face->file), face->font_data_ptr, face->face_index, width, height);
3490
3491 if (face->file)
3492 {
3493 if (!(font->mapping = map_font_file( face->file )))
3494 {
3495 WARN("failed to map %s\n", debugstr_a(face->file));
3496 return 0;
3497 }
3498 data_ptr = font->mapping->data;
3499 data_size = font->mapping->size;
3500 }
3501 else
3502 {
3503 data_ptr = face->font_data_ptr;
3504 data_size = face->font_data_size;
3505 }
3506
3507 err = pFT_New_Memory_Face(library, data_ptr, data_size, face->face_index, &ft_face);
3508 if(err) {
3509 ERR("FT_New_Face rets %d\n", err);
3510 return 0;
3511 }
3512
3513 /* set it here, as load_VDMX needs it */
3514 font->ft_face = ft_face;
3515
3516 if(FT_IS_SCALABLE(ft_face)) {
3517 /* load the VDMX table if we have one */
3518 font->ppem = load_VDMX(font, height);
3519 if(font->ppem == 0)
3520 font->ppem = calc_ppem_for_height(ft_face, height);
3521 TRACE("height %d => ppem %d\n", height, font->ppem);
3522
3523 if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
3524 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font->ppem, err);
3525 } else {
3526 font->ppem = height;
3527 if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
3528 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width, height, err);
3529 }
3530 return ft_face;
3531 }
3532
3533
3534 static int get_nearest_charset(Face *face, int *cp)
3535 {
3536 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
3537 a single face with the requested charset. The idea is to check if
3538 the selected font supports the current ANSI codepage, if it does
3539 return the corresponding charset, else return the first charset */
3540
3541 CHARSETINFO csi;
3542 int acp = GetACP(), i;
3543 DWORD fs0;
3544
3545 *cp = acp;
3546 if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
3547 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
3548 return csi.ciCharset;
3549
3550 for(i = 0; i < 32; i++) {
3551 fs0 = 1L << i;
3552 if(face->fs.fsCsb[0] & fs0) {
3553 if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
3554 *cp = csi.ciACP;
3555 return csi.ciCharset;
3556 }
3557 else
3558 FIXME("TCI failing on %x\n", fs0);
3559 }
3560 }
3561
3562 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
3563 face->fs.fsCsb[0], face->file);
3564 *cp = acp;
3565 return DEFAULT_CHARSET;
3566 }
3567
3568 static GdiFont *alloc_font(void)
3569 {
3570 GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
3571 ret->gmsize = 1;
3572 ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM*));
3573 ret->gm[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
3574 ret->potm = NULL;
3575 ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
3576 ret->total_kern_pairs = (DWORD)-1;
3577 ret->kern_pairs = NULL;
3578 list_init(&ret->hfontlist);
3579 list_init(&ret->child_fonts);
3580 return ret;
3581 }
3582
3583 static void free_font(GdiFont *font)
3584 {
3585 struct list *cursor, *cursor2;
3586 DWORD i;
3587
3588 LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
3589 {
3590 CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
3591 list_remove(cursor);
3592 if(child->font)
3593 free_font(child->font);
3594 HeapFree(GetProcessHeap(), 0, child);
3595 }
3596
3597 LIST_FOR_EACH_SAFE(cursor, cursor2, &font->hfontlist)
3598 {
3599 HFONTLIST *hfontlist = LIST_ENTRY(cursor, HFONTLIST, entry);
3600 DeleteObject(hfontlist->hfont);
3601 list_remove(&hfontlist->entry);
3602 HeapFree(GetProcessHeap(), 0, hfontlist);
3603 }
3604
3605 if (font->ft_face) pFT_Done_Face(font->ft_face);
3606 if (font->mapping) unmap_font_file( font->mapping );
3607 HeapFree(GetProcessHeap(), 0, font->kern_pairs);
3608 HeapFree(GetProcessHeap(), 0, font->potm);
3609 HeapFree(GetProcessHeap(), 0, font->name);
3610 for (i = 0; i < font->gmsize; i++)
3611 HeapFree(GetProcessHeap(),0,font->gm[i]);
3612 HeapFree(GetProcessHeap(), 0, font->gm);
3613 HeapFree(GetProcessHeap(), 0, font->GSUB_Table);
3614 HeapFree(GetProcessHeap(), 0, font);
3615 }
3616
3617
3618 static DWORD get_font_data( GdiFont *font, DWORD table, DWORD offset, LPVOID buf, DWORD cbData)
3619 {
3620 FT_Face ft_face = font->ft_face;
3621 FT_ULong len;
3622 FT_Error err;
3623
3624 if (!FT_IS_SFNT(ft_face)) return GDI_ERROR;
3625
3626 if(!buf)
3627 len = 0;
3628 else
3629 len = cbData;
3630
3631 table = RtlUlongByteSwap( table ); /* MS tags differ in endianness from FT ones */
3632
3633 /* make sure value of len is the value freetype says it needs */
3634 if (buf && len)
3635 {
3636 FT_ULong needed = 0;
3637 err = pFT_Load_Sfnt_Table(ft_face, table, offset, NULL, &needed);
3638 if( !err && needed < len) len = needed;
3639 }
3640 err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, &len);
3641 if (err)
3642 {
3643 TRACE("Can't find table %c%c%c%c\n",
3644 /* bytes were reversed */
3645 HIBYTE(HIWORD(table)), LOBYTE(HIWORD(table)),
3646 HIBYTE(LOWORD(table)), LOBYTE(LOWORD(table)));
3647 return GDI_ERROR;
3648 }
3649 return len;
3650 }
3651
3652 /*************************************************************
3653 * load_VDMX
3654 *
3655 * load the vdmx entry for the specified height
3656 */
3657
3658 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
3659 ( ( (FT_ULong)_x4 << 24 ) | \
3660 ( (FT_ULong)_x3 << 16 ) | \
3661 ( (FT_ULong)_x2 << 8 ) | \
3662 (FT_ULong)_x1 )
3663
3664 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
3665
3666 typedef struct {
3667 BYTE bCharSet;
3668 BYTE xRatio;
3669 BYTE yStartRatio;
3670 BYTE yEndRatio;
3671 } Ratios;
3672
3673 typedef struct {
3674 WORD recs;
3675 BYTE startsz;
3676 BYTE endsz;
3677 } VDMX_group;
3678
3679 static LONG load_VDMX(GdiFont *font, LONG height)
3680 {
3681 WORD hdr[3], tmp;
3682 VDMX_group group;
3683 BYTE devXRatio, devYRatio;
3684 USHORT numRecs, numRatios;
3685 DWORD result, offset = -1;
3686 LONG ppem = 0;
3687 int i;
3688
3689 result = get_font_data(font, MS_VDMX_TAG, 0, hdr, 6);
3690
3691 if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
3692 return ppem;
3693
3694 /* FIXME: need the real device aspect ratio */
3695 devXRatio = 1;
3696 devYRatio = 1;
3697
3698 numRecs = GET_BE_WORD(hdr[1]);
3699 numRatios = GET_BE_WORD(hdr[2]);
3700
3701 TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
3702 for(i = 0; i < numRatios; i++) {
3703 Ratios ratio;
3704
3705 offset = (3 * 2) + (i * sizeof(Ratios));
3706 get_font_data(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
3707 offset = -1;
3708
3709 TRACE("Ratios[%d] %d %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
3710
3711 if((ratio.xRatio == 0 &&
3712 ratio.yStartRatio == 0 &&
3713 ratio.yEndRatio == 0) ||
3714 (devXRatio == ratio.xRatio &&
3715 devYRatio >= ratio.yStartRatio &&
3716 devYRatio <= ratio.yEndRatio))
3717 {
3718 offset = (3 * 2) + (numRatios * 4) + (i * 2);
3719 get_font_data(font, MS_VDMX_TAG, offset, &tmp, 2);
3720 offset = GET_BE_WORD(tmp);
3721 break;
3722 }
3723 }
3724
3725 if(offset == -1) {
3726 FIXME("No suitable ratio found\n");
3727 return ppem;
3728 }
3729
3730 if(get_font_data(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
3731 USHORT recs;
3732 BYTE startsz, endsz;
3733 WORD *vTable;
3734
3735 recs = GET_BE_WORD(group.recs);
3736 startsz = group.startsz;
3737 endsz = group.endsz;
3738
3739 TRACE("recs=%d startsz=%d endsz=%d\n", recs, startsz, endsz);
3740
3741 vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
3742 result = get_font_data(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
3743 if(result == GDI_ERROR) {
3744 FIXME("Failed to retrieve vTable\n");
3745 goto end;
3746 }
3747
3748 if(height > 0) {
3749 for(i = 0; i < recs; i++) {
3750 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
3751 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
3752 ppem = GET_BE_WORD(vTable[i * 3]);
3753
3754 if(yMax + -yMin == height) {
3755 font->yMax = yMax;
3756 font->yMin = yMin;
3757 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
3758 break;
3759 }
3760 if(yMax + -yMin > height) {
3761 if(--i < 0) {
3762 ppem = 0;
3763 goto end; /* failed */
3764 }
3765 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
3766 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
3767 ppem = GET_BE_WORD(vTable[i * 3]);
3768 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
3769 break;
3770 }
3771 }
3772 if(!font->yMax) {
3773 ppem = 0;
3774 TRACE("ppem not found for height %d\n", height);
3775 }
3776 }
3777 end:
3778 HeapFree(GetProcessHeap(), 0, vTable);
3779 }
3780
3781 return ppem;
3782 }
3783
3784 static BOOL fontcmp(const GdiFont *font, FONT_DESC *fd)
3785 {
3786 if(font->font_desc.hash != fd->hash) return TRUE;
3787 if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
3788 if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
3789 if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
3790 return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
3791 }
3792
3793 static void calc_hash(FONT_DESC *pfd)
3794 {
3795 DWORD hash = 0, *ptr, two_chars;
3796 WORD *pwc;
3797 unsigned int i;
3798
3799 for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
3800 hash ^= *ptr;
3801 for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
3802 hash ^= *ptr;
3803 for(i = 0, ptr = (DWORD*)pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
3804 two_chars = *ptr;
3805 pwc = (WCHAR *)&two_chars;
3806 if(!*pwc) break;
3807 *pwc = toupperW(*pwc);
3808 pwc++;
3809 *pwc = toupperW(*pwc);
3810 hash ^= two_chars;
3811 if(!*pwc) break;
3812 }
3813 hash ^= !pfd->can_use_bitmap;
3814 pfd->hash = hash;
3815 return;
3816 }
3817
3818 static GdiFont *find_in_cache(HFONT hfont, const LOGFONTW *plf, const FMAT2 *pmat, BOOL can_use_bitmap)
3819 {
3820 GdiFont *ret;
3821 FONT_DESC fd;
3822 HFONTLIST *hflist;
3823 struct list *font_elem_ptr, *hfontlist_elem_ptr;
3824
3825 fd.lf = *plf;
3826 fd.matrix = *pmat;
3827 fd.can_use_bitmap = can_use_bitmap;
3828 calc_hash(&fd);
3829
3830 /* try the child list */
3831 LIST_FOR_EACH(font_elem_ptr, &child_font_list) {
3832 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3833 if(!fontcmp(ret, &fd)) {
3834 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
3835 LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
3836 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
3837 if(hflist->hfont == hfont)
3838 return ret;
3839 }
3840 }
3841 }
3842
3843 /* try the in-use list */
3844 LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
3845 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3846 if(!fontcmp(ret, &fd)) {
3847 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
3848 LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
3849 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
3850 if(hflist->hfont == hfont)
3851 return ret;
3852 }
3853 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
3854 hflist->hfont = hfont;
3855 list_add_head(&ret->hfontlist, &hflist->entry);
3856 return ret;
3857 }
3858 }
3859
3860 /* then the unused list */
3861 font_elem_ptr = list_head(&unused_gdi_font_list);
3862 while(font_elem_ptr) {
3863 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3864 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3865 if(!fontcmp(ret, &fd)) {
3866 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
3867 assert(list_empty(&ret->hfontlist));
3868 TRACE("Found %p in unused list\n", ret);
3869 list_remove(&ret->entry);
3870 list_add_head(&gdi_font_list, &ret->entry);
3871 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
3872 hflist->hfont = hfont;
3873 list_add_head(&ret->hfontlist, &hflist->entry);
3874 return ret;
3875 }
3876 }
3877 return NULL;
3878 }
3879
3880 static void add_to_cache(GdiFont *font)
3881 {
3882 static DWORD cache_num = 1;
3883
3884 font->cache_num = cache_num++;
3885 list_add_head(&gdi_font_list, &font->entry);
3886 }
3887
3888 /*************************************************************
3889 * create_child_font_list
3890 */
3891 static BOOL create_child_font_list(GdiFont *font)
3892 {
3893 BOOL ret = FALSE;
3894 SYSTEM_LINKS *font_link;
3895 CHILD_FONT *font_link_entry, *new_child;
3896 FontSubst *psub;
3897 WCHAR* font_name;
3898
3899 psub = get_font_subst(&font_subst_list, font->name, -1);
3900 font_name = psub ? psub->to.name : font->name;
3901 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
3902 {
3903 if(!strcmpiW(font_link->font_name, font_name))
3904 {
3905 TRACE("found entry in system list\n");
3906 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
3907 {
3908 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
3909 new_child->face = font_link_entry->face;
3910 new_child->font = NULL;
3911 list_add_tail(&font->child_fonts, &new_child->entry);
3912 TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
3913 }
3914 ret = TRUE;
3915 break;
3916 }
3917 }
3918 /*
3919 * if not SYMBOL or OEM then we also get all the fonts for Microsoft
3920 * Sans Serif. This is how asian windows get default fallbacks for fonts
3921 */
3922 if (use_default_fallback && font->charset != SYMBOL_CHARSET &&
3923 font->charset != OEM_CHARSET &&
3924 strcmpiW(font_name,szDefaultFallbackLink) != 0)
3925 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
3926 {
3927 if(!strcmpiW(font_link->font_name,szDefaultFallbackLink))
3928 {
3929 TRACE("found entry in default fallback list\n");
3930 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
3931 {
3932 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
3933 new_child->face = font_link_entry->face;
3934 new_child->font = NULL;
3935 list_add_tail(&font->child_fonts, &new_child->entry);
3936 TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
3937 }
3938 ret = TRUE;
3939 break;
3940 }
3941 }
3942
3943 return ret;
3944 }
3945
3946 static BOOL select_charmap(FT_Face ft_face, FT_Encoding encoding)
3947 {
3948 FT_Error ft_err = FT_Err_Invalid_CharMap_Handle;
3949
3950 if (pFT_Set_Charmap)
3951 {
3952 FT_Int i;
3953 FT_CharMap cmap0, cmap1, cmap2, cmap3, cmap_def;
3954
3955 cmap0 = cmap1 = cmap2 = cmap3 = cmap_def = NULL;
3956
3957 for (i = 0; i < ft_face->num_charmaps; i++)
3958 {
3959 if (ft_face->charmaps[i]->encoding == encoding)
3960 {
3961 TRACE("found cmap with platform_id %u, encoding_id %u\n",
3962 ft_face->charmaps[i]->platform_id, ft_face->charmaps[i]->encoding_id);
3963
3964 switch (ft_face->charmaps[i]->platform_id)
3965 {
3966 default:
3967 cmap_def = ft_face->charmaps[i];
3968 break;
3969 case 0: /* Apple Unicode */
3970 cmap0 = ft_face->charmaps[i];
3971 break;
3972 case 1: /* Macintosh */
3973 cmap1 = ft_face->charmaps[i];
3974 break;
3975 case 2: /* ISO */
3976 cmap2 = ft_face->charmaps[i];
3977 break;
3978 case 3: /* Microsoft */
3979 cmap3 = ft_face->charmaps[i];
3980 break;
3981 }
3982 }
3983
3984 if (cmap3) /* prefer Microsoft cmap table */
3985 ft_err = pFT_Set_Charmap(ft_face, cmap3);
3986 else if (cmap1)
3987 ft_err = pFT_Set_Charmap(ft_face, cmap1);
3988 else if (cmap2)
3989 ft_err = pFT_Set_Charmap(ft_face, cmap2);
3990 else if (cmap0)
3991 ft_err = pFT_Set_Charmap(ft_face, cmap0);
3992 else if (cmap_def)
3993 ft_err = pFT_Set_Charmap(ft_face, cmap_def);
3994 }
3995 return ft_err == FT_Err_Ok;
3996 }
3997
3998 return pFT_Select_Charmap(ft_face, encoding) == FT_Err_Ok;
3999 }
4000
4001
4002 /*************************************************************
4003 * freetype_CreateDC
4004 */
4005 static BOOL freetype_CreateDC( PHYSDEV *dev, LPCWSTR driver, LPCWSTR device,
4006 LPCWSTR output, const DEVMODEW *devmode )
4007 {
4008 struct freetype_physdev *physdev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physdev) );
4009
4010 if (!physdev) return FALSE;
4011 push_dc_driver( dev, &physdev->dev, &freetype_funcs );
4012 return TRUE;
4013 }
4014
4015
4016 /*************************************************************
4017 * freetype_DeleteDC
4018 */
4019 static BOOL freetype_DeleteDC( PHYSDEV dev )
4020 {
4021 struct freetype_physdev *physdev = get_freetype_dev( dev );
4022 HeapFree( GetProcessHeap(), 0, physdev );
4023 return TRUE;
4024 }
4025
4026
4027 /*************************************************************
4028 * freetype_SelectFont
4029 */
4030 static HFONT freetype_SelectFont( PHYSDEV dev, HFONT hfont )
4031 {
4032 struct freetype_physdev *physdev = get_freetype_dev( dev );
4033 GdiFont *ret;
4034 Face *face, *best, *best_bitmap;
4035 Family *family, *last_resort_family;
4036 struct list *family_elem_ptr, *face_elem_ptr;
4037 INT height, width = 0;
4038 unsigned int score = 0, new_score;
4039 signed int diff = 0, newdiff;
4040 BOOL bd, it, can_use_bitmap, want_vertical;
4041 LOGFONTW lf;
4042 CHARSETINFO csi;
4043 HFONTLIST *hflist;
4044 FMAT2 dcmat;
4045 FontSubst *psub = NULL;
4046 DC *dc = get_dc_ptr( dev->hdc );
4047
4048 if (!hfont) /* notification that the font has been changed by another driver */
4049 {
4050 dc->gdiFont = NULL;
4051 physdev->font = NULL;
4052 release_dc_ptr( dc );
4053 return 0;
4054 }
4055
4056 GetObjectW( hfont, sizeof(lf), &lf );
4057 lf.lfWidth = abs(lf.lfWidth);
4058
4059 can_use_bitmap = GetDeviceCaps(dev->hdc, TEXTCAPS) & TC_RA_ABLE;
4060
4061 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
4062 debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
4063 lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
4064 lf.lfEscapement);
4065
4066 if(dc->GraphicsMode == GM_ADVANCED)
4067 {
4068 memcpy(&dcmat, &dc->xformWorld2Vport, sizeof(FMAT2));
4069 /* Try to avoid not necessary glyph transformations */
4070 if (dcmat.eM21 == 0.0 && dcmat.eM12 == 0.0 && dcmat.eM11 == dcmat.eM22)
4071 {
4072 lf.lfHeight *= fabs(dcmat.eM11);
4073 lf.lfWidth *= fabs(dcmat.eM11);
4074 dcmat.eM11 = dcmat.eM22 = 1.0;
4075 }
4076 }
4077 else
4078 {
4079 /* Windows 3.1 compatibility mode GM_COMPATIBLE has only limited
4080 font scaling abilities. */
4081 dcmat.eM11 = dcmat.eM22 = 1.0;
4082 dcmat.eM21 = dcmat.eM12 = 0;
4083 if (dc->vport2WorldValid)
4084 {
4085 if (dc->xformWorld2Vport.eM11 * dc->xformWorld2Vport.eM22 < 0)
4086 lf.lfOrientation = -lf.lfOrientation;
4087 lf.lfHeight *= fabs(dc->xformWorld2Vport.eM22);
4088 lf.lfWidth *= fabs(dc->xformWorld2Vport.eM22);
4089 }
4090 }
4091
4092 TRACE("DC transform %f %f %f %f\n", dcmat.eM11, dcmat.eM12,
4093 dcmat.eM21, dcmat.eM22);
4094
4095 GDI_CheckNotLock();
4096 EnterCriticalSection( &freetype_cs );
4097
4098 /* check the cache first */
4099 if((ret = find_in_cache(hfont, &lf, &dcmat, can_use_bitmap)) != NULL) {
4100 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
4101 goto done;
4102 }
4103
4104 if(list_empty(&font_list)) /* No fonts installed */
4105 {
4106 TRACE("No fonts installed\n");
4107 goto done;
4108 }
4109
4110 TRACE("not in cache\n");
4111 ret = alloc_font();
4112
4113 ret->font_desc.matrix = dcmat;
4114 ret->font_desc.lf = lf;
4115 ret->font_desc.can_use_bitmap = can_use_bitmap;
4116 calc_hash(&ret->font_desc);
4117 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
4118 hflist->hfont = hfont;
4119 list_add_head(&ret->hfontlist, &hflist->entry);
4120
4121 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
4122 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
4123 original value lfCharSet. Note this is a special case for
4124 Symbol and doesn't happen at least for "Wingdings*" */
4125
4126 if(!strcmpiW(lf.lfFaceName, SymbolW))
4127 lf.lfCharSet = SYMBOL_CHARSET;
4128
4129 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
4130 switch(lf.lfCharSet) {
4131 case DEFAULT_CHARSET:
4132 csi.fs.fsCsb[0] = 0;
4133 break;
4134 default:
4135 FIXME("Untranslated charset %d\n", lf.lfCharSet);
4136 csi.fs.fsCsb[0] = 0;
4137 break;
4138 }
4139 }
4140
4141 family = NULL;
4142 if(lf.lfFaceName[0] != '\0') {
4143 SYSTEM_LINKS *font_link;
4144 CHILD_FONT *font_link_entry;
4145 LPWSTR FaceName = lf.lfFaceName;
4146
4147 psub = get_font_subst(&font_subst_list, FaceName, lf.lfCharSet);
4148
4149 if(psub) {
4150 TRACE("substituting %s,%d -> %s,%d\n", debugstr_w(FaceName), lf.lfCharSet,
4151 debugstr_w(psub->to.name), (psub->to.charset != -1) ? psub->to.charset : lf.lfCharSet);
4152 if (psub->to.charset != -1)
4153 lf.lfCharSet = psub->to.charset;
4154 }
4155
4156 /* We want a match on name and charset or just name if
4157 charset was DEFAULT_CHARSET. If the latter then
4158 we fixup the returned charset later in get_nearest_charset
4159 where we'll either use the charset of the current ansi codepage
4160 or if that's unavailable the first charset that the font supports.
4161 */
4162 LIST_FOR_EACH(family_elem_ptr, &font_list) {
4163 family = LIST_ENTRY(family_elem_ptr, Family, entry);
4164 if (!strcmpiW(family->FamilyName, FaceName) ||
4165 (psub && !strcmpiW(family->FamilyName, psub->to.name)))
4166 {
4167 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
4168 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4169 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
4170 if(face->scalable || can_use_bitmap)
4171 goto found;
4172 }
4173 }
4174 }
4175
4176 /* Search by full face name. */
4177 LIST_FOR_EACH(family_elem_ptr, &font_list) {
4178 family = LIST_ENTRY(family_elem_ptr, Family, entry);
4179 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
4180 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4181 if(face->FullName && !strcmpiW(face->FullName, FaceName) &&
4182 ((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0]))
4183 {
4184 if(face->scalable || can_use_bitmap)
4185 goto found_face;
4186 }
4187 }
4188 }
4189
4190 /*
4191 * Try check the SystemLink list first for a replacement font.
4192 * We may find good replacements there.
4193 */
4194 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
4195 {
4196 if(!strcmpiW(font_link->font_name, FaceName) ||
4197 (psub && !strcmpiW(font_link->font_name,psub->to.name)))
4198 {
4199 TRACE("found entry in system list\n");
4200 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
4201 {
4202 face = font_link_entry->face;
4203 family = face->family;
4204 if(csi.fs.fsCsb[0] &
4205 (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]) || !csi.fs.fsCsb[0])
4206 {
4207 if(face->scalable || can_use_bitmap)
4208 goto found;
4209 }
4210 }
4211 }
4212 }
4213 }
4214
4215 psub = NULL; /* substitution is no more relevant */
4216
4217 /* If requested charset was DEFAULT_CHARSET then try using charset
4218 corresponding to the current ansi codepage */
4219 if (!csi.fs.fsCsb[0])
4220 {
4221 INT acp = GetACP();
4222 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
4223 FIXME("TCI failed on codepage %d\n", acp);
4224 csi.fs.fsCsb[0] = 0;
4225 } else
4226 lf.lfCharSet = csi.ciCharset;
4227 }
4228
4229 want_vertical = (lf.lfFaceName[0] == '@');
4230
4231 /* Face families are in the top 4 bits of lfPitchAndFamily,
4232 so mask with 0xF0 before testing */
4233
4234 if((lf.lfPitchAndFamily & FIXED_PITCH) ||
4235 (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
4236 strcpyW(lf.lfFaceName, defFixed);
4237 else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
4238 strcpyW(lf.lfFaceName, defSerif);
4239 else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
4240 strcpyW(lf.lfFaceName, defSans);
4241 else
4242 strcpyW(lf.lfFaceName, defSans);
4243 LIST_FOR_EACH(family_elem_ptr, &font_list) {
4244 family = LIST_ENTRY(family_elem_ptr, Family, entry);
4245 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
4246 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
4247 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4248 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
4249 if(face->scalable || can_use_bitmap)
4250 goto found;
4251 }
4252 }
4253 }
4254
4255 last_resort_family = NULL;
4256 LIST_FOR_EACH(family_elem_ptr, &font_list) {
4257 family = LIST_ENTRY(family_elem_ptr, Family, entry);
4258 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
4259 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4260 if(face->vertical == want_vertical &&
4261 (csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))) {
4262 if(face->scalable)
4263 goto found;
4264 if(can_use_bitmap && !last_resort_family)
4265 last_resort_family = family;
4266 }
4267 }
4268 }
4269
4270 if(last_resort_family) {
4271 family = last_resort_family;
4272 csi.fs.fsCsb[0] = 0;
4273 goto found;
4274 }
4275
4276 LIST_FOR_EACH(family_elem_ptr, &font_list) {
4277 family = LIST_ENTRY(family_elem_ptr, Family, entry);
4278 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
4279 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4280 if(face->scalable && face->vertical == want_vertical) {
4281 csi.fs.fsCsb[0] = 0;
4282 WARN("just using first face for now\n");
4283 goto found;
4284 }
4285 if(can_use_bitmap && !last_resort_family)
4286 last_resort_family = family;
4287 }
4288 }
4289 if(!last_resort_family) {
4290 FIXME("can't find a single appropriate font - bailing\n");
4291 free_font(ret);
4292 ret = NULL;
4293 goto done;
4294 }
4295
4296 WARN("could only find a bitmap font - this will probably look awful!\n");
4297 family = last_resort_family;
4298 csi.fs.fsCsb[0] = 0;
4299
4300 found:
4301 it = lf.lfItalic ? 1 : 0;
4302 bd = lf.lfWeight > 550 ? 1 : 0;
4303
4304 height = lf.lfHeight;
4305
4306 face = best = best_bitmap = NULL;
4307 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
4308 {
4309 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
4310 {
4311 BOOL italic, bold;
4312
4313 italic = (face->ntmFlags & NTM_ITALIC) ? 1 : 0;
4314 bold = (face->ntmFlags & NTM_BOLD) ? 1 : 0;
4315 new_score = (italic ^ it) + (bold ^ bd);
4316 if(!best || new_score <= score)
4317 {
4318 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
4319 italic, bold, it, bd);
4320 score = new_score;
4321 best = face;
4322 if(best->scalable && score == 0) break;
4323 if(!best->scalable)
4324 {
4325 if(height > 0)
4326 newdiff = height - (signed int)(best->size.height);
4327 else
4328 newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
4329 if(!best_bitmap || new_score < score ||
4330 (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
4331 {
4332 TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
4333 diff = newdiff;
4334 best_bitmap = best;
4335 if(score == 0 && diff == 0) break;
4336 }
4337 }
4338 }
4339 }
4340 }
4341 if(best)
4342 face = best->scalable ? best : best_bitmap;
4343 ret->fake_italic = (it && !(face->ntmFlags & NTM_ITALIC));
4344 ret->fake_bold = (bd && !(face->ntmFlags & NTM_BOLD));
4345
4346 found_face:
4347 height = lf.lfHeight;
4348
4349 ret->fs = face->fs;
4350
4351 if(csi.fs.fsCsb[0]) {
4352 ret->charset = lf.lfCharSet;
4353 ret->codepage = csi.ciACP;
4354 }
4355 else
4356 ret->charset = get_nearest_charset(face, &ret->codepage);
4357
4358 TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family->FamilyName),
4359 debugstr_w(face->StyleName), face->file, face->font_data_ptr, face->face_index);
4360
4361 ret->aveWidth = height ? lf.lfWidth : 0;
4362
4363 if(!face->scalable) {
4364 /* Windows uses integer scaling factors for bitmap fonts */
4365 INT scale, scaled_height;
4366 GdiFont *cachedfont;
4367
4368 /* FIXME: rotation of bitmap fonts is ignored */
4369 height = abs(GDI_ROUND( (double)height * ret->font_desc.matrix.eM22 ));
4370 if (ret->aveWidth)
4371 ret->aveWidth = (double)ret->aveWidth * ret->font_desc.matrix.eM11;
4372 ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
4373 dcmat.eM11 = dcmat.eM22 = 1.0;
4374 /* As we changed the matrix, we need to search the cache for the font again,
4375 * otherwise we might explode the cache. */
4376 if((cachedfont = find_in_cache(hfont, &lf, &dcmat, can_use_bitmap)) != NULL) {
4377 TRACE("Found cached font after non-scalable matrix rescale!\n");
4378 free_font( ret );
4379 ret = cachedfont;
4380 goto done;
4381 }
4382 calc_hash(&ret->font_desc);
4383
4384 if (height != 0) height = diff;
4385 height += face->size.height;
4386
4387 scale = (height + face->size.height - 1) / face->size.height;
4388 scaled_height = scale * face->size.height;
4389 /* Only jump to the next height if the difference <= 25% original height */
4390 if (scale > 2 && scaled_height - height > face->size.height / 4) scale--;
4391 /* The jump between unscaled and doubled is delayed by 1 */
4392 else if (scale == 2 && scaled_height - height > (face->size.height / 4 - 1)) scale--;
4393 ret->scale_y = scale;
4394
4395 width = face->size.x_ppem >> 6;
4396 height = face->size.y_ppem >> 6;
4397 }
4398 else
4399 ret->scale_y = 1.0;
4400 TRACE("font scale y: %f\n", ret->scale_y);
4401
4402 ret->ft_face = OpenFontFace(ret, face, width, height);
4403
4404 if (!ret->ft_face)
4405 {
4406 free_font( ret );
4407 ret = NULL;
4408 goto done;
4409 }
4410
4411 ret->ntmFlags = face->ntmFlags;
4412
4413 if (ret->charset == SYMBOL_CHARSET &&
4414 select_charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
4415 /* No ops */
4416 }
4417 else if (select_charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
4418 /* No ops */
4419 }
4420 else {
4421 select_charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
4422 }
4423
4424 ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
4425 ret->name = psub ? strdupW(psub->from.name) : strdupW(family->FamilyName);
4426 ret->underline = lf.lfUnderline ? 0xff : 0;
4427 ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
4428 create_child_font_list(ret);
4429
4430 if (face->vertical) /* We need to try to load the GSUB table */
4431 {
4432 int length = get_font_data(ret, GSUB_TAG , 0, NULL, 0);
4433 if (length != GDI_ERROR)
4434 {
4435 ret->GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
4436 get_font_data(ret, GSUB_TAG , 0, ret->GSUB_Table, length);
4437 TRACE("Loaded GSUB table of %i bytes\n",length);
4438 }
4439 }
4440
4441 TRACE("caching: gdiFont=%p hfont=%p\n", ret, hfont);
4442
4443 add_to_cache(ret);
4444 done:
4445 if (ret)
4446 {
4447 dc->gdiFont = ret;
4448 physdev->font = ret;
4449 }
4450 LeaveCriticalSection( &freetype_cs );
4451 release_dc_ptr( dc );
4452 return ret ? hfont : 0;
4453 }
4454
4455 static void dump_gdi_font_list(void)
4456 {
4457 GdiFont *gdiFont;
4458 struct list *elem_ptr;
4459
4460 TRACE("---------- gdiFont Cache ----------\n");
4461 LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
4462 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
4463 TRACE("gdiFont=%p %s %d\n",
4464 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
4465 }
4466
4467 TRACE("---------- Unused gdiFont Cache ----------\n");
4468 LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
4469 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
4470 TRACE("gdiFont=%p %s %d\n",
4471 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
4472 }
4473
4474 TRACE("---------- Child gdiFont Cache ----------\n");
4475 LIST_FOR_EACH(elem_ptr, &child_font_list) {
4476 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
4477 TRACE("gdiFont=%p %s %d\n",
4478 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
4479 }
4480 }
4481
4482 /*************************************************************
4483 * WineEngDestroyFontInstance
4484 *
4485 * free the gdiFont associated with this handle
4486 *
4487 */
4488 BOOL WineEngDestroyFontInstance(HFONT handle)
4489 {
4490 GdiFont *gdiFont;
4491 HFONTLIST *hflist;
4492 BOOL ret = FALSE;
4493 struct list *font_elem_ptr, *hfontlist_elem_ptr;
4494 int i = 0;
4495
4496 GDI_CheckNotLock();
4497 EnterCriticalSection( &freetype_cs );
4498
4499 LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
4500 {
4501 hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
4502 while(hfontlist_elem_ptr) {
4503 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
4504 hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
4505 if(hflist->hfont == handle) {
4506 TRACE("removing child font %p from child list\n", gdiFont);
4507 list_remove(&gdiFont->entry);
4508 LeaveCriticalSection( &freetype_cs );
4509 return TRUE;
4510 }
4511 }
4512 }
4513
4514 TRACE("destroying hfont=%p\n", handle);
4515 if(TRACE_ON(font))
4516 dump_gdi_font_list();
4517
4518 font_elem_ptr = list_head(&gdi_font_list);
4519 while(font_elem_ptr) {
4520 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
4521 font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
4522
4523 hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
4524 while(hfontlist_elem_ptr) {
4525 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
4526 hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
4527 if(hflist->hfont == handle) {
4528 list_remove(&hflist->entry);
4529 HeapFree(GetProcessHeap(), 0, hflist);
4530 ret = TRUE;
4531 }
4532 }
4533 if(list_empty(&gdiFont->hfontlist)) {
4534 TRACE("Moving to Unused list\n");
4535 list_remove(&gdiFont->entry);
4536 list_add_head(&unused_gdi_font_list, &gdiFont->entry);
4537 }
4538 }
4539
4540
4541 font_elem_ptr = list_head(&unused_gdi_font_list);
4542 while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
4543 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
4544 while(font_elem_ptr) {
4545 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
4546 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
4547 TRACE("freeing %p\n", gdiFont);
4548 list_remove(&gdiFont->entry);
4549 free_font(gdiFont);
4550 }
4551 LeaveCriticalSection( &freetype_cs );
4552 return ret;
4553 }
4554
4555 static INT load_script_name( UINT id, WCHAR buffer[LF_FACESIZE] )
4556 {
4557 HRSRC rsrc;
4558 HGLOBAL hMem;
4559 WCHAR *p;
4560 int i;
4561
4562 id += IDS_FIRST_SCRIPT;
4563 rsrc = FindResourceW( gdi32_module, (LPCWSTR)(ULONG_PTR)((id >> 4) + 1), (LPCWSTR)6 /*RT_STRING*/ );
4564 if (!rsrc) return 0;
4565 hMem = LoadResource( gdi32_module, rsrc );
4566 if (!hMem) return 0;
4567
4568 p = LockResource( hMem );
4569 id &= 0x000f;
4570 while (id--) p += *p + 1;
4571
4572 i = min(LF_FACESIZE - 1, *p);
4573 memcpy(buffer, p + 1, i * sizeof(WCHAR));
4574 buffer[i] = 0;
4575 return i;
4576 }
4577
4578
4579 /***************************************************
4580 * create_enum_charset_list
4581 *
4582 * This function creates charset enumeration list because in DEFAULT_CHARSET
4583 * case, the ANSI codepage's charset takes precedence over other charsets.
4584 * This function works as a filter other than DEFAULT_CHARSET case.
4585 */
4586 static DWORD create_enum_charset_list(DWORD charset, struct enum_charset_list *list)
4587 {
4588 CHARSETINFO csi;
4589 DWORD n = 0;
4590
4591 if (TranslateCharsetInfo(ULongToPtr(charset), &csi, TCI_SRCCHARSET) &&
4592 csi.fs.fsCsb[0] != 0) {
4593 list->element[n].mask = csi.fs.fsCsb[0];
4594 list->element[n].charset = csi.ciCharset;
4595 load_script_name( ffs(csi.fs.fsCsb[0]) - 1, list->element[n].name );
4596 n++;
4597 }
4598 else { /* charset is DEFAULT_CHARSET or invalid. */
4599 INT acp, i;
4600
4601 /* Set the current codepage's charset as the first element. */
4602 acp = GetACP();
4603 if (TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE) &&
4604 csi.fs.fsCsb[0] != 0) {
4605 list->element[n].mask = csi.fs.fsCsb[0];
4606 list->element[n].charset = csi.ciCharset;
4607 load_script_name( ffs(csi.fs.fsCsb[0]) - 1, list->element[n].name );
4608 n++;
4609 }
4610
4611 /* Fill out left elements. */
4612 for (i = 0; i < 32; i++) {
4613 FONTSIGNATURE fs;
4614 fs.fsCsb[0] = 1L << i;
4615 fs.fsCsb[1] = 0;
4616 if (n > 0 && fs.fsCsb[0] == list->element[0].mask)
4617 continue; /* skip, already added. */
4618 if (!TranslateCharsetInfo(fs.fsCsb, &csi, TCI_SRCFONTSIG))
4619 continue; /* skip, this is an invalid fsCsb bit. */
4620
4621 list->element[n].mask = fs.fsCsb[0];
4622 list->element[n].charset = csi.ciCharset;
4623 load_script_name( i, list->element[n].name );
4624 n++;
4625 }
4626 }
4627 list->total = n;
4628
4629 return n;
4630 }
4631
4632 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
4633 NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
4634 {
4635 GdiFont *font;
4636 LONG width, height;
4637
4638 if (face->cached_enum_data)
4639 {
4640 TRACE("Cached\n");
4641 *pelf = face->cached_enum_data->elf;
4642 *pntm = face->cached_enum_data->ntm;
4643 *ptype = face->cached_enum_data->type;
4644 return;
4645 }
4646
4647 font = alloc_font();
4648
4649 if(face->scalable) {
4650 height = -2048; /* 2048 is the most common em size */
4651 width = 0;
4652 } else {
4653 height = face->size.y_ppem >> 6;
4654 width = face->size.x_ppem >> 6;
4655 }
4656 font->scale_y = 1.0;
4657
4658 if (!(font->ft_face = OpenFontFace(font, face, width, height)))
4659 {
4660 free_font(font);
4661 return;
4662 }
4663
4664 font->name = strdupW(face->family->FamilyName);
4665 font->ntmFlags = face->ntmFlags;
4666
4667 if (get_outline_text_metrics(font))
4668 {
4669 memcpy(&pntm->ntmTm, &font->potm->otmTextMetrics, sizeof(TEXTMETRICW));
4670
4671 pntm->ntmTm.ntmSizeEM = font->potm->otmEMSquare;
4672
4673 lstrcpynW(pelf->elfLogFont.lfFaceName,
4674 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFamilyName),
4675 LF_FACESIZE);
4676 lstrcpynW(pelf->elfFullName,
4677 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFullName),
4678 LF_FULLFACESIZE);
4679 lstrcpynW(pelf->elfStyle,
4680 (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpStyleName),
4681 LF_FACESIZE);
4682 }
4683 else
4684 {
4685 get_text_metrics(font, (TEXTMETRICW *)&pntm->ntmTm);
4686
4687 pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
4688
4689 lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
4690 if (face->FullName)
4691 lstrcpynW(pelf->elfFullName, face->FullName, LF_FULLFACESIZE);
4692 else
4693 lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FULLFACESIZE);
4694 lstrcpynW(pelf->elfStyle, face->StyleName, LF_FACESIZE);
4695 }
4696
4697 pntm->ntmTm.ntmFlags = face->ntmFlags;
4698 pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
4699 pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
4700 pntm->ntmFontSig = face->fs;
4701
4702 pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
4703
4704 pelf->elfLogFont.lfEscapement = 0;
4705 pelf->elfLogFont.lfOrientation = 0;
4706 pelf->elfLogFont.lfHeight = pntm->ntmTm.tmHeight;
4707 pelf->elfLogFont.lfWidth = pntm->ntmTm.tmAveCharWidth;
4708 pelf->elfLogFont.lfWeight = pntm->ntmTm.tmWeight;
4709 pelf->elfLogFont.lfItalic = pntm->ntmTm.tmItalic;
4710 pelf->elfLogFont.lfUnderline = pntm->ntmTm.tmUnderlined;
4711 pelf->elfLogFont.lfStrikeOut = pntm->ntmTm.tmStruckOut;
4712 pelf->elfLogFont.lfCharSet = pntm->ntmTm.tmCharSet;
4713 pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
4714 pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
4715 pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
4716 pelf->elfLogFont.lfPitchAndFamily = (pntm->ntmTm.tmPitchAndFamily & 0xf1) + 1;
4717
4718 *ptype = 0;
4719 if (pntm->ntmTm.tmPitchAndFamily & TMPF_TRUETYPE)
4720 *ptype |= TRUETYPE_FONTTYPE;
4721 if (pntm->ntmTm.tmPitchAndFamily & TMPF_DEVICE)
4722 *ptype |= DEVICE_FONTTYPE;
4723 if(!(pntm->ntmTm.tmPitchAndFamily & TMPF_VECTOR))
4724 *ptype |= RASTER_FONTTYPE;
4725
4726 face->cached_enum_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*face->cached_enum_data));
4727 if (face->cached_enum_data)
4728 {
4729 face->cached_enum_data->elf = *pelf;
4730 face->cached_enum_data->ntm = *pntm;
4731 face->cached_enum_data->type = *ptype;
4732 }
4733
4734 free_font(font);
4735 }
4736
4737 static BOOL family_matches(Family *family, const LOGFONTW *lf)
4738 {
4739 struct list *face_elem_ptr;
4740
4741 if (!strcmpiW(lf->lfFaceName, family->FamilyName)) return TRUE;
4742
4743 LIST_FOR_EACH(face_elem_ptr, &family->faces)
4744 {
4745 static const WCHAR spaceW[] = { ' ',0 };
4746 WCHAR full_family_name[LF_FULLFACESIZE];
4747 Face *face = LIST_ENTRY(face_elem_ptr, Face, entry);
4748
4749 if (strlenW(family->FamilyName) + strlenW(face->StyleName) + 2 > LF_FULLFACESIZE)
4750 {
4751 FIXME("Length of %s + %s + 2 is longer than LF_FULLFACESIZE\n",
4752 debugstr_w(family->FamilyName), debugstr_w(face->StyleName));
4753 continue;
4754 }
4755
4756 strcpyW(full_family_name, family->FamilyName);
4757 strcatW(full_family_name, spaceW);
4758 strcatW(full_family_name, face->StyleName);
4759 if (!strcmpiW(lf->lfFaceName, full_family_name)) return TRUE;
4760 }
4761
4762 return FALSE;
4763 }
4764
4765 static BOOL face_matches(Face *face, const LOGFONTW *lf)
4766 {
4767 static const WCHAR spaceW[] = { ' ',0 };
4768 WCHAR full_family_name[LF_FULLFACESIZE];
4769
4770 if (!strcmpiW(lf->lfFaceName, face->family->FamilyName)) return TRUE;
4771
4772 if (strlenW(face->family->FamilyName) + strlenW(face->StyleName) + 2 > LF_FULLFACESIZE)
4773 {
4774 FIXME("Length of %s + %s + 2 is longer than LF_FULLFACESIZE\n",
4775 debugstr_w(face->family->FamilyName), debugstr_w(face->StyleName));
4776 return FALSE;
4777 }
4778
4779 strcpyW(full_family_name, face->family->FamilyName);
4780 strcatW(full_family_name, spaceW);
4781 strcatW(full_family_name, face->StyleName);
4782 return !strcmpiW(lf->lfFaceName, full_family_name);
4783 }
4784
4785 static BOOL enum_face_charsets(Face *face, struct enum_charset_list *list,
4786 FONTENUMPROCW proc, LPARAM lparam)
4787 {
4788 ENUMLOGFONTEXW elf;
4789 NEWTEXTMETRICEXW ntm;
4790 DWORD type = 0;
4791 int i;
4792
4793 GetEnumStructs(face, &elf, &ntm, &type);
4794 for(i = 0; i < list->total; i++) {
4795 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
4796 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
4797 load_script_name( IDS_OEM_DOS, elf.elfScript );
4798 i = list->total; /* break out of loop after enumeration */
4799 } else if(!(face->fs.fsCsb[0] & list->element[i].mask))
4800 continue;
4801 else {
4802 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = list->element[i].charset;
4803 strcpyW(elf.elfScript, list->element[i].name);
4804 if (!elf.elfScript[0])
4805 FIXME("Unknown elfscript for bit %d\n", ffs(list->element[i].mask) - 1);
4806 }
4807 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
4808 debugstr_w(elf.elfLogFont.lfFaceName),
4809 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
4810 elf.elfLogFont.lfCharSet, type, debugstr_w(elf.elfScript),
4811 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
4812 ntm.ntmTm.ntmFlags);
4813 /* release section before callback (FIXME) */
4814 LeaveCriticalSection( &freetype_cs );
4815 if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return FALSE;
4816 EnterCriticalSection( &freetype_cs );
4817 }
4818 return TRUE;
4819 }
4820
4821 /*************************************************************
4822 * freetype_EnumFonts
4823 */
4824 static BOOL freetype_EnumFonts( PHYSDEV dev, LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam )
4825 {
4826 Family *family;
4827 Face *face;
4828 struct list *family_elem_ptr, *face_elem_ptr;
4829 LOGFONTW lf;
4830 struct enum_charset_list enum_charsets;
4831
4832 if (!plf)
4833 {
4834 lf.lfCharSet = DEFAULT_CHARSET;
4835 lf.lfPitchAndFamily = 0;
4836 lf.lfFaceName[0] = 0;
4837 plf = &lf;
4838 }
4839
4840 TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
4841
4842 create_enum_charset_list(plf->lfCharSet, &enum_charsets);
4843
4844 GDI_CheckNotLock();
4845 EnterCriticalSection( &freetype_cs );
4846 if(plf->lfFaceName[0]) {
4847 FontSubst *psub;
4848 psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
4849
4850 if(psub) {
4851 TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
4852 debugstr_w(psub->to.name));
4853 lf = *plf;
4854 strcpyW(lf.lfFaceName, psub->to.name);
4855 plf = &lf;
4856 }
4857
4858 LIST_FOR_EACH(family_elem_ptr, &font_list) {
4859 family = LIST_ENTRY(family_elem_ptr, Family, entry);
4860 if(family_matches(family, plf)) {
4861 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
4862 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4863 if (!face_matches(face, plf)) continue;
4864 if (!enum_face_charsets(face, &enum_charsets, proc, lparam)) return FALSE;
4865 }
4866 }
4867 }
4868 } else {
4869 LIST_FOR_EACH(family_elem_ptr, &font_list) {
4870 family = LIST_ENTRY(family_elem_ptr, Family, entry);
4871 face_elem_ptr = list_head(&family->faces);
4872 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4873 if (!enum_face_charsets(face, &enum_charsets, proc, lparam)) return FALSE;
4874 }
4875 }
4876 LeaveCriticalSection( &freetype_cs );
4877 return TRUE;
4878 }
4879
4880 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
4881 {
4882 pt->x.value = vec->x >> 6;
4883 pt->x.fract = (vec->x & 0x3f) << 10;
4884 pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
4885 pt->y.value = vec->y >> 6;
4886 pt->y.fract = (vec->y & 0x3f) << 10;
4887 pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
4888 return;
4889 }
4890
4891 /***************************************************
4892 * According to the MSDN documentation on WideCharToMultiByte,
4893 * certain codepages cannot set the default_used parameter.
4894 * This returns TRUE if the codepage can set that parameter, false else
4895 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
4896 */
4897 static BOOL codepage_sets_default_used(UINT codepage)
4898 {
4899 switch (codepage)
4900 {
4901 case CP_UTF7:
4902 case CP_UTF8:
4903 case CP_SYMBOL:
4904 return FALSE;
4905 default:
4906 return TRUE;
4907 }
4908 }
4909
4910 /*
4911 * GSUB Table handling functions
4912 */
4913
4914 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
4915 {
4916 const GSUB_CoverageFormat1* cf1;
4917
4918 cf1 = table;
4919
4920 if (GET_BE_WORD(cf1->CoverageFormat) == 1)
4921 {
4922 int count = GET_BE_WORD(cf1->GlyphCount);
4923 int i;
4924 TRACE("Coverage Format 1, %i glyphs\n",count);
4925 for (i = 0; i < count; i++)
4926 if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
4927 return i;
4928 return -1;
4929 }
4930 else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
4931 {
4932 const GSUB_CoverageFormat2* cf2;
4933 int i;
4934 int count;
4935 cf2 = (const GSUB_CoverageFormat2*)cf1;
4936
4937 count = GET_BE_WORD(cf2->RangeCount);
4938 TRACE("Coverage Format 2, %i ranges\n",count);
4939 for (i = 0; i < count; i++)
4940 {
4941 if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
4942 return -1;
4943 if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
4944 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
4945 {
4946 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
4947 glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
4948 }
4949 }
4950 return -1;
4951 }
4952 else
4953 ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
4954
4955 return -1;
4956 }
4957
4958 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
4959 {
4960 const GSUB_ScriptList *script;
4961 const GSUB_Script *deflt = NULL;
4962 int i;
4963 script = (const GSUB_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
4964
4965 TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
4966 for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
4967 {
4968 const GSUB_Script *scr;
4969 int offset;
4970
4971 offset = GET_BE_WORD(script->ScriptRecord[i].Script);
4972 scr = (const GSUB_Script*)((const BYTE*)script + offset);
4973
4974 if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
4975 return scr;
4976 if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
4977 deflt = scr;
4978 }
4979 return deflt;
4980 }
4981
4982 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
4983 {
4984 int i;
4985 int offset;
4986 const GSUB_LangSys *Lang;
4987
4988 TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
4989
4990 for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
4991 {
4992 offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
4993 Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
4994
4995 if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
4996 return Lang;
4997 }
4998 offset = GET_BE_WORD(script->DefaultLangSys);
4999 if (offset)
5000 {
5001 Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
5002 return Lang;
5003 }
5004 return NULL;
5005 }
5006
5007 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
5008 {
5009 int i;
5010 const GSUB_FeatureList *feature;
5011 feature = (const GSUB_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
5012
5013 TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
5014 for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
5015 {
5016 int index = GET_BE_WORD(lang->FeatureIndex[i]);
5017 if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
5018 {
5019 const GSUB_Feature *feat;
5020 feat = (const GSUB_Feature*)((const BYTE*)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
5021 return feat;
5022 }
5023 }
5024 return NULL;
5025 }
5026
5027 static FT_UInt GSUB_apply_feature(const GSUB_Header * header, const GSUB_Feature* feature, UINT glyph)
5028 {
5029 int i;
5030 int offset;
5031 const GSUB_LookupList *lookup;
5032 lookup = (const GSUB_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
5033
5034 TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
5035 for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
5036 {
5037 const GSUB_LookupTable *look;
5038 offset = GET_BE_WORD(lookup->Lookup[GET_BE_WORD(feature->LookupListIndex[i])]);
5039 look = (const GSUB_LookupTable*)((const BYTE*)lookup + offset);
5040 TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
5041 if (GET_BE_WORD(look->LookupType) != 1)
5042 FIXME("We only handle SubType 1\n");
5043 else
5044 {
5045 int j;
5046
5047 for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
5048 {
5049 const GSUB_SingleSubstFormat1 *ssf1;
5050 offset = GET_BE_WORD(look->SubTable[j]);
5051 ssf1 = (const GSUB_SingleSubstFormat1*)((const BYTE*)look+offset);
5052 if (GET_BE_WORD(ssf1->SubstFormat) == 1)
5053 {
5054 int offset = GET_BE_WORD(ssf1->Coverage);
5055 TRACE(" subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
5056 if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyph) != -1)
5057 {
5058 TRACE(" Glyph 0x%x ->",glyph);
5059 glyph += GET_BE_WORD(ssf1->DeltaGlyphID);
5060 TRACE(" 0x%x\n",glyph);
5061 }
5062 }
5063 else
5064 {
5065 const GSUB_SingleSubstFormat2 *ssf2;
5066 INT index;
5067 INT offset;
5068
5069 ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
5070 offset = GET_BE_WORD(ssf1->Coverage);
5071 TRACE(" subtype 2, glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
5072 index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyph);
5073 TRACE(" Coverage index %i\n",index);
5074 if (index != -1)
5075 {
5076 TRACE(" Glyph is 0x%x ->",glyph);
5077 glyph = GET_BE_WORD(ssf2->Substitute[index]);
5078 TRACE("0x%x\n",glyph);
5079 }
5080 }
5081 }
5082 }
5083 }
5084 return glyph;
5085 }
5086
5087 static const char* get_opentype_script(const GdiFont *font)
5088 {
5089 /*
5090 * I am not sure if this is the correct way to generate our script tag
5091 */
5092
5093 switch (font->charset)
5094 {
5095 case ANSI_CHARSET: return "latn";
5096 case BALTIC_CHARSET: return "latn"; /* ?? */
5097 case CHINESEBIG5_CHARSET: return "hani";
5098 case EASTEUROPE_CHARSET: return "latn"; /* ?? */
5099 case GB2312_CHARSET: return "hani";
5100 case GREEK_CHARSET: return "grek";
5101 case HANGUL_CHARSET: return "hang";
5102 case RUSSIAN_CHARSET: return "cyrl";
5103 case SHIFTJIS_CHARSET: return "kana";
5104 case TURKISH_CHARSET: return "latn"; /* ?? */
5105 case VIETNAMESE_CHARSET: return "latn";
5106 case JOHAB_CHARSET: return "latn"; /* ?? */
5107 case ARABIC_CHARSET: return "arab";
5108 case HEBREW_CHARSET: return "hebr";
5109 case THAI_CHARSET: return "thai";
5110 default: return "latn";
5111 }
5112 }
5113
5114 static FT_UInt get_GSUB_vert_glyph(const GdiFont *font, UINT glyph)
5115 {
5116 const GSUB_Header *header;
5117 const GSUB_Script *script;
5118 const GSUB_LangSys *language;
5119 const GSUB_Feature *feature;
5120
5121 if (!font->GSUB_Table)
5122 return glyph;
5123
5124 header = font->GSUB_Table;
5125
5126 script = GSUB_get_script_table(header, get_opentype_script(font));
5127 if (!script)
5128 {
5129 TRACE("Script not found\n");
5130 return glyph;
5131 }
5132 language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
5133 if (!language)
5134 {
5135 TRACE("Language not found\n");
5136 return glyph;
5137 }
5138 feature = GSUB_get_feature(header, language, "vrt2");
5139 if (!feature)
5140 feature = GSUB_get_feature(header, language, "vert");
5141 if (!feature)
5142 {
5143 TRACE("vrt2/vert feature not found\n");
5144 return glyph;
5145 }
5146 return GSUB_apply_feature(header, feature, glyph);
5147 }
5148
5149 static FT_UInt get_glyph_index(const GdiFont *font, UINT glyph)
5150 {
5151 FT_UInt glyphId;
5152
5153 if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
5154 WCHAR wc = (WCHAR)glyph;
5155 BOOL default_used;
5156 BOOL *default_used_pointer;
5157 FT_UInt ret;
5158 char buf;
5159 default_used_pointer = NULL;
5160 default_used = FALSE;
5161 if (codepage_sets_default_used(font->codepage))
5162 default_used_pointer = &default_used;
5163 if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
5164 ret = 0;
5165 else
5166 ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
5167 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
5168 return ret;
5169 }
5170
5171 if(font->ft_face->charmap->encoding == FT_ENCODING_MS_SYMBOL)
5172 {
5173 if (glyph < 0x100) glyph += 0xf000;
5174 /* there is a number of old pre-Unicode "broken" TTFs, which
5175 do have symbols at U+00XX instead of U+f0XX */
5176 if (!(glyphId = pFT_Get_Char_Index(font->ft_face, glyph)))
5177 glyphId = pFT_Get_Char_Index(font->ft_face, glyph-0xf000);
5178 }
5179 else glyphId = pFT_Get_Char_Index(font->ft_face, glyph);
5180
5181 return glyphId;
5182 }
5183
5184 /*************************************************************
5185 * freetype_GetGlyphIndices
5186 */
5187 static DWORD freetype_GetGlyphIndices( PHYSDEV dev, LPCWSTR lpstr, INT count, LPWORD pgi, DWORD flags )
5188 {
5189 struct freetype_physdev *physdev = get_freetype_dev( dev );
5190 int i;
5191 WORD default_char;
5192 BOOL got_default = FALSE;
5193
5194 if (!physdev->font)
5195 {
5196 dev = GET_NEXT_PHYSDEV( dev, pGetGlyphIndices );
5197 return dev->funcs->pGetGlyphIndices( dev, lpstr, count, pgi, flags );
5198 }
5199
5200 if (flags & GGI_MARK_NONEXISTING_GLYPHS)
5201 {
5202 default_char = 0xffff; /* XP would use 0x1f for bitmap fonts */
5203 got_default = TRUE;
5204 }
5205
5206 GDI_CheckNotLock();
5207 EnterCriticalSection( &freetype_cs );
5208
5209 for(i = 0; i < count; i++)
5210 {
5211 pgi[i] = get_glyph_index(physdev->font, lpstr[i]);
5212 if (pgi[i] == 0)
5213 {
5214 if (!got_default)
5215 {
5216 if (FT_IS_SFNT(physdev->font->ft_face))
5217 {
5218 TT_OS2 *pOS2 = pFT_Get_Sfnt_Table(physdev->font->ft_face, ft_sfnt_os2);
5219 default_char = (pOS2->usDefaultChar ? get_glyph_index(physdev->font, pOS2->usDefaultChar) : 0);
5220 }
5221 else
5222 {
5223 TEXTMETRICW textm;
5224 get_text_metrics(physdev->font, &textm);
5225 default_char = textm.tmDefaultChar;
5226 }
5227 got_default = TRUE;
5228 }
5229 pgi[i] = default_char;
5230 }
5231 }
5232 LeaveCriticalSection( &freetype_cs );
5233 return count;
5234 }
5235
5236 static inline BOOL is_identity_FMAT2(const FMAT2 *matrix)
5237 {
5238 static const FMAT2 identity = { 1.0, 0.0, 0.0, 1.0 };
5239 return !memcmp(matrix, &identity, sizeof(FMAT2));
5240 }
5241
5242 static inline BOOL is_identity_MAT2(const MAT2 *matrix)
5243 {
5244 static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
5245 return !memcmp(matrix, &identity, sizeof(MAT2));
5246 }
5247
5248 static inline BYTE get_max_level( UINT format )
5249 {
5250 switch( format )
5251 {
5252 case GGO_GRAY2_BITMAP: return 4;
5253 case GGO_GRAY4_BITMAP: return 16;
5254 case GGO_GRAY8_BITMAP: return 64;
5255 }
5256 return 255;
5257 }
5258
5259 static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
5260
5261 static DWORD get_glyph_outline(GdiFont *incoming_font, UINT glyph, UINT format,
5262 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
5263 const MAT2* lpmat)
5264 {
5265 static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
5266 FT_Face ft_face = incoming_font->ft_face;
5267 GdiFont *font = incoming_font;
5268 FT_UInt glyph_index;
5269 DWORD width, height, pitch, needed = 0;
5270 FT_Bitmap ft_bitmap;
5271 FT_Error err;
5272 INT left, right, top = 0, bottom = 0, adv, lsb, bbx;
5273 FT_Angle angle = 0;
5274 FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
5275 double widthRatio = 1.0;
5276 FT_Matrix transMat = identityMat;
5277 FT_Matrix transMatUnrotated;
5278 BOOL needsTransform = FALSE;
5279 BOOL tategaki = (font->GSUB_Table != NULL);
5280 UINT original_index;
5281
5282 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
5283 buflen, buf, lpmat);
5284
5285 TRACE("font transform %f %f %f %f\n",
5286 font->font_desc.matrix.eM11, font->font_desc.matrix.eM12,
5287 font->font_desc.matrix.eM21, font->font_desc.matrix.eM22);
5288
5289 if(format & GGO_GLYPH_INDEX) {
5290 glyph_index = get_GSUB_vert_glyph(incoming_font,glyph);
5291 original_index = glyph;
5292 format &= ~GGO_GLYPH_INDEX;
5293 } else {
5294 get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
5295 ft_face = font->ft_face;
5296 original_index = glyph_index;
5297 }
5298
5299 if(format & GGO_UNHINTED) {
5300 load_flags |= FT_LOAD_NO_HINTING;
5301 format &= ~GGO_UNHINTED;
5302 }
5303
5304 /* tategaki never appears to happen to lower glyph index */
5305 if (glyph_index < TATEGAKI_LOWER_BOUND )
5306 tategaki = FALSE;
5307
5308 if(original_index >= font->gmsize * GM_BLOCK_SIZE) {
5309 font->gmsize = (original_index / GM_BLOCK_SIZE + 1);
5310 font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
5311 font->gmsize * sizeof(GM*));
5312 } else {
5313 if (format == GGO_METRICS && font->gm[original_index / GM_BLOCK_SIZE] != NULL &&
5314 FONT_GM(font,original_index)->init && is_identity_MAT2(lpmat))
5315 {
5316 *lpgm = FONT_GM(font,original_index)->gm;
5317 TRACE("cached: %u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
5318 wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
5319 lpgm->gmCellIncX, lpgm->gmCellIncY);
5320 return 1; /* FIXME */
5321 }
5322 }
5323
5324 if (!font->gm[original_index / GM_BLOCK_SIZE])
5325 font->gm[original_index / GM_BLOCK_SIZE] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
5326
5327 /* Scaling factor */
5328 if (font->aveWidth)
5329 {
5330 TEXTMETRICW tm;
5331
5332 get_text_metrics(font, &tm);
5333
5334 widthRatio = (double)font->aveWidth;
5335 widthRatio /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
5336 }
5337 else
5338 widthRatio = font->scale_y;
5339
5340 /* Scaling transform */
5341 if (widthRatio != 1.0 || font->scale_y != 1.0)
5342 {
5343 FT_Matrix scaleMat;
5344 scaleMat.xx = FT_FixedFromFloat(widthRatio);
5345 scaleMat.xy = 0;
5346 scaleMat.yx = 0;
5347 scaleMat.yy = FT_FixedFromFloat(font->scale_y);
5348
5349 pFT_Matrix_Multiply(&scaleMat, &transMat);
5350 needsTransform = TRUE;
5351 }
5352
5353 /* Slant transform */
5354 if (font->fake_italic) {
5355 FT_Matrix slantMat;
5356
5357 slantMat.xx = (1 << 16);
5358 slantMat.xy = ((1 << 16) >> 2);
5359 slantMat.yx = 0;
5360 slantMat.yy = (1 << 16);
5361 pFT_Matrix_Multiply(&slantMat, &transMat);
5362 needsTransform = TRUE;
5363 }
5364
5365 /* Rotation transform */
5366 transMatUnrotated = transMat;
5367 if(font->orientation && !tategaki) {
5368 FT_Matrix rotationMat;
5369 FT_Vector vecAngle;
5370 angle = FT_FixedFromFloat((double)font->orientation / 10.0);
5371 pFT_Vector_Unit(&vecAngle, angle);
5372 rotationMat.xx = vecAngle.x;
5373 rotationMat.xy = -vecAngle.y;
5374 rotationMat.yx = -rotationMat.xy;
5375 rotationMat.yy = rotationMat.xx;
5376
5377 pFT_Matrix_Multiply(&rotationMat, &transMat);
5378 needsTransform = TRUE;
5379 }
5380
5381 /* World transform */
5382 if (!is_identity_FMAT2(&font->font_desc.matrix))
5383 {
5384 FT_Matrix worldMat;
5385 worldMat.xx = FT_FixedFromFloat(font->font_desc.matrix.eM11);
5386 worldMat.xy = FT_FixedFromFloat(font->font_desc.matrix.eM12);
5387 worldMat.yx = FT_FixedFromFloat(font->font_desc.matrix.eM21);
5388 worldMat.yy = FT_FixedFromFloat(font->font_desc.matrix.eM22);
5389 pFT_Matrix_Multiply(&worldMat, &transMat);
5390 pFT_Matrix_Multiply(&worldMat, &transMatUnrotated);
5391 needsTransform = TRUE;
5392 }
5393
5394 /* Extra transformation specified by caller */
5395 if (!is_identity_MAT2(lpmat))
5396 {
5397 FT_Matrix extraMat;
5398 extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
5399 extraMat.xy = FT_FixedFromFIXED(lpmat->eM12);
5400 extraMat.yx = FT_FixedFromFIXED(lpmat->eM21);
5401 extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
5402 pFT_Matrix_Multiply(&extraMat, &transMat);
5403 pFT_Matrix_Multiply(&extraMat, &transMatUnrotated);
5404 needsTransform = TRUE;
5405 }
5406
5407 if (needsTransform || (format == GGO_NATIVE || format == GGO_BEZIER ||
5408 format == GGO_GRAY2_BITMAP || format == GGO_GRAY4_BITMAP ||
5409 format == GGO_GRAY8_BITMAP))
5410 {
5411 load_flags |= FT_LOAD_NO_BITMAP;
5412 }
5413
5414 err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
5415
5416 if(err) {
5417 WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
5418 return GDI_ERROR;
5419 }
5420
5421 if(!needsTransform) {
5422 left = (INT)(ft_face->glyph->metrics.horiBearingX) & -64;
5423 right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) + 63) & -64;
5424 adv = (INT)(ft_face->glyph->metrics.horiAdvance + 63) >> 6;
5425
5426 top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
5427 bottom = (ft_face->glyph->metrics.horiBearingY -
5428 ft_face->glyph->metrics.height) & -64;
5429 lpgm->gmCellIncX = adv;
5430 lpgm->gmCellIncY = 0;
5431 } else {
5432 INT xc, yc;
5433 FT_Vector vec;
5434
5435 left = right = 0;
5436
5437 for(xc = 0; xc < 2; xc++) {
5438 for(yc = 0; yc < 2; yc++) {
5439 vec.x = (ft_face->glyph->metrics.horiBearingX +
5440 xc * ft_face->glyph->metrics.width);
5441 vec.y = ft_face->glyph->metrics.horiBearingY -
5442 yc * ft_face->glyph->metrics.height;
5443 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
5444 pFT_Vector_Transform(&vec, &transMat);
5445 if(xc == 0 && yc == 0) {
5446 left = right = vec.x;
5447 top = bottom = vec.y;
5448 } else {
5449 if(vec.x < left) left = vec.x;
5450 else if(vec.x > right) right = vec.x;
5451 if(vec.y < bottom) bottom = vec.y;
5452 else if(vec.y > top) top = vec.y;
5453 }
5454 }
5455 }
5456 left = left & -64;
5457 right = (right + 63) & -64;
5458 bottom = bottom & -64;
5459 top = (top + 63) & -64;
5460
5461 TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
5462 vec.x = ft_face->glyph->metrics.horiAdvance;
5463 vec.y = 0;
5464 pFT_Vector_Transform(&vec, &transMat);
5465 lpgm->gmCellIncX = (vec.x+63) >> 6;
5466 lpgm->gmCellIncY = -((vec.y+63) >> 6);
5467
5468 vec.x = ft_face->glyph->metrics.horiAdvance;
5469 vec.y = 0;
5470 pFT_Vector_Transform(&vec, &transMatUnrotated);
5471 adv = (vec.x+63) >> 6;
5472 }
5473
5474 lsb = left >> 6;
5475 bbx = (right - left) >> 6;
5476 lpgm->gmBlackBoxX = (right - left) >> 6;
5477 lpgm->gmBlackBoxY = (top - bottom) >> 6;
5478 lpgm->gmptGlyphOrigin.x = left >> 6;
5479 lpgm->gmptGlyphOrigin.y = top >> 6;
5480
5481 TRACE("%u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
5482 wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
5483 lpgm->gmCellIncX, lpgm->gmCellIncY);
5484
5485 if ((format == GGO_METRICS || format == GGO_BITMAP || format == WINE_GGO_GRAY16_BITMAP) &&
5486 is_identity_MAT2(lpmat)) /* don't cache custom transforms */
5487 {
5488 FONT_GM(font,original_index)->gm = *lpgm;
5489 FONT_GM(font,original_index)->adv = adv;
5490 FONT_GM(font,original_index)->lsb = lsb;
5491 FONT_GM(font,original_index)->bbx = bbx;
5492 FONT_GM(font,original_index)->init = TRUE;
5493 }
5494
5495 if(format == GGO_METRICS)
5496 {
5497 return 1; /* FIXME */
5498 }
5499
5500 if(ft_face->glyph->format != ft_glyph_format_outline &&
5501 (format == GGO_NATIVE || format == GGO_BEZIER))
5502 {
5503 TRACE("loaded a bitmap\n");
5504 return GDI_ERROR;
5505 }
5506
5507 switch(format) {
5508 case GGO_BITMAP:
5509 width = lpgm->gmBlackBoxX;
5510 height = lpgm->gmBlackBoxY;
5511 pitch = ((width + 31) >> 5) << 2;
5512 needed = pitch * height;
5513
5514 if(!buf || !buflen) break;
5515
5516 switch(ft_face->glyph->format) {
5517 case ft_glyph_format_bitmap:
5518 {
5519 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
5520 INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
5521 INT h = ft_face->glyph->bitmap.rows;
5522 while(h--) {
5523 memcpy(dst, src, w);
5524 src += ft_face->glyph->bitmap.pitch;
5525 dst += pitch;
5526 }
5527 break;
5528 }
5529
5530 case ft_glyph_format_outline:
5531 ft_bitmap.width = width;
5532 ft_bitmap.rows = height;
5533 ft_bitmap.pitch = pitch;
5534 ft_bitmap.pixel_mode = ft_pixel_mode_mono;
5535 ft_bitmap.buffer = buf;
5536
5537 if(needsTransform)
5538 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
5539
5540 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
5541
5542 /* Note: FreeType will only set 'black' bits for us. */
5543 memset(buf, 0, needed);
5544 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
5545 break;
5546
5547 default:
5548 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
5549 return GDI_ERROR;
5550 }
5551 break;
5552
5553 case GGO_GRAY2_BITMAP:
5554 case GGO_GRAY4_BITMAP:
5555 case GGO_GRAY8_BITMAP:
5556 case WINE_GGO_GRAY16_BITMAP:
5557 {
5558 unsigned int max_level, row, col;
5559 BYTE *start, *ptr;
5560
5561 width = lpgm->gmBlackBoxX;
5562 height = lpgm->gmBlackBoxY;
5563 pitch = (width + 3) / 4 * 4;
5564 needed = pitch * height;
5565
5566 if(!buf || !buflen) break;
5567
5568 max_level = get_max_level( format );
5569
5570 switch(ft_face->glyph->format) {
5571 case ft_glyph_format_bitmap:
5572 {
5573 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
5574 INT h = ft_face->glyph->bitmap.rows;
5575 INT x;
5576 memset( buf, 0, needed );
5577 while(h--) {
5578 for(x = 0; x < pitch && x < ft_face->glyph->bitmap.width; x++)
5579 if (src[x / 8] & masks[x % 8]) dst[x] = max_level;
5580 src += ft_face->glyph->bitmap.pitch;
5581 dst += pitch;
5582 }
5583 return needed;
5584 }
5585 case ft_glyph_format_outline:
5586 {
5587 ft_bitmap.width = width;
5588 ft_bitmap.rows = height;
5589 ft_bitmap.pitch = pitch;
5590 ft_bitmap.pixel_mode = ft_pixel_mode_grays;
5591 ft_bitmap.buffer = buf;
5592
5593 if(needsTransform)
5594 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
5595
5596 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
5597
5598 memset(ft_bitmap.buffer, 0, buflen);
5599
5600 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
5601
5602 if (max_level != 255)
5603 {
5604 for (row = 0, start = buf; row < height; row++)
5605 {
5606 for (col = 0, ptr = start; col < width; col++, ptr++)
5607 *ptr = (((int)*ptr) * max_level + 128) / 256;
5608 start += pitch;
5609 }
5610 }
5611 return needed;
5612 }
5613
5614 default:
5615 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
5616 return GDI_ERROR;
5617 }
5618 break;
5619 }
5620
5621 case WINE_GGO_HRGB_BITMAP:
5622 case WINE_GGO_HBGR_BITMAP:
5623 case WINE_GGO_VRGB_BITMAP:
5624 case WINE_GGO_VBGR_BITMAP:
5625 #ifdef HAVE_FREETYPE_FTLCDFIL_H
5626 {
5627 switch (ft_face->glyph->format)
5628 {
5629 case FT_GLYPH_FORMAT_BITMAP:
5630 {
5631 BYTE *src, *dst;
5632 INT src_pitch, x;
5633
5634 width = lpgm->gmBlackBoxX;
5635 height = lpgm->gmBlackBoxY;
5636 pitch = width * 4;
5637 needed = pitch * height;
5638
5639 if (!buf || !buflen) break;
5640
5641 memset(buf, 0, buflen);
5642 dst = buf;
5643 src = ft_face->glyph->bitmap.buffer;
5644 src_pitch = ft_face->glyph->bitmap.pitch;
5645
5646 height = min( height, ft_face->glyph->bitmap.rows );
5647 while ( height-- )
5648 {
5649 for (x = 0; x < width && x < ft_face->glyph->bitmap.width; x++)
5650 {
5651 if ( src[x / 8] & masks[x % 8] )
5652 ((unsigned int *)dst)[x] = ~0u;
5653 }
5654 src += src_pitch;
5655 dst += pitch;
5656 }
5657
5658 break;
5659 }
5660
5661 case FT_GLYPH_FORMAT_OUTLINE:
5662 {
5663 unsigned int *dst;
5664 BYTE *src;
5665 INT x, src_pitch, src_width, src_height, rgb_interval, hmul, vmul;
5666 INT x_shift, y_shift;
5667 BOOL rgb;
5668 FT_LcdFilter lcdfilter = FT_LCD_FILTER_DEFAULT;
5669 FT_Render_Mode render_mode =
5670 (format == WINE_GGO_HRGB_BITMAP || format == WINE_GGO_HBGR_BITMAP)?
5671 FT_RENDER_MODE_LCD: FT_RENDER_MODE_LCD_V;
5672
5673 if ( lcdfilter == FT_LCD_FILTER_DEFAULT || lcdfilter == FT_LCD_FILTER_LIGHT )
5674 {
5675 if ( render_mode == FT_RENDER_MODE_LCD)
5676 {
5677 lpgm->gmBlackBoxX += 2;
5678 lpgm->gmptGlyphOrigin.x -= 1;
5679 }
5680 else
5681 {
5682 lpgm->gmBlackBoxY += 2;
5683 lpgm->gmptGlyphOrigin.y += 1;
5684 }
5685 }
5686
5687 width = lpgm->gmBlackBoxX;
5688 height = lpgm->gmBlackBoxY;
5689 pitch = width * 4;
5690 needed = pitch * height;
5691
5692 if (!buf || !buflen) break;
5693
5694 memset(buf, 0, buflen);
5695 dst = buf;
5696 rgb = (format == WINE_GGO_HRGB_BITMAP || format == WINE_GGO_VRGB_BITMAP);
5697
5698 if ( needsTransform )
5699 pFT_Outline_Transform (&ft_face->glyph->outline, &transMat);
5700
5701 if ( pFT_Library_SetLcdFilter )
5702 pFT_Library_SetLcdFilter( library, lcdfilter );
5703 pFT_Render_Glyph (ft_face->glyph, render_mode);
5704
5705 src = ft_face->glyph->bitmap.buffer;
5706 src_pitch = ft_face->glyph->bitmap.pitch;
5707 src_width = ft_face->glyph->bitmap.width;
5708 src_height = ft_face->glyph->bitmap.rows;
5709
5710 if ( render_mode == FT_RENDER_MODE_LCD)
5711 {
5712 rgb_interval = 1;
5713 hmul = 3;
5714 vmul = 1;
5715 }
5716 else
5717 {
5718 rgb_interval = src_pitch;
5719 hmul = 1;
5720 vmul = 3;
5721 }
5722
5723 x_shift = ft_face->glyph->bitmap_left - lpgm->gmptGlyphOrigin.x;
5724 if ( x_shift < 0 ) x_shift = 0;
5725 if ( x_shift + (src_width / hmul) > width )
5726 x_shift = width - (src_width / hmul);
5727
5728 y_shift = lpgm->gmptGlyphOrigin.y - ft_face->glyph->bitmap_top;
5729 if ( y_shift < 0 ) y_shift = 0;
5730 if ( y_shift + (src_height / vmul) > height )
5731 y_shift = height - (src_height / vmul);
5732
5733 dst += x_shift + y_shift * ( pitch / 4 );
5734 while ( src_height )
5735 {
5736 for ( x = 0; x < src_width / hmul; x++ )
5737 {
5738 if ( rgb )
5739 {
5740 dst[x] = ((unsigned int)src[hmul * x + rgb_interval * 0] << 16) |
5741 ((unsigned int)src[hmul * x + rgb_interval * 1] << 8) |
5742 ((unsigned int)src[hmul * x + rgb_interval * 2] << 0) |
5743 ((unsigned int)src[hmul * x + rgb_interval * 1] << 24) ;
5744 }
5745 else
5746 {
5747 dst[x] = ((unsigned int)src[hmul * x + rgb_interval * 2] << 16) |
5748 ((unsigned int)src[hmul * x + rgb_interval * 1] << 8) |
5749 ((unsigned int)src[hmul * x + rgb_interval * 0] << 0) |
5750 ((unsigned int)src[hmul * x + rgb_interval * 1] << 24) ;
5751 }
5752 }
5753 src += src_pitch * vmul;
5754 dst += pitch / 4;
5755 src_height -= vmul;
5756 }
5757
5758 break;
5759 }
5760
5761 default:
5762 FIXME ("loaded glyph format %x\n", ft_face->glyph->format);
5763 return GDI_ERROR;
5764 }
5765
5766 break;
5767 }
5768 #else
5769 return GDI_ERROR;
5770 #endif
5771
5772 case GGO_NATIVE:
5773 {
5774 int contour, point = 0, first_pt;
5775 FT_Outline *outline = &ft_face->glyph->outline;
5776 TTPOLYGONHEADER *pph;
5777 TTPOLYCURVE *ppc;
5778 DWORD pph_start, cpfx, type;
5779
5780 if(buflen == 0) buf = NULL;
5781
5782 if (needsTransform && buf) {
5783 pFT_Outline_Transform(outline, &transMat);
5784 }
5785
5786 for(contour = 0; contour < outline->n_contours; contour++) {
5787 pph_start = needed;
5788 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
5789 first_pt = point;
5790 if(buf) {
5791 pph->dwType = TT_POLYGON_TYPE;
5792 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
5793 }
5794 needed += sizeof(*pph);
5795 point++;
5796 while(point <= outline->contours[contour]) {
5797 ppc = (TTPOLYCURVE *)((char *)buf + needed);
5798 type = (outline->tags[point] & FT_Curve_Tag_On) ?
5799 TT_PRIM_LINE : TT_PRIM_QSPLINE;
5800 cpfx = 0;
5801 do {
5802 if(buf)
5803 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
5804 cpfx++;
5805 point++;
5806 } while(point <= outline->contours[contour] &&
5807 (outline->tags[point] & FT_Curve_Tag_On) ==
5808 (outline->tags[point-1] & FT_Curve_Tag_On));
5809 /* At the end of a contour Windows adds the start point, but
5810 only for Beziers */
5811 if(point > outline->contours[contour] &&
5812 !(outline->tags[point-1] & FT_Curve_Tag_On)) {
5813 if(buf)
5814 FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
5815 cpfx++;
5816 } else if(point <= outline->contours[contour] &&
5817 outline->tags[point] & FT_Curve_Tag_On) {
5818 /* add closing pt for bezier */
5819 if(buf)
5820 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
5821 cpfx++;
5822 point++;
5823 }
5824 if(buf) {
5825 ppc->wType = type;
5826 ppc->cpfx = cpfx;
5827 }
5828 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
5829 }
5830 if(buf)
5831 pph->cb = needed - pph_start;
5832 }
5833 break;
5834 }
5835 case GGO_BEZIER:
5836 {
5837 /* Convert the quadratic Beziers to cubic Beziers.
5838 The parametric eqn for a cubic Bezier is, from PLRM:
5839 r(t) = at^3 + bt^2 + ct + r0
5840 with the control points:
5841 r1 = r0 + c/3
5842 r2 = r1 + (c + b)/3
5843 r3 = r0 + c + b + a
5844
5845 A quadratic Bezier has the form:
5846 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
5847
5848 So equating powers of t leads to:
5849 r1 = 2/3 p1 + 1/3 p0
5850 r2 = 2/3 p1 + 1/3 p2
5851 and of course r0 = p0, r3 = p2
5852 */
5853
5854 int contour, point = 0, first_pt;
5855 FT_Outline *outline = &ft_face->glyph->outline;
5856 TTPOLYGONHEADER *pph;
5857 TTPOLYCURVE *ppc;
5858 DWORD pph_start, cpfx, type;
5859 FT_Vector cubic_control[4];
5860 if(buflen == 0) buf = NULL;
5861
5862 if (needsTransform && buf) {
5863 pFT_Outline_Transform(outline, &transMat);
5864 }
5865
5866 for(contour = 0; contour < outline->n_contours; contour++) {
5867 pph_start = needed;
5868 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
5869 first_pt = point;
5870 if(buf) {
5871 pph->dwType = TT_POLYGON_TYPE;
5872 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
5873 }
5874 needed += sizeof(*pph);
5875 point++;
5876 while(point <= outline->contours[contour]) {
5877 ppc = (TTPOLYCURVE *)((char *)buf + needed);
5878 type = (outline->tags[point] & FT_Curve_Tag_On) ?
5879 TT_PRIM_LINE : TT_PRIM_CSPLINE;
5880 cpfx = 0;
5881 do {
5882 if(type == TT_PRIM_LINE) {
5883 if(buf)
5884 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
5885 cpfx++;
5886 point++;
5887 } else {
5888 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
5889 so cpfx = 3n */
5890
5891 /* FIXME: Possible optimization in endpoint calculation
5892 if there are two consecutive curves */
5893 cubic_control[0] = outline->points[point-1];
5894 if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
5895 cubic_control[0].x += outline->points[point].x + 1;
5896 cubic_control[0].y += outline->points[point].y + 1;
5897 cubic_control[0].x >>= 1;
5898 cubic_control[0].y >>= 1;
5899 }
5900 if(point+1 > outline->contours[contour])
5901 cubic_control[3] = outline->points[first_pt];
5902 else {
5903 cubic_control[3] = outline->points[point+1];
5904 if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
5905 cubic_control[3].x += outline->points[point].x + 1;
5906 cubic_control[3].y += outline->points[point].y + 1;
5907 cubic_control[3].x >>= 1;
5908 cubic_control[3].y >>= 1;
5909 }
5910 }
5911 /* r1 = 1/3 p0 + 2/3 p1
5912 r2 = 1/3 p2 + 2/3 p1 */
5913 cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
5914 cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
5915 cubic_control[2] = cubic_control[1];
5916 cubic_control[1].x += (cubic_control[0].x + 1) / 3;
5917 cubic_control[1].y += (cubic_control[0].y + 1) / 3;
5918 cubic_control[2].x += (cubic_control[3].x + 1) / 3;
5919 cubic_control[2].y += (cubic_control[3].y + 1) / 3;
5920 if(buf) {
5921 FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
5922 FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
5923 FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
5924 }
5925 cpfx += 3;
5926 point++;
5927 }
5928 } while(point <= outline->contours[contour] &&
5929 (outline->tags[point] & FT_Curve_Tag_On) ==
5930 (outline->tags[point-1] & FT_Curve_Tag_On));
5931 /* At the end of a contour Windows adds the start point,
5932 but only for Beziers and we've already done that.
5933 */
5934 if(point <= outline->contours[contour] &&
5935 outline->tags[point] & FT_Curve_Tag_On) {
5936 /* This is the closing pt of a bezier, but we've already
5937 added it, so just inc point and carry on */
5938 point++;
5939 }
5940 if(buf) {
5941 ppc->wType = type;
5942 ppc->cpfx = cpfx;
5943 }
5944 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
5945 }
5946 if(buf)
5947 pph->cb = needed - pph_start;
5948 }
5949 break;
5950 }
5951
5952 default:
5953 FIXME("Unsupported format %d\n", format);
5954 return GDI_ERROR;
5955 }
5956 return needed;
5957 }
5958
5959 static BOOL get_bitmap_text_metrics(GdiFont *font)
5960 {
5961 FT_Face ft_face = font->ft_face;
5962 FT_WinFNT_HeaderRec winfnt_header;
5963 const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
5964 font->potm = HeapAlloc(GetProcessHeap(), 0, size);
5965 font->potm->otmSize = size;
5966
5967 #define TM font->potm->otmTextMetrics
5968 if(!pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
5969 {
5970 TM.tmHeight = winfnt_header.pixel_height;
5971 TM.tmAscent = winfnt_header.ascent;
5972 TM.tmDescent = TM.tmHeight - TM.tmAscent;
5973 TM.tmInternalLeading = winfnt_header.internal_leading;
5974 TM.tmExternalLeading = winfnt_header.external_leading;
5975 TM.tmAveCharWidth = winfnt_header.avg_width;
5976 TM.tmMaxCharWidth = winfnt_header.max_width;
5977 TM.tmWeight = winfnt_header.weight;
5978 TM.tmOverhang = 0;
5979 TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
5980 TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
5981 TM.tmFirstChar = winfnt_header.first_char;
5982 TM.tmLastChar = winfnt_header.last_char;
5983 TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
5984 TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
5985 TM.tmItalic = winfnt_header.italic;
5986 TM.tmUnderlined = font->underline;
5987 TM.tmStruckOut = font->strikeout;
5988 TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
5989 TM.tmCharSet = winfnt_header.charset;
5990 }
5991 else
5992 {
5993 TM.tmAscent = ft_face->size->metrics.ascender >> 6;
5994 TM.tmDescent = -ft_face->size->metrics.descender >> 6;
5995 TM.tmHeight = TM.tmAscent + TM.tmDescent;
5996 TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
5997 TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
5998 TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
5999 TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
6000 TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
6001 TM.tmOverhang = 0;
6002 TM.tmDigitizedAspectX = 96; /* FIXME */
6003 TM.tmDigitizedAspectY = 96; /* FIXME */
6004 TM.tmFirstChar = 1;
6005 TM.tmLastChar = 255;
6006 TM.tmDefaultChar = 32;
6007 TM.tmBreakChar = 32;
6008 TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
6009 TM.tmUnderlined = font->underline;
6010 TM.tmStruckOut = font->strikeout;
6011 /* NB inverted meaning of TMPF_FIXED_PITCH */
6012 TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
6013 TM.tmCharSet = font->charset;
6014 }
6015 #undef TM
6016
6017 return TRUE;
6018 }
6019
6020
6021 static void scale_font_metrics(const GdiFont *font, LPTEXTMETRICW ptm)
6022 {
6023 double scale_x, scale_y;
6024
6025 if (font->aveWidth)
6026 {
6027 scale_x = (double)font->aveWidth;
6028 scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
6029 }
6030 else
6031 scale_x = font->scale_y;
6032
6033 scale_x *= fabs(font->font_desc.matrix.eM11);
6034 scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
6035
6036 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
6037 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
6038
6039 SCALE_Y(ptm->tmHeight);
6040 SCALE_Y(ptm->tmAscent);
6041 SCALE_Y(ptm->tmDescent);
6042 SCALE_Y(ptm->tmInternalLeading);
6043 SCALE_Y(ptm->tmExternalLeading);
6044 SCALE_Y(ptm->tmOverhang);
6045
6046 SCALE_X(ptm->tmAveCharWidth);
6047 SCALE_X(ptm->tmMaxCharWidth);
6048
6049 #undef SCALE_X
6050 #undef SCALE_Y
6051 }
6052
6053 static void scale_outline_font_metrics(const GdiFont *font, OUTLINETEXTMETRICW *potm)
6054 {
6055 double scale_x, scale_y;
6056
6057 if (font->aveWidth)
6058 {
6059 scale_x = (double)font->aveWidth;
6060 scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
6061 }
6062 else
6063 scale_x = font->scale_y;
6064
6065 scale_x *= fabs(font->font_desc.matrix.eM11);
6066 scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
6067
6068 scale_font_metrics(font, &potm->otmTextMetrics);
6069
6070 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
6071 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
6072
6073 SCALE_Y(potm->otmAscent);
6074 SCALE_Y(potm->otmDescent);
6075 SCALE_Y(potm->otmLineGap);
6076 SCALE_Y(potm->otmsCapEmHeight);
6077 SCALE_Y(potm->otmsXHeight);
6078 SCALE_Y(potm->otmrcFontBox.top);
6079 SCALE_Y(potm->otmrcFontBox.bottom);
6080 SCALE_X(potm->otmrcFontBox.left);
6081 SCALE_X(potm->otmrcFontBox.right);
6082 SCALE_Y(potm->otmMacAscent);
6083 SCALE_Y(potm->otmMacDescent);
6084 SCALE_Y(potm->otmMacLineGap);
6085 SCALE_X(potm->otmptSubscriptSize.x);
6086 SCALE_Y(potm->otmptSubscriptSize.y);
6087 SCALE_X(potm->otmptSubscriptOffset.x);
6088 SCALE_Y(potm->otmptSubscriptOffset.y);
6089 SCALE_X(potm->otmptSuperscriptSize.x);
6090 SCALE_Y(potm->otmptSuperscriptSize.y);
6091 SCALE_X(potm->otmptSuperscriptOffset.x);
6092 SCALE_Y(potm->otmptSuperscriptOffset.y);
6093 SCALE_Y(potm->otmsStrikeoutSize);
6094 SCALE_Y(potm->otmsStrikeoutPosition);
6095 SCALE_Y(potm->otmsUnderscoreSize);
6096 SCALE_Y(potm->otmsUnderscorePosition);
6097
6098 #undef SCALE_X
6099 #undef SCALE_Y
6100 }
6101
6102 static BOOL get_text_metrics(GdiFont *font, LPTEXTMETRICW ptm)
6103 {
6104 if(!font->potm)
6105 {
6106 if (!get_outline_text_metrics(font) && !get_bitmap_text_metrics(font)) return FALSE;
6107
6108 /* Make sure that the font has sane width/height ratio */
6109 if (font->aveWidth)
6110 {
6111 if ((font->aveWidth + font->potm->otmTextMetrics.tmHeight - 1) / font->potm->otmTextMetrics.tmHeight > 100)
6112 {
6113 WARN("Ignoring too large font->aveWidth %d\n", font->aveWidth);
6114 font->aveWidth = 0;
6115 }
6116 }
6117 }
6118 *ptm = font->potm->otmTextMetrics;
6119 scale_font_metrics(font, ptm);
6120 return TRUE;
6121 }
6122
6123 static BOOL face_has_symbol_charmap(FT_Face ft_face)
6124 {
6125 int i;
6126
6127 for(i = 0; i < ft_face->num_charmaps; i++)
6128 {
6129 if(ft_face->charmaps[i]->encoding == FT_ENCODING_MS_SYMBOL)
6130 return TRUE;
6131 }
6132 return FALSE;
6133 }
6134
6135 static BOOL get_outline_text_metrics(GdiFont *font)
6136 {
6137 BOOL ret = FALSE;
6138 FT_Face ft_face = font->ft_face;
6139 UINT needed, lenfam, lensty;
6140 TT_OS2 *pOS2;
6141 TT_HoriHeader *pHori;
6142 TT_Postscript *pPost;
6143 FT_Fixed x_scale, y_scale;
6144 WCHAR *family_nameW, *style_nameW;
6145 static const WCHAR spaceW[] = {' ', '\0'};
6146 char *cp;
6147 INT ascent, descent;
6148
6149 TRACE("font=%p\n", font);
6150
6151 if(!FT_IS_SCALABLE(ft_face))
6152 return FALSE;
6153
6154 needed = sizeof(*font->potm);
6155
6156 lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
6157 family_nameW = strdupW(font->name);
6158
6159 lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
6160 * sizeof(WCHAR);
6161 style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
6162 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
6163 style_nameW, lensty/sizeof(WCHAR));
6164
6165 /* These names should be read from the TT name table */
6166
6167 /* length of otmpFamilyName */
6168 needed += lenfam;
6169
6170 /* length of otmpFaceName */
6171 if ((ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) == 0) {
6172 needed += lenfam; /* just the family name */
6173 } else {
6174 needed += lenfam + lensty; /* family + " " + style */
6175 }
6176
6177 /* length of otmpStyleName */
6178 needed += lensty;
6179
6180 /* length of otmpFullName */
6181 needed += lenfam + lensty;
6182
6183
6184 x_scale = ft_face->size->metrics.x_scale;
6185 y_scale = ft_face->size->metrics.y_scale;
6186
6187 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
6188 if(!pOS2) {
6189 FIXME("Can't find OS/2 table - not TT font?\n");
6190 goto end;
6191 }
6192
6193 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
6194 if(!pHori) {
6195 FIXME("Can't find HHEA table - not TT font?\n");
6196 goto end;
6197 }
6198
6199 pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
6200
6201 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",
6202 pOS2->usWinAscent, pOS2->usWinDescent,
6203 pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
6204 ft_face->ascender, ft_face->descender, ft_face->height,
6205 pHori->Ascender, pHori->Descender, pHori->Line_Gap,
6206 ft_face->bbox.yMax, ft_face->bbox.yMin);
6207
6208 font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
6209 font->potm->otmSize = needed;
6210
6211 #define TM font->potm->otmTextMetrics
6212
6213 if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
6214 ascent = pHori->Ascender;
6215 descent = -pHori->Descender;
6216 } else {
6217 ascent = pOS2->usWinAscent;
6218 descent = pOS2->usWinDescent;
6219 }
6220
6221 if(font->yMax) {
6222 TM.tmAscent = font->yMax;
6223 TM.tmDescent = -font->yMin;
6224 TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
6225 } else {
6226 TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
6227 TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
6228 TM.tmInternalLeading = (pFT_MulFix(ascent + descent
6229 - ft_face->units_per_EM, y_scale) + 32) >> 6;
6230 }
6231
6232 TM.tmHeight = TM.tmAscent + TM.tmDescent;
6233
6234 /* MSDN says:
6235 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
6236 */
6237 TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
6238 ((ascent + descent) -
6239 (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
6240
6241 TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
6242 if (TM.tmAveCharWidth == 0) {
6243 TM.tmAveCharWidth = 1;
6244 }
6245 TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
6246 TM.tmWeight = FW_REGULAR;
6247 if (font->fake_bold)
6248 TM.tmWeight = FW_BOLD;
6249 else
6250 {
6251 if (ft_face->style_flags & FT_STYLE_FLAG_BOLD)
6252 {
6253 if (pOS2->usWeightClass > FW_MEDIUM)
6254 TM.tmWeight = pOS2->usWeightClass;
6255 }
6256 else if (pOS2->usWeightClass <= FW_MEDIUM)
6257 TM.tmWeight = pOS2->usWeightClass;
6258 }
6259 TM.tmOverhang = 0;
6260 TM.tmDigitizedAspectX = 300;
6261 TM.tmDigitizedAspectY = 300;
6262 /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
6263 * symbol range to 0 - f0ff
6264 */
6265
6266 if (face_has_symbol_charmap(ft_face) || (pOS2->usFirstCharIndex >= 0xf000 && pOS2->usFirstCharIndex < 0xf100))
6267 {
6268 TM.tmFirstChar = 0;
6269 switch(GetACP())
6270 {
6271 case 1257: /* Baltic */
6272 TM.tmLastChar = 0xf8fd;
6273 break;
6274 default:
6275 TM.tmLastChar = 0xf0ff;
6276 }
6277 TM.tmBreakChar = 0x20;
6278 TM.tmDefaultChar = 0x1f;
6279 }
6280 else
6281 {
6282 TM.tmFirstChar = pOS2->usFirstCharIndex; /* Should be the first char in the cmap */
6283 TM.tmLastChar = pOS2->usLastCharIndex; /* Should be min(cmap_last, os2_last) */
6284
6285 if(pOS2->usFirstCharIndex <= 1)
6286 TM.tmBreakChar = pOS2->usFirstCharIndex + 2;
6287 else if (pOS2->usFirstCharIndex > 0xff)
6288 TM.tmBreakChar = 0x20;
6289 else
6290 TM.tmBreakChar = pOS2->usFirstCharIndex;
6291 TM.tmDefaultChar = TM.tmBreakChar - 1;
6292 }
6293 TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
6294 TM.tmUnderlined = font->underline;
6295 TM.tmStruckOut = font->strikeout;
6296
6297 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
6298 if(!FT_IS_FIXED_WIDTH(ft_face) &&
6299 (pOS2->version == 0xFFFFU ||
6300 pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
6301 TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
6302 else
6303 TM.tmPitchAndFamily = 0;
6304
6305 switch(pOS2->panose[PAN_FAMILYTYPE_INDEX])
6306 {
6307 case PAN_FAMILY_SCRIPT:
6308 TM.tmPitchAndFamily |= FF_SCRIPT;
6309 break;
6310
6311 case PAN_FAMILY_DECORATIVE:
6312 TM.tmPitchAndFamily |= FF_DECORATIVE;
6313 break;
6314
6315 case PAN_ANY:
6316 case PAN_NO_FIT:
6317 case PAN_FAMILY_TEXT_DISPLAY:
6318 case PAN_FAMILY_PICTORIAL: /* symbol fonts get treated as if they were text */
6319 /* which is clearly not what the panose spec says. */
6320 default:
6321 if(TM.tmPitchAndFamily == 0 || /* fixed */
6322 pOS2->panose[PAN_PROPORTION_INDEX] == PAN_PROP_MONOSPACED)
6323 TM.tmPitchAndFamily = FF_MODERN;
6324 else
6325 {
6326 switch(pOS2->panose[PAN_SERIFSTYLE_INDEX])
6327 {
6328 case PAN_ANY:
6329 case PAN_NO_FIT:
6330 default:
6331 TM.tmPitchAndFamily |= FF_DONTCARE;
6332 break;
6333
6334 case PAN_SERIF_COVE:
6335 case PAN_SERIF_OBTUSE_COVE:
6336 case PAN_SERIF_SQUARE_COVE:
6337 case PAN_SERIF_OBTUSE_SQUARE_COVE:
6338 case PAN_SERIF_SQUARE:
6339 case PAN_SERIF_THIN:
6340 case PAN_SERIF_BONE:
6341 case PAN_SERIF_EXAGGERATED:
6342 case PAN_SERIF_TRIANGLE:
6343 TM.tmPitchAndFamily |= FF_ROMAN;
6344 break;
6345
6346 case PAN_SERIF_NORMAL_SANS:
6347 case PAN_SERIF_OBTUSE_SANS:
6348 case PAN_SERIF_PERP_SANS:
6349 case PAN_SERIF_FLARED:
6350 case PAN_SERIF_ROUNDED:
6351 TM.tmPitchAndFamily |= FF_SWISS;
6352 break;
6353 }
6354 }
6355 break;
6356 }
6357
6358 if(FT_IS_SCALABLE(ft_face))
6359 TM.tmPitchAndFamily |= TMPF_VECTOR;
6360
6361 if(FT_IS_SFNT(ft_face))
6362 {
6363 if (font->ntmFlags & NTM_PS_OPENTYPE)
6364 TM.tmPitchAndFamily |= TMPF_DEVICE;
6365 else
6366 TM.tmPitchAndFamily |= TMPF_TRUETYPE;
6367 }
6368
6369 TM.tmCharSet = font->charset;
6370
6371 font->potm->otmFiller = 0;
6372 memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
6373 font->potm->otmfsSelection = pOS2->fsSelection;
6374 font->potm->otmfsType = pOS2->fsType;
6375 font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
6376 font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
6377 font->potm->otmItalicAngle = 0; /* POST table */
6378 font->potm->otmEMSquare = ft_face->units_per_EM;
6379 font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
6380 font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
6381 font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
6382 font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
6383 font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
6384 font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
6385 font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
6386 font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
6387 font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
6388 font->potm->otmMacAscent = TM.tmAscent;
6389 font->potm->otmMacDescent = -TM.tmDescent;
6390 font->potm->otmMacLineGap = font->potm->otmLineGap;
6391 font->potm->otmusMinimumPPEM = 0; /* TT Header */
6392 font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
6393 font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
6394 font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
6395 font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
6396 font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
6397 font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
6398 font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
6399 font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
6400 font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
6401 font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
6402 if(!pPost) {
6403 font->potm->otmsUnderscoreSize = 0;
6404 font->potm->otmsUnderscorePosition = 0;
6405 } else {
6406 font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
6407 font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
6408 }
6409 #undef TM
6410
6411 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
6412 cp = (char*)font->potm + sizeof(*font->potm);
6413 font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
6414 strcpyW((WCHAR*)cp, family_nameW);
6415 cp += lenfam;
6416 font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
6417 strcpyW((WCHAR*)cp, style_nameW);
6418 cp += lensty;
6419 font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
6420 strcpyW((WCHAR*)cp, family_nameW);
6421 if (ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) {
6422 strcatW((WCHAR*)cp, spaceW);
6423 strcatW((WCHAR*)cp, style_nameW);
6424 cp += lenfam + lensty;
6425 } else
6426 cp += lenfam;
6427 font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
6428 strcpyW((WCHAR*)cp, family_nameW);
6429 strcatW((WCHAR*)cp, spaceW);
6430 strcatW((WCHAR*)cp, style_nameW);
6431 ret = TRUE;
6432
6433 end:
6434 HeapFree(GetProcessHeap(), 0, style_nameW);
6435 HeapFree(GetProcessHeap(), 0, family_nameW);
6436 return ret;
6437 }
6438
6439 /*************************************************************
6440 * freetype_GetGlyphOutline
6441 */
6442 static DWORD freetype_GetGlyphOutline( PHYSDEV dev, UINT glyph, UINT format,
6443 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf, const MAT2 *lpmat )
6444 {
6445 struct freetype_physdev *physdev = get_freetype_dev( dev );
6446 DWORD ret;
6447
6448 if (!physdev->font)
6449 {
6450 dev = GET_NEXT_PHYSDEV( dev, pGetGlyphOutline );
6451 return dev->funcs->pGetGlyphOutline( dev, glyph, format, lpgm, buflen, buf, lpmat );
6452 }
6453
6454 GDI_CheckNotLock();
6455 EnterCriticalSection( &freetype_cs );
6456 ret = get_glyph_outline( physdev->font, glyph, format, lpgm, buflen, buf, lpmat );
6457 LeaveCriticalSection( &freetype_cs );
6458 return ret;
6459 }
6460
6461 /*************************************************************
6462 * freetype_GetTextMetrics
6463 */
6464 static BOOL freetype_GetTextMetrics( PHYSDEV dev, TEXTMETRICW *metrics )
6465 {
6466 struct freetype_physdev *physdev = get_freetype_dev( dev );
6467 BOOL ret;
6468
6469 if (!physdev->font)
6470 {
6471 dev = GET_NEXT_PHYSDEV( dev, pGetTextMetrics );
6472 return dev->funcs->pGetTextMetrics( dev, metrics );
6473 }
6474
6475 GDI_CheckNotLock();
6476 EnterCriticalSection( &freetype_cs );
6477 ret = get_text_metrics( physdev->font, metrics );
6478 LeaveCriticalSection( &freetype_cs );
6479 return ret;
6480 }
6481
6482 /*************************************************************
6483 * freetype_GetOutlineTextMetrics
6484 */
6485 static UINT freetype_GetOutlineTextMetrics( PHYSDEV dev, UINT cbSize, OUTLINETEXTMETRICW *potm )
6486 {
6487 struct freetype_physdev *physdev = get_freetype_dev( dev );
6488 UINT ret = 0;
6489
6490 if (!physdev->font)
6491 {
6492 dev = GET_NEXT_PHYSDEV( dev, pGetOutlineTextMetrics );
6493 return dev->funcs->pGetOutlineTextMetrics( dev, cbSize, potm );
6494 }
6495
6496 TRACE("font=%p\n", physdev->font);
6497
6498 if (!FT_IS_SCALABLE( physdev->font->ft_face )) return 0;
6499
6500 GDI_CheckNotLock();
6501 EnterCriticalSection( &freetype_cs );
6502
6503 if (physdev->font->potm || get_outline_text_metrics( physdev->font ))
6504 {
6505 if(cbSize >= physdev->font->potm->otmSize)
6506 {
6507 memcpy(potm, physdev->font->potm, physdev->font->potm->otmSize);
6508 scale_outline_font_metrics(physdev->font, potm);
6509 }
6510 ret = physdev->font->potm->otmSize;
6511 }
6512 LeaveCriticalSection( &freetype_cs );
6513 return ret;
6514 }
6515
6516 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
6517 {
6518 HFONTLIST *hfontlist;
6519 child->font = alloc_font();
6520 child->font->ft_face = OpenFontFace(child->font, child->face, 0, -font->ppem);
6521 if(!child->font->ft_face)
6522 {
6523 free_font(child->font);
6524 child->font = NULL;
6525 return FALSE;
6526 }
6527
6528 child->font->font_desc = font->font_desc;
6529 child->font->ntmFlags = child->face->ntmFlags;
6530 child->font->orientation = font->orientation;
6531 child->font->scale_y = font->scale_y;
6532 hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
6533 hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
6534 child->font->name = strdupW(child->face->family->FamilyName);
6535 list_add_head(&child->font->hfontlist, &hfontlist->entry);
6536 child->font->base_font = font;
6537 list_add_head(&child_font_list, &child->font->entry);
6538 TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
6539 return TRUE;
6540 }
6541
6542 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
6543 {
6544 FT_UInt g;
6545 CHILD_FONT *child_font;
6546
6547 if(font->base_font)
6548 font = font->base_font;
6549
6550 *linked_font = font;
6551
6552 if((*glyph = get_glyph_index(font, c)))
6553 {
6554 *glyph = get_GSUB_vert_glyph(font, *glyph);
6555 return TRUE;
6556 }
6557
6558 LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
6559 {
6560 if(!child_font->font)
6561 if(!load_child_font(font, child_font))
6562 continue;
6563
6564 if(!child_font->font->ft_face)
6565 continue;
6566 g = get_glyph_index(child_font->font, c);
6567 g = get_GSUB_vert_glyph(child_font->font, g);
6568 if(g)
6569 {
6570 *glyph = g;
6571 *linked_font = child_font->font;
6572 return TRUE;
6573 }
6574 }
6575 return FALSE;
6576 }
6577
6578 /*************************************************************
6579 * freetype_GetCharWidth
6580 */
6581 static BOOL freetype_GetCharWidth( PHYSDEV dev, UINT firstChar, UINT lastChar, LPINT buffer )
6582 {
6583 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6584 UINT c;
6585 GLYPHMETRICS gm;
6586 FT_UInt glyph_index;
6587 GdiFont *linked_font;
6588 struct freetype_physdev *physdev = get_freetype_dev( dev );
6589
6590 if (!physdev->font)
6591 {
6592 dev = GET_NEXT_PHYSDEV( dev, pGetCharWidth );
6593 return dev->funcs->pGetCharWidth( dev, firstChar, lastChar, buffer );
6594 }
6595
6596 TRACE("%p, %d, %d, %p\n", physdev->font, firstChar, lastChar, buffer);
6597
6598 GDI_CheckNotLock();
6599 EnterCriticalSection( &freetype_cs );
6600 for(c = firstChar; c <= lastChar; c++) {
6601 get_glyph_index_linked(physdev->font, c, &linked_font, &glyph_index);
6602 get_glyph_outline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
6603 &gm, 0, NULL, &identity);
6604 buffer[c - firstChar] = FONT_GM(linked_font,glyph_index)->adv;
6605 }
6606 LeaveCriticalSection( &freetype_cs );
6607 return TRUE;
6608 }
6609
6610 /*************************************************************
6611 * freetype_GetCharABCWidths
6612 */
6613 static BOOL freetype_GetCharABCWidths( PHYSDEV dev, UINT firstChar, UINT lastChar, LPABC buffer )
6614 {
6615 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6616 UINT c;
6617 GLYPHMETRICS gm;
6618 FT_UInt glyph_index;
6619 GdiFont *linked_font;
6620 struct freetype_physdev *physdev = get_freetype_dev( dev );
6621
6622 if (!physdev->font)
6623 {
6624 dev = GET_NEXT_PHYSDEV( dev, pGetCharABCWidths );
6625 return dev->funcs->pGetCharABCWidths( dev, firstChar, lastChar, buffer );
6626 }
6627
6628 TRACE("%p, %d, %d, %p\n", physdev->font, firstChar, lastChar, buffer);
6629
6630 GDI_CheckNotLock();
6631 EnterCriticalSection( &freetype_cs );
6632
6633 for(c = firstChar; c <= lastChar; c++) {
6634 get_glyph_index_linked(physdev->font, c, &linked_font, &glyph_index);
6635 get_glyph_outline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
6636 &gm, 0, NULL, &identity);
6637 buffer[c - firstChar].abcA = FONT_GM(linked_font,glyph_index)->lsb;
6638 buffer[c - firstChar].abcB = FONT_GM(linked_font,glyph_index)->bbx;
6639 buffer[c - firstChar].abcC = FONT_GM(linked_font,glyph_index)->adv - FONT_GM(linked_font,glyph_index)->lsb -
6640 FONT_GM(linked_font,glyph_index)->bbx;
6641 }
6642 LeaveCriticalSection( &freetype_cs );
6643 return TRUE;
6644 }
6645
6646 /*************************************************************
6647 * freetype_GetCharABCWidthsI
6648 */
6649 static BOOL freetype_GetCharABCWidthsI( PHYSDEV dev, UINT firstChar, UINT count, LPWORD pgi, LPABC buffer )
6650 {
6651 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6652 UINT c;
6653 GLYPHMETRICS gm;
6654 FT_UInt glyph_index;
6655 GdiFont *linked_font;
6656 struct freetype_physdev *physdev = get_freetype_dev( dev );
6657
6658 if (!physdev->font)
6659 {
6660 dev = GET_NEXT_PHYSDEV( dev, pGetCharABCWidthsI );
6661 return dev->funcs->pGetCharABCWidthsI( dev, firstChar, count, pgi, buffer );
6662 }
6663
6664 if(!FT_HAS_HORIZONTAL(physdev->font->ft_face))
6665 return FALSE;
6666
6667 GDI_CheckNotLock();
6668 EnterCriticalSection( &freetype_cs );
6669
6670 get_glyph_index_linked(physdev->font, 'a', &linked_font, &glyph_index);
6671 if (!pgi)
6672 for(c = firstChar; c < firstChar+count; c++) {
6673 get_glyph_outline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
6674 &gm, 0, NULL, &identity);
6675 buffer[c - firstChar].abcA = FONT_GM(linked_font,c)->lsb;
6676 buffer[c - firstChar].abcB = FONT_GM(linked_font,c)->bbx;
6677 buffer[c - firstChar].abcC = FONT_GM(linked_font,c)->adv - FONT_GM(linked_font,c)->lsb
6678 - FONT_GM(linked_font,c)->bbx;
6679 }
6680 else
6681 for(c = 0; c < count; c++) {
6682 get_glyph_outline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
6683 &gm, 0, NULL, &identity);
6684 buffer[c].abcA = FONT_GM(linked_font,pgi[c])->lsb;
6685 buffer[c].abcB = FONT_GM(linked_font,pgi[c])->bbx;
6686 buffer[c].abcC = FONT_GM(linked_font,pgi[c])->adv
6687 - FONT_GM(linked_font,pgi[c])->lsb - FONT_GM(linked_font,pgi[c])->bbx;
6688 }
6689
6690 LeaveCriticalSection( &freetype_cs );
6691 return TRUE;
6692 }
6693
6694 /*************************************************************
6695 * freetype_GetTextExtentExPoint
6696 */
6697 static BOOL freetype_GetTextExtentExPoint( PHYSDEV dev, LPCWSTR wstr, INT count,
6698 INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
6699 {
6700 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6701 INT idx;
6702 INT nfit = 0, ext;
6703 GLYPHMETRICS gm;
6704 TEXTMETRICW tm;
6705 FT_UInt glyph_index;
6706 GdiFont *linked_font;
6707 struct freetype_physdev *physdev = get_freetype_dev( dev );
6708
6709 if (!physdev->font)
6710 {
6711 dev = GET_NEXT_PHYSDEV( dev, pGetTextExtentExPoint );
6712 return dev->funcs->pGetTextExtentExPoint( dev, wstr, count, max_ext, pnfit, dxs, size );
6713 }
6714
6715 TRACE("%p, %s, %d, %d, %p\n", physdev->font, debugstr_wn(wstr, count), count, max_ext, size);
6716
6717 GDI_CheckNotLock();
6718 EnterCriticalSection( &freetype_cs );
6719
6720 size->cx = 0;
6721 get_text_metrics( physdev->font, &tm );
6722 size->cy = tm.tmHeight;
6723
6724 for(idx = 0; idx < count; idx++) {
6725 get_glyph_index_linked( physdev->font, wstr[idx], &linked_font, &glyph_index );
6726 get_glyph_outline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
6727 &gm, 0, NULL, &identity);
6728 size->cx += FONT_GM(linked_font,glyph_index)->adv;
6729 ext = size->cx;
6730 if (! pnfit || ext <= max_ext) {
6731 ++nfit;
6732 if (dxs)
6733 dxs[idx] = ext;
6734 }
6735 }
6736
6737 if (pnfit)
6738 *pnfit = nfit;
6739
6740 LeaveCriticalSection( &freetype_cs );
6741 TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
6742 return TRUE;
6743 }
6744
6745 /*************************************************************
6746 * freetype_GetTextExtentExPointI
6747 */
6748 static BOOL freetype_GetTextExtentExPointI( PHYSDEV dev, const WORD *indices, INT count,
6749 INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size )
6750 {
6751 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6752 INT idx;
6753 INT nfit = 0, ext;
6754 GLYPHMETRICS gm;
6755 TEXTMETRICW tm;
6756 struct freetype_physdev *physdev = get_freetype_dev( dev );
6757
6758 if (!physdev->font)
6759 {
6760 dev = GET_NEXT_PHYSDEV( dev, pGetTextExtentExPointI );
6761 return dev->funcs->pGetTextExtentExPointI( dev, indices, count, max_ext, pnfit, dxs, size );
6762 }
6763
6764 TRACE("%p, %p, %d, %d, %p\n", physdev->font, indices, count, max_ext, size);
6765
6766 GDI_CheckNotLock();
6767 EnterCriticalSection( &freetype_cs );
6768
6769 size->cx = 0;
6770 get_text_metrics(physdev->font, &tm);
6771 size->cy = tm.tmHeight;
6772
6773 for(idx = 0; idx < count; idx++) {
6774 get_glyph_outline(physdev->font, indices[idx], GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &identity);
6775 size->cx += FONT_GM(physdev->font,indices[idx])->adv;
6776 ext = size->cx;
6777 if (! pnfit || ext <= max_ext) {
6778 ++nfit;
6779 if (dxs)
6780 dxs[idx] = ext;
6781 }
6782 }
6783
6784 if (pnfit)
6785 *pnfit = nfit;
6786
6787 LeaveCriticalSection( &freetype_cs );
6788 TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
6789 return TRUE;
6790 }
6791
6792 /*************************************************************
6793 * freetype_GetFontData
6794 */
6795 static DWORD freetype_GetFontData( PHYSDEV dev, DWORD table, DWORD offset, LPVOID buf, DWORD cbData )
6796 {
6797 struct freetype_physdev *physdev = get_freetype_dev( dev );
6798
6799 if (!physdev->font)
6800 {
6801 dev = GET_NEXT_PHYSDEV( dev, pGetFontData );
6802 return dev->funcs->pGetFontData( dev, table, offset, buf, cbData );
6803 }
6804
6805 TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
6806 physdev->font, LOBYTE(LOWORD(table)), HIBYTE(LOWORD(table)),
6807 LOBYTE(HIWORD(table)), HIBYTE(HIWORD(table)), offset, buf, cbData);
6808
6809 return get_font_data( physdev->font, table, offset, buf, cbData );
6810 }
6811
6812 /*************************************************************
6813 * freetype_GetTextFace
6814 */
6815 static INT freetype_GetTextFace( PHYSDEV dev, INT count, LPWSTR str )
6816 {
6817 INT n;
6818 struct freetype_physdev *physdev = get_freetype_dev( dev );
6819
6820 if (!physdev->font)
6821 {
6822 dev = GET_NEXT_PHYSDEV( dev, pGetTextFace );
6823 return dev->funcs->pGetTextFace( dev, count, str );
6824 }
6825
6826 n = strlenW(physdev->font->name) + 1;
6827 if (str)
6828 {
6829 lstrcpynW(str, physdev->font->name, count);
6830 n = min(count, n);
6831 }
6832 return n;
6833 }
6834
6835 /*************************************************************
6836 * freetype_GetTextCharsetInfo
6837 */
6838 static UINT freetype_GetTextCharsetInfo( PHYSDEV dev, LPFONTSIGNATURE fs, DWORD flags )
6839 {
6840 struct freetype_physdev *physdev = get_freetype_dev( dev );
6841
6842 if (!physdev->font)
6843 {
6844 dev = GET_NEXT_PHYSDEV( dev, pGetTextCharsetInfo );
6845 return dev->funcs->pGetTextCharsetInfo( dev, fs, flags );
6846 }
6847 if (fs) *fs = physdev->font->fs;
6848 return physdev->font->charset;
6849 }
6850
6851 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
6852 {
6853 GdiFont *font = dc->gdiFont, *linked_font;
6854 struct list *first_hfont;
6855 BOOL ret;
6856
6857 GDI_CheckNotLock();
6858 EnterCriticalSection( &freetype_cs );
6859 ret = get_glyph_index_linked(font, c, &linked_font, glyph);
6860 TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
6861 if(font == linked_font)
6862 *new_hfont = dc->hFont;
6863 else
6864 {
6865 first_hfont = list_head(&linked_font->hfontlist);
6866 *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
6867 }
6868 LeaveCriticalSection( &freetype_cs );
6869 return ret;
6870 }
6871
6872 /* Retrieve a list of supported Unicode ranges for a given font.
6873 * Can be called with NULL gs to calculate the buffer size. Returns
6874 * the number of ranges found.
6875 */
6876 static DWORD get_font_unicode_ranges(FT_Face face, GLYPHSET *gs)
6877 {
6878 DWORD num_ranges = 0;
6879
6880 if (face->charmap->encoding == FT_ENCODING_UNICODE)
6881 {
6882 FT_UInt glyph_code;
6883 FT_ULong char_code, char_code_prev;
6884
6885 glyph_code = 0;
6886 char_code_prev = char_code = pFT_Get_First_Char(face, &glyph_code);
6887
6888 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
6889 face->num_glyphs, glyph_code, char_code);
6890
6891 if (!glyph_code) return 0;
6892
6893 if (gs)
6894 {
6895 gs->ranges[0].wcLow = (USHORT)char_code;
6896 gs->ranges[0].cGlyphs = 0;
6897 gs->cGlyphsSupported = 0;
6898 }
6899
6900 num_ranges = 1;
6901 while (glyph_code)
6902 {
6903 if (char_code < char_code_prev)
6904 {
6905 ERR("expected increasing char code from FT_Get_Next_Char\n");
6906 return 0;
6907 }
6908 if (char_code - char_code_prev > 1)
6909 {
6910 num_ranges++;
6911 if (gs)
6912 {
6913 gs->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
6914 gs->ranges[num_ranges - 1].cGlyphs = 1;
6915 gs->cGlyphsSupported++;
6916 }
6917 }
6918 else if (gs)
6919 {
6920 gs->ranges[num_ranges - 1].cGlyphs++;
6921 gs->cGlyphsSupported++;
6922 }
6923 char_code_prev = char_code;
6924 char_code = pFT_Get_Next_Char(face, char_code, &glyph_code);
6925 }
6926 }
6927 else
6928 FIXME("encoding %u not supported\n", face->charmap->encoding);
6929
6930 return num_ranges;
6931 }
6932
6933 /*************************************************************
6934 * freetype_GetFontUnicodeRanges
6935 */
6936 static DWORD freetype_GetFontUnicodeRanges( PHYSDEV dev, LPGLYPHSET glyphset )
6937 {
6938 struct freetype_physdev *physdev = get_freetype_dev( dev );
6939 DWORD size, num_ranges;
6940
6941 if (!physdev->font)
6942 {
6943 dev = GET_NEXT_PHYSDEV( dev, pGetFontUnicodeRanges );
6944 return dev->funcs->pGetFontUnicodeRanges( dev, glyphset );
6945 }
6946
6947 num_ranges = get_font_unicode_ranges(physdev->font->ft_face, glyphset);
6948 size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
6949 if (glyphset)
6950 {
6951 glyphset->cbThis = size;
6952 glyphset->cRanges = num_ranges;
6953 glyphset->flAccel = 0;
6954 }
6955 return size;
6956 }
6957
6958 /*************************************************************
6959 * freetype_FontIsLinked
6960 */
6961 static BOOL freetype_FontIsLinked( PHYSDEV dev )
6962 {
6963 struct freetype_physdev *physdev = get_freetype_dev( dev );
6964 BOOL ret;
6965
6966 if (!physdev->font)
6967 {
6968 dev = GET_NEXT_PHYSDEV( dev, pFontIsLinked );
6969 return dev->funcs->pFontIsLinked( dev );
6970 }
6971
6972 GDI_CheckNotLock();
6973 EnterCriticalSection( &freetype_cs );
6974 ret = !list_empty(&physdev->font->child_fonts);
6975 LeaveCriticalSection( &freetype_cs );
6976 return ret;
6977 }
6978
6979 static BOOL is_hinting_enabled(void)
6980 {
6981 /* Use the >= 2.2.0 function if available */
6982 if(pFT_Get_TrueType_Engine_Type)
6983 {
6984 FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
6985 return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
6986 }
6987 #ifdef FT_DRIVER_HAS_HINTER
6988 else
6989 {
6990 FT_Module mod;
6991
6992 /* otherwise if we've been compiled with < 2.2.0 headers
6993 use the internal macro */
6994 mod = pFT_Get_Module(library, "truetype");
6995 if(mod && FT_DRIVER_HAS_HINTER(mod))
6996 return TRUE;
6997 }
6998 #endif
6999
7000 return FALSE;
7001 }
7002
7003 static BOOL is_subpixel_rendering_enabled( void )
7004 {
7005 #ifdef HAVE_FREETYPE_FTLCDFIL_H
7006 return pFT_Library_SetLcdFilter &&
7007 pFT_Library_SetLcdFilter( NULL, 0 ) != FT_Err_Unimplemented_Feature;
7008 #else
7009 return FALSE;
7010 #endif
7011 }
7012
7013 /*************************************************************************
7014 * GetRasterizerCaps (GDI32.@)
7015 */
7016 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
7017 {
7018 static int hinting = -1;
7019 static int subpixel = -1;
7020
7021 if(hinting == -1)
7022 {
7023 hinting = is_hinting_enabled();
7024 TRACE("hinting is %senabled\n", hinting ? "" : "NOT ");
7025 }
7026
7027 if ( subpixel == -1 )
7028 {
7029 subpixel = is_subpixel_rendering_enabled();
7030 TRACE("subpixel rendering is %senabled\n", subpixel ? "" : "NOT ");
7031 }
7032
7033 lprs->nSize = sizeof(RASTERIZER_STATUS);
7034 lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
7035 if ( subpixel )
7036 lprs->wFlags |= WINE_TT_SUBPIXEL_RENDERING_ENABLED;
7037 lprs->nLanguageID = 0;
7038 return TRUE;
7039 }
7040
7041 /*************************************************************
7042 * freetype_GdiRealizationInfo
7043 */
7044 static BOOL freetype_GdiRealizationInfo( PHYSDEV dev, void *ptr )
7045 {
7046 struct freetype_physdev *physdev = get_freetype_dev( dev );
7047 realization_info_t *info = ptr;
7048
7049 if (!physdev->font)
7050 {
7051 dev = GET_NEXT_PHYSDEV( dev, pGdiRealizationInfo );
7052 return dev->funcs->pGdiRealizationInfo( dev, ptr );
7053 }
7054
7055 FIXME("(%p, %p): stub!\n", physdev->font, info);
7056
7057 info->flags = 1;
7058 if(FT_IS_SCALABLE(physdev->font->ft_face))
7059 info->flags |= 2;
7060
7061 info->cache_num = physdev->font->cache_num;
7062 info->unknown2 = -1;
7063 return TRUE;
7064 }
7065
7066 /*************************************************************************
7067 * Kerning support for TrueType fonts
7068 */
7069 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
7070
7071 struct TT_kern_table
7072 {
7073 USHORT version;
7074 USHORT nTables;
7075 };
7076
7077 struct TT_kern_subtable
7078 {
7079 USHORT version;
7080 USHORT length;
7081 union
7082 {
7083 USHORT word;
7084 struct
7085 {
7086 USHORT horizontal : 1;
7087 USHORT minimum : 1;
7088 USHORT cross_stream: 1;
7089 USHORT override : 1;
7090 USHORT reserved1 : 4;
7091 USHORT format : 8;
7092 } bits;
7093 } coverage;
7094 };
7095
7096 struct TT_format0_kern_subtable
7097 {
7098 USHORT nPairs;
7099 USHORT searchRange;
7100 USHORT entrySelector;
7101 USHORT rangeShift;
7102 };
7103
7104 struct TT_kern_pair
7105 {
7106 USHORT left;
7107 USHORT right;
7108 short value;
7109 };
7110
7111 static DWORD parse_format0_kern_subtable(GdiFont *font,
7112 const struct TT_format0_kern_subtable *tt_f0_ks,
7113 const USHORT *glyph_to_char,
7114 KERNINGPAIR *kern_pair, DWORD cPairs)
7115 {
7116 USHORT i, nPairs;
7117 const struct TT_kern_pair *tt_kern_pair;
7118
7119 TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
7120
7121 nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
7122
7123 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
7124 nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
7125 GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
7126
7127 if (!kern_pair || !cPairs)
7128 return nPairs;
7129
7130 tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
7131
7132 nPairs = min(nPairs, cPairs);
7133
7134 for (i = 0; i < nPairs; i++)
7135 {
7136 kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
7137 kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
7138 /* this algorithm appears to better match what Windows does */
7139 kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
7140 if (kern_pair->iKernAmount < 0)
7141 {
7142 kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
7143 kern_pair->iKernAmount -= font->ppem;
7144 }
7145 else if (kern_pair->iKernAmount > 0)
7146 {
7147 kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
7148 kern_pair->iKernAmount += font->ppem;
7149 }
7150 kern_pair->iKernAmount /= font->ft_face->units_per_EM;
7151
7152 TRACE("left %u right %u value %d\n",
7153 kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
7154
7155 kern_pair++;
7156 }
7157 TRACE("copied %u entries\n", nPairs);
7158 return nPairs;
7159 }
7160
7161 /*************************************************************
7162 * freetype_GetKerningPairs
7163 */
7164 static DWORD freetype_GetKerningPairs( PHYSDEV dev, DWORD cPairs, KERNINGPAIR *kern_pair )
7165 {
7166 DWORD length;
7167 void *buf;
7168 const struct TT_kern_table *tt_kern_table;
7169 const struct TT_kern_subtable *tt_kern_subtable;
7170 USHORT i, nTables;
7171 USHORT *glyph_to_char;
7172 GdiFont *font;
7173 struct freetype_physdev *physdev = get_freetype_dev( dev );
7174
7175 if (!(font = physdev->font))
7176 {
7177 dev = GET_NEXT_PHYSDEV( dev, pGetKerningPairs );
7178 return dev->funcs->pGetKerningPairs( dev, cPairs, kern_pair );
7179 }
7180
7181 GDI_CheckNotLock();
7182 EnterCriticalSection( &freetype_cs );
7183 if (font->total_kern_pairs != (DWORD)-1)
7184 {
7185 if (cPairs && kern_pair)
7186 {
7187 cPairs = min(cPairs, font->total_kern_pairs);
7188 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
7189 }
7190 else cPairs = font->total_kern_pairs;
7191
7192 LeaveCriticalSection( &freetype_cs );
7193 return cPairs;
7194 }
7195
7196 font->total_kern_pairs = 0;
7197
7198 length = get_font_data(font, MS_KERN_TAG, 0, NULL, 0);
7199
7200 if (length == GDI_ERROR)
7201 {
7202 TRACE("no kerning data in the font\n");
7203 LeaveCriticalSection( &freetype_cs );
7204 return 0;
7205 }
7206
7207 buf = HeapAlloc(GetProcessHeap(), 0, length);
7208 if (!buf)
7209 {
7210 WARN("Out of memory\n");
7211 LeaveCriticalSection( &freetype_cs );
7212 return 0;
7213 }
7214
7215 get_font_data(font, MS_KERN_TAG, 0, buf, length);
7216
7217 /* build a glyph index to char code map */
7218 glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
7219 if (!glyph_to_char)
7220 {
7221 WARN("Out of memory allocating a glyph index to char code map\n");
7222 HeapFree(GetProcessHeap(), 0, buf);
7223 LeaveCriticalSection( &freetype_cs );
7224 return 0;
7225 }
7226
7227 if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE)
7228 {
7229 FT_UInt glyph_code;
7230 FT_ULong char_code;
7231
7232 glyph_code = 0;
7233 char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
7234
7235 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
7236 font->ft_face->num_glyphs, glyph_code, char_code);
7237
7238 while (glyph_code)
7239 {
7240 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
7241
7242 /* FIXME: This doesn't match what Windows does: it does some fancy
7243 * things with duplicate glyph index to char code mappings, while
7244 * we just avoid overriding existing entries.
7245 */
7246 if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
7247 glyph_to_char[glyph_code] = (USHORT)char_code;
7248
7249 char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
7250 }
7251 }
7252 else
7253 {
7254 ULONG n;
7255
7256 FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
7257 for (n = 0; n <= 65535; n++)
7258 glyph_to_char[n] = (USHORT)n;
7259 }
7260
7261 tt_kern_table = buf;
7262 nTables = GET_BE_WORD(tt_kern_table->nTables);
7263 TRACE("version %u, nTables %u\n",
7264 GET_BE_WORD(tt_kern_table->version), nTables);
7265
7266 tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
7267
7268 for (i = 0; i < nTables; i++)
7269 {
7270 struct TT_kern_subtable tt_kern_subtable_copy;
7271
7272 tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
7273 tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
7274 tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
7275
7276 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
7277 tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
7278 tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
7279
7280 /* According to the TrueType specification this is the only format
7281 * that will be properly interpreted by Windows and OS/2
7282 */
7283 if (tt_kern_subtable_copy.coverage.bits.format == 0)
7284 {
7285 DWORD new_chunk, old_total = font->total_kern_pairs;
7286
7287 new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
7288 glyph_to_char, NULL, 0);
7289 font->total_kern_pairs += new_chunk;
7290
7291 if (!font->kern_pairs)
7292 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
7293 font->total_kern_pairs * sizeof(*font->kern_pairs));
7294 else
7295 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
7296 font->total_kern_pairs * sizeof(*font->kern_pairs));
7297
7298 parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
7299 glyph_to_char, font->kern_pairs + old_total, new_chunk);
7300 }
7301 else
7302 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
7303
7304 tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
7305 }
7306
7307 HeapFree(GetProcessHeap(), 0, glyph_to_char);
7308 HeapFree(GetProcessHeap(), 0, buf);
7309
7310 if (cPairs && kern_pair)
7311 {
7312 cPairs = min(cPairs, font->total_kern_pairs);
7313 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
7314 }
7315 else cPairs = font->total_kern_pairs;
7316
7317 LeaveCriticalSection( &freetype_cs );
7318 return cPairs;
7319 }
7320
7321 static const struct gdi_dc_funcs freetype_funcs =
7322 {
7323 NULL, /* pAbortDoc */
7324 NULL, /* pAbortPath */
7325 NULL, /* pAlphaBlend */
7326 NULL, /* pAngleArc */
7327 NULL, /* pArc */
7328 NULL, /* pArcTo */
7329 NULL, /* pBeginPath */
7330 NULL, /* pBlendImage */
7331 NULL, /* pChoosePixelFormat */
7332 NULL, /* pChord */
7333 NULL, /* pCloseFigure */
7334 NULL, /* pCopyBitmap */
7335 NULL, /* pCreateBitmap */
7336 NULL, /* pCreateCompatibleDC */
7337 freetype_CreateDC, /* pCreateDC */
7338 NULL, /* pDeleteBitmap */
7339 freetype_DeleteDC, /* pDeleteDC */
7340 NULL, /* pDeleteObject */
7341 NULL, /* pDescribePixelFormat */
7342 NULL, /* pDeviceCapabilities */
7343 NULL, /* pEllipse */
7344 NULL, /* pEndDoc */
7345 NULL, /* pEndPage */
7346 NULL, /* pEndPath */
7347 freetype_EnumFonts, /* pEnumFonts */
7348 NULL, /* pEnumICMProfiles */
7349 NULL, /* pExcludeClipRect */
7350 NULL, /* pExtDeviceMode */
7351 NULL, /* pExtEscape */
7352 NULL, /* pExtFloodFill */
7353 NULL, /* pExtSelectClipRgn */
7354 NULL, /* pExtTextOut */
7355 NULL, /* pFillPath */
7356 NULL, /* pFillRgn */
7357 NULL, /* pFlattenPath */
7358 freetype_FontIsLinked, /* pFontIsLinked */
7359 NULL, /* pFrameRgn */
7360 NULL, /* pGdiComment */
7361 freetype_GdiRealizationInfo, /* pGdiRealizationInfo */
7362 freetype_GetCharABCWidths, /* pGetCharABCWidths */
7363 freetype_GetCharABCWidthsI, /* pGetCharABCWidthsI */
7364 freetype_GetCharWidth, /* pGetCharWidth */
7365 NULL, /* pGetDeviceCaps */
7366 NULL, /* pGetDeviceGammaRamp */
7367 freetype_GetFontData, /* pGetFontData */
7368 freetype_GetFontUnicodeRanges, /* pGetFontUnicodeRanges */
7369 freetype_GetGlyphIndices, /* pGetGlyphIndices */
7370 freetype_GetGlyphOutline, /* pGetGlyphOutline */
7371 NULL, /* pGetICMProfile */
7372 NULL, /* pGetImage */
7373 freetype_GetKerningPairs, /* pGetKerningPairs */
7374 NULL, /* pGetNearestColor */
7375 freetype_GetOutlineTextMetrics, /* pGetOutlineTextMetrics */
7376 NULL, /* pGetPixel */
7377 NULL, /* pGetPixelFormat */
7378 NULL, /* pGetSystemPaletteEntries */
7379 freetype_GetTextCharsetInfo, /* pGetTextCharsetInfo */
7380 freetype_GetTextExtentExPoint, /* pGetTextExtentExPoint */
7381 freetype_GetTextExtentExPointI, /* pGetTextExtentExPointI */
7382 freetype_GetTextFace, /* pGetTextFace */
7383 freetype_GetTextMetrics, /* pGetTextMetrics */
7384 NULL, /* pGradientFill */
7385 NULL, /* pIntersectClipRect */
7386 NULL, /* pInvertRgn */
7387 NULL, /* pLineTo */
7388 NULL, /* pModifyWorldTransform */
7389 NULL, /* pMoveTo */
7390 NULL, /* pOffsetClipRgn */
7391 NULL, /* pOffsetViewportOrg */
7392 NULL, /* pOffsetWindowOrg */
7393 NULL, /* pPaintRgn */
7394 NULL, /* pPatBlt */
7395 NULL, /* pPie */
7396 NULL, /* pPolyBezier */
7397 NULL, /* pPolyBezierTo */
7398 NULL, /* pPolyDraw */
7399 NULL, /* pPolyPolygon */
7400 NULL, /* pPolyPolyline */
7401 NULL, /* pPolygon */
7402 NULL, /* pPolyline */
7403 NULL, /* pPolylineTo */
7404 NULL, /* pPutImage */
7405 NULL, /* pRealizeDefaultPalette */
7406 NULL, /* pRealizePalette */
7407 NULL, /* pRectangle */
7408 NULL, /* pResetDC */
7409 NULL, /* pRestoreDC */
7410 NULL, /* pRoundRect */
7411 NULL, /* pSaveDC */
7412 NULL, /* pScaleViewportExt */
7413 NULL, /* pScaleWindowExt */
7414 NULL, /* pSelectBitmap */
7415 NULL, /* pSelectBrush */
7416 NULL, /* pSelectClipPath */
7417 freetype_SelectFont, /* pSelectFont */
7418 NULL, /* pSelectPalette */
7419 NULL, /* pSelectPen */
7420 NULL, /* pSetArcDirection */
7421 NULL, /* pSetBkColor */
7422 NULL, /* pSetBkMode */
7423 NULL, /* pSetDCBrushColor */
7424 NULL, /* pSetDCPenColor */
7425 NULL, /* pSetDIBColorTable */
7426 NULL, /* pSetDIBitsToDevice */
7427 NULL, /* pSetDeviceClipping */
7428 NULL, /* pSetDeviceGammaRamp */
7429 NULL, /* pSetLayout */
7430 NULL, /* pSetMapMode */
7431 NULL, /* pSetMapperFlags */
7432 NULL, /* pSetPixel */
7433 NULL, /* pSetPixelFormat */
7434 NULL, /* pSetPolyFillMode */
7435 NULL, /* pSetROP2 */
7436 NULL, /* pSetRelAbs */
7437 NULL, /* pSetStretchBltMode */
7438 NULL, /* pSetTextAlign */
7439 NULL, /* pSetTextCharacterExtra */
7440 NULL, /* pSetTextColor */
7441 NULL, /* pSetTextJustification */
7442 NULL, /* pSetViewportExt */
7443 NULL, /* pSetViewportOrg */
7444 NULL, /* pSetWindowExt */
7445 NULL, /* pSetWindowOrg */
7446 NULL, /* pSetWorldTransform */
7447 NULL, /* pStartDoc */
7448 NULL, /* pStartPage */
7449 NULL, /* pStretchBlt */
7450 NULL, /* pStretchDIBits */
7451 NULL, /* pStrokeAndFillPath */
7452 NULL, /* pStrokePath */
7453 NULL, /* pSwapBuffers */
7454 NULL, /* pUnrealizePalette */
7455 NULL, /* pWidenPath */
7456 /* OpenGL not supported */
7457 };
7458
7459 #else /* HAVE_FREETYPE */
7460
7461 /*************************************************************************/
7462
7463 BOOL WineEngInit(void)
7464 {
7465 return FALSE;
7466 }
7467 BOOL WineEngDestroyFontInstance(HFONT hfont)
7468 {
7469 return FALSE;
7470 }
7471
7472 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
7473 {
7474 FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
7475 return 1;
7476 }
7477
7478 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
7479 {
7480 FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
7481 return TRUE;
7482 }
7483
7484 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
7485 {
7486 FIXME("(%p, %u, %p, %p): stub\n", pbFont, cbFont, pdv, pcFonts);
7487 return NULL;
7488 }
7489
7490 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
7491 {
7492 return FALSE;
7493 }
7494
7495 /*************************************************************************
7496 * GetRasterizerCaps (GDI32.@)
7497 */
7498 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
7499 {
7500 lprs->nSize = sizeof(RASTERIZER_STATUS);
7501 lprs->wFlags = 0;
7502 lprs->nLanguageID = 0;
7503 return TRUE;
7504 }
7505
7506 #endif /* HAVE_FREETYPE */
Maarten's multimedia branch