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