?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Use a separate variable to indicate the default has been retrieved.
[wine/multimedia.git] / dlls / gdi32 / freetype.c
blob81c704b911cf31a46976c07503703b7bc69c2262
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 WORD default_char;
4606 BOOL got_default = FALSE;
4607
4608 if (flags & GGI_MARK_NONEXISTING_GLYPHS)
4609 {
4610 default_char = 0xffff; /* XP would use 0x1f for bitmap fonts */
4611 got_default = TRUE;
4612 }
4613
4614 for(i = 0; i < count; i++)
4615 {
4616 pgi[i] = get_glyph_index(font, lpstr[i]);
4617 if (pgi[i] == 0)
4618 {
4619 if (!got_default)
4620 {
4621 if (FT_IS_SFNT(font->ft_face))
4622 {
4623 TT_OS2 *pOS2 = pFT_Get_Sfnt_Table(font->ft_face, ft_sfnt_os2);
4624 default_char = (pOS2->usDefaultChar ? get_glyph_index(font, pOS2->usDefaultChar) : 0);
4625 }
4626 else
4627 {
4628 TEXTMETRICW textm;
4629 WineEngGetTextMetrics(font, &textm);
4630 default_char = textm.tmDefaultChar;
4631 }
4632 got_default = TRUE;
4633 }
4634 pgi[i] = default_char;
4635 }
4636 }
4637 return count;
4638 }
4639
4640 static inline BOOL is_identity_FMAT2(const FMAT2 *matrix)
4641 {
4642 static const FMAT2 identity = { 1.0, 0.0, 0.0, 1.0 };
4643 return !memcmp(matrix, &identity, sizeof(FMAT2));
4644 }
4645
4646 static inline BOOL is_identity_MAT2(const MAT2 *matrix)
4647 {
4648 static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
4649 return !memcmp(matrix, &identity, sizeof(MAT2));
4650 }
4651
4652 /*************************************************************
4653 * WineEngGetGlyphOutline
4654 *
4655 * Behaves in exactly the same way as the win32 api GetGlyphOutline
4656 * except that the first parameter is the HWINEENGFONT of the font in
4657 * question rather than an HDC.
4658 *
4659 */
4660 DWORD WineEngGetGlyphOutline(GdiFont *incoming_font, UINT glyph, UINT format,
4661 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
4662 const MAT2* lpmat)
4663 {
4664 static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
4665 FT_Face ft_face = incoming_font->ft_face;
4666 GdiFont *font = incoming_font;
4667 FT_UInt glyph_index;
4668 DWORD width, height, pitch, needed = 0;
4669 FT_Bitmap ft_bitmap;
4670 FT_Error err;
4671 INT left, right, top = 0, bottom = 0, adv, lsb, bbx;
4672 FT_Angle angle = 0;
4673 FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
4674 double widthRatio = 1.0;
4675 FT_Matrix transMat = identityMat;
4676 FT_Matrix transMatUnrotated;
4677 BOOL needsTransform = FALSE;
4678 BOOL tategaki = (font->GSUB_Table != NULL);
4679 UINT original_index;
4680
4681 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
4682 buflen, buf, lpmat);
4683
4684 TRACE("font transform %f %f %f %f\n",
4685 font->font_desc.matrix.eM11, font->font_desc.matrix.eM12,
4686 font->font_desc.matrix.eM21, font->font_desc.matrix.eM22);
4687
4688 GDI_CheckNotLock();
4689 EnterCriticalSection( &freetype_cs );
4690
4691 if(format & GGO_GLYPH_INDEX) {
4692 glyph_index = get_GSUB_vert_glyph(incoming_font,glyph);
4693 original_index = glyph;
4694 format &= ~GGO_GLYPH_INDEX;
4695 } else {
4696 get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
4697 ft_face = font->ft_face;
4698 original_index = glyph_index;
4699 }
4700
4701 if(format & GGO_UNHINTED) {
4702 load_flags |= FT_LOAD_NO_HINTING;
4703 format &= ~GGO_UNHINTED;
4704 }
4705
4706 /* tategaki never appears to happen to lower glyph index */
4707 if (glyph_index < TATEGAKI_LOWER_BOUND )
4708 tategaki = FALSE;
4709
4710 if(original_index >= font->gmsize * GM_BLOCK_SIZE) {
4711 font->gmsize = (original_index / GM_BLOCK_SIZE + 1);
4712 font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
4713 font->gmsize * sizeof(GM*));
4714 } else {
4715 if (format == GGO_METRICS && font->gm[original_index / GM_BLOCK_SIZE] != NULL &&
4716 FONT_GM(font,original_index)->init && is_identity_MAT2(lpmat))
4717 {
4718 *lpgm = FONT_GM(font,original_index)->gm;
4719 TRACE("cached: %u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
4720 wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
4721 lpgm->gmCellIncX, lpgm->gmCellIncY);
4722 LeaveCriticalSection( &freetype_cs );
4723 return 1; /* FIXME */
4724 }
4725 }
4726
4727 if (!font->gm[original_index / GM_BLOCK_SIZE])
4728 font->gm[original_index / GM_BLOCK_SIZE] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
4729
4730 /* Scaling factor */
4731 if (font->aveWidth)
4732 {
4733 TEXTMETRICW tm;
4734
4735 WineEngGetTextMetrics(font, &tm);
4736
4737 widthRatio = (double)font->aveWidth;
4738 widthRatio /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
4739 }
4740 else
4741 widthRatio = font->scale_y;
4742
4743 /* Scaling transform */
4744 if (widthRatio != 1.0 || font->scale_y != 1.0)
4745 {
4746 FT_Matrix scaleMat;
4747 scaleMat.xx = FT_FixedFromFloat(widthRatio);
4748 scaleMat.xy = 0;
4749 scaleMat.yx = 0;
4750 scaleMat.yy = FT_FixedFromFloat(font->scale_y);
4751
4752 pFT_Matrix_Multiply(&scaleMat, &transMat);
4753 needsTransform = TRUE;
4754 }
4755
4756 /* Slant transform */
4757 if (font->fake_italic) {
4758 FT_Matrix slantMat;
4759
4760 slantMat.xx = (1 << 16);
4761 slantMat.xy = ((1 << 16) >> 2);
4762 slantMat.yx = 0;
4763 slantMat.yy = (1 << 16);
4764 pFT_Matrix_Multiply(&slantMat, &transMat);
4765 needsTransform = TRUE;
4766 }
4767
4768 /* Rotation transform */
4769 transMatUnrotated = transMat;
4770 if(font->orientation && !tategaki) {
4771 FT_Matrix rotationMat;
4772 FT_Vector vecAngle;
4773 angle = FT_FixedFromFloat((double)font->orientation / 10.0);
4774 pFT_Vector_Unit(&vecAngle, angle);
4775 rotationMat.xx = vecAngle.x;
4776 rotationMat.xy = -vecAngle.y;
4777 rotationMat.yx = -rotationMat.xy;
4778 rotationMat.yy = rotationMat.xx;
4779
4780 pFT_Matrix_Multiply(&rotationMat, &transMat);
4781 needsTransform = TRUE;
4782 }
4783
4784 /* World transform */
4785 if (!is_identity_FMAT2(&font->font_desc.matrix))
4786 {
4787 FT_Matrix worldMat;
4788 worldMat.xx = FT_FixedFromFloat(font->font_desc.matrix.eM11);
4789 worldMat.xy = FT_FixedFromFloat(font->font_desc.matrix.eM12);
4790 worldMat.yx = FT_FixedFromFloat(font->font_desc.matrix.eM21);
4791 worldMat.yy = FT_FixedFromFloat(font->font_desc.matrix.eM22);
4792 pFT_Matrix_Multiply(&worldMat, &transMat);
4793 pFT_Matrix_Multiply(&worldMat, &transMatUnrotated);
4794 needsTransform = TRUE;
4795 }
4796
4797 /* Extra transformation specified by caller */
4798 if (!is_identity_MAT2(lpmat))
4799 {
4800 FT_Matrix extraMat;
4801 extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
4802 extraMat.xy = FT_FixedFromFIXED(lpmat->eM12);
4803 extraMat.yx = FT_FixedFromFIXED(lpmat->eM21);
4804 extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
4805 pFT_Matrix_Multiply(&extraMat, &transMat);
4806 pFT_Matrix_Multiply(&extraMat, &transMatUnrotated);
4807 needsTransform = TRUE;
4808 }
4809
4810 if (needsTransform || (format == GGO_NATIVE || format == GGO_BEZIER ||
4811 format == GGO_GRAY2_BITMAP || format == GGO_GRAY4_BITMAP ||
4812 format == GGO_GRAY8_BITMAP))
4813 {
4814 load_flags |= FT_LOAD_NO_BITMAP;
4815 }
4816
4817 err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
4818
4819 if(err) {
4820 WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
4821 LeaveCriticalSection( &freetype_cs );
4822 return GDI_ERROR;
4823 }
4824
4825 if(!needsTransform) {
4826 left = (INT)(ft_face->glyph->metrics.horiBearingX) & -64;
4827 right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) + 63) & -64;
4828 adv = (INT)(ft_face->glyph->metrics.horiAdvance + 63) >> 6;
4829
4830 top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
4831 bottom = (ft_face->glyph->metrics.horiBearingY -
4832 ft_face->glyph->metrics.height) & -64;
4833 lpgm->gmCellIncX = adv;
4834 lpgm->gmCellIncY = 0;
4835 } else {
4836 INT xc, yc;
4837 FT_Vector vec;
4838
4839 left = right = 0;
4840
4841 for(xc = 0; xc < 2; xc++) {
4842 for(yc = 0; yc < 2; yc++) {
4843 vec.x = (ft_face->glyph->metrics.horiBearingX +
4844 xc * ft_face->glyph->metrics.width);
4845 vec.y = ft_face->glyph->metrics.horiBearingY -
4846 yc * ft_face->glyph->metrics.height;
4847 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
4848 pFT_Vector_Transform(&vec, &transMat);
4849 if(xc == 0 && yc == 0) {
4850 left = right = vec.x;
4851 top = bottom = vec.y;
4852 } else {
4853 if(vec.x < left) left = vec.x;
4854 else if(vec.x > right) right = vec.x;
4855 if(vec.y < bottom) bottom = vec.y;
4856 else if(vec.y > top) top = vec.y;
4857 }
4858 }
4859 }
4860 left = left & -64;
4861 right = (right + 63) & -64;
4862 bottom = bottom & -64;
4863 top = (top + 63) & -64;
4864
4865 TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
4866 vec.x = ft_face->glyph->metrics.horiAdvance;
4867 vec.y = 0;
4868 pFT_Vector_Transform(&vec, &transMat);
4869 lpgm->gmCellIncX = (vec.x+63) >> 6;
4870 lpgm->gmCellIncY = -((vec.y+63) >> 6);
4871
4872 vec.x = ft_face->glyph->metrics.horiAdvance;
4873 vec.y = 0;
4874 pFT_Vector_Transform(&vec, &transMatUnrotated);
4875 adv = (vec.x+63) >> 6;
4876 }
4877
4878 lsb = left >> 6;
4879 bbx = (right - left) >> 6;
4880 lpgm->gmBlackBoxX = (right - left) >> 6;
4881 lpgm->gmBlackBoxY = (top - bottom) >> 6;
4882 lpgm->gmptGlyphOrigin.x = left >> 6;
4883 lpgm->gmptGlyphOrigin.y = top >> 6;
4884
4885 TRACE("%u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
4886 wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
4887 lpgm->gmCellIncX, lpgm->gmCellIncY);
4888
4889 if ((format == GGO_METRICS || format == GGO_BITMAP || format == WINE_GGO_GRAY16_BITMAP) &&
4890 is_identity_MAT2(lpmat)) /* don't cache custom transforms */
4891 {
4892 FONT_GM(font,original_index)->gm = *lpgm;
4893 FONT_GM(font,original_index)->adv = adv;
4894 FONT_GM(font,original_index)->lsb = lsb;
4895 FONT_GM(font,original_index)->bbx = bbx;
4896 FONT_GM(font,original_index)->init = TRUE;
4897 }
4898
4899 if(format == GGO_METRICS)
4900 {
4901 LeaveCriticalSection( &freetype_cs );
4902 return 1; /* FIXME */
4903 }
4904
4905 if(ft_face->glyph->format != ft_glyph_format_outline &&
4906 (format == GGO_NATIVE || format == GGO_BEZIER ||
4907 format == GGO_GRAY2_BITMAP || format == GGO_GRAY4_BITMAP ||
4908 format == GGO_GRAY8_BITMAP))
4909 {
4910 TRACE("loaded a bitmap\n");
4911 LeaveCriticalSection( &freetype_cs );
4912 return GDI_ERROR;
4913 }
4914
4915 switch(format) {
4916 case GGO_BITMAP:
4917 width = lpgm->gmBlackBoxX;
4918 height = lpgm->gmBlackBoxY;
4919 pitch = ((width + 31) >> 5) << 2;
4920 needed = pitch * height;
4921
4922 if(!buf || !buflen) break;
4923
4924 switch(ft_face->glyph->format) {
4925 case ft_glyph_format_bitmap:
4926 {
4927 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
4928 INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
4929 INT h = ft_face->glyph->bitmap.rows;
4930 while(h--) {
4931 memcpy(dst, src, w);
4932 src += ft_face->glyph->bitmap.pitch;
4933 dst += pitch;
4934 }
4935 break;
4936 }
4937
4938 case ft_glyph_format_outline:
4939 ft_bitmap.width = width;
4940 ft_bitmap.rows = height;
4941 ft_bitmap.pitch = pitch;
4942 ft_bitmap.pixel_mode = ft_pixel_mode_mono;
4943 ft_bitmap.buffer = buf;
4944
4945 if(needsTransform)
4946 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
4947
4948 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
4949
4950 /* Note: FreeType will only set 'black' bits for us. */
4951 memset(buf, 0, needed);
4952 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
4953 break;
4954
4955 default:
4956 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
4957 LeaveCriticalSection( &freetype_cs );
4958 return GDI_ERROR;
4959 }
4960 break;
4961
4962 case GGO_GRAY2_BITMAP:
4963 case GGO_GRAY4_BITMAP:
4964 case GGO_GRAY8_BITMAP:
4965 case WINE_GGO_GRAY16_BITMAP:
4966 {
4967 unsigned int mult, row, col;
4968 BYTE *start, *ptr;
4969
4970 width = lpgm->gmBlackBoxX;
4971 height = lpgm->gmBlackBoxY;
4972 pitch = (width + 3) / 4 * 4;
4973 needed = pitch * height;
4974
4975 if(!buf || !buflen) break;
4976
4977 switch(ft_face->glyph->format) {
4978 case ft_glyph_format_bitmap:
4979 {
4980 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
4981 INT h = ft_face->glyph->bitmap.rows;
4982 INT x;
4983 memset( buf, 0, needed );
4984 while(h--) {
4985 for(x = 0; x < pitch && x < ft_face->glyph->bitmap.width; x++)
4986 if (src[x / 8] & (1 << ( (7 - (x % 8))))) dst[x] = 0xff;
4987 src += ft_face->glyph->bitmap.pitch;
4988 dst += pitch;
4989 }
4990 LeaveCriticalSection( &freetype_cs );
4991 return needed;
4992 }
4993 case ft_glyph_format_outline:
4994 {
4995 ft_bitmap.width = width;
4996 ft_bitmap.rows = height;
4997 ft_bitmap.pitch = pitch;
4998 ft_bitmap.pixel_mode = ft_pixel_mode_grays;
4999 ft_bitmap.buffer = buf;
5000
5001 if(needsTransform)
5002 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
5003
5004 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
5005
5006 memset(ft_bitmap.buffer, 0, buflen);
5007
5008 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
5009
5010 if(format == GGO_GRAY2_BITMAP)
5011 mult = 4;
5012 else if(format == GGO_GRAY4_BITMAP)
5013 mult = 16;
5014 else if(format == GGO_GRAY8_BITMAP)
5015 mult = 64;
5016 else /* format == WINE_GGO_GRAY16_BITMAP */
5017 {
5018 LeaveCriticalSection( &freetype_cs );
5019 return needed;
5020 }
5021 break;
5022 }
5023 default:
5024 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
5025 LeaveCriticalSection( &freetype_cs );
5026 return GDI_ERROR;
5027 }
5028
5029 start = buf;
5030 for(row = 0; row < height; row++) {
5031 ptr = start;
5032 for(col = 0; col < width; col++, ptr++) {
5033 *ptr = (((int)*ptr) * mult + 128) / 256;
5034 }
5035 start += pitch;
5036 }
5037 break;
5038 }
5039
5040 case WINE_GGO_HRGB_BITMAP:
5041 case WINE_GGO_HBGR_BITMAP:
5042 case WINE_GGO_VRGB_BITMAP:
5043 case WINE_GGO_VBGR_BITMAP:
5044 #ifdef HAVE_FREETYPE_FTLCDFIL_H
5045 {
5046 switch (ft_face->glyph->format)
5047 {
5048 case FT_GLYPH_FORMAT_BITMAP:
5049 {
5050 BYTE *src, *dst;
5051 INT src_pitch, x;
5052
5053 width = lpgm->gmBlackBoxX;
5054 height = lpgm->gmBlackBoxY;
5055 pitch = width * 4;
5056 needed = pitch * height;
5057
5058 if (!buf || !buflen) break;
5059
5060 memset(buf, 0, buflen);
5061 dst = buf;
5062 src = ft_face->glyph->bitmap.buffer;
5063 src_pitch = ft_face->glyph->bitmap.pitch;
5064
5065 height = min( height, ft_face->glyph->bitmap.rows );
5066 while ( height-- )
5067 {
5068 for (x = 0; x < width && x < ft_face->glyph->bitmap.width; x++)
5069 {
5070 if ( src[x / 8] & (1 << ( (7 - (x % 8)))) )
5071 ((unsigned int *)dst)[x] = ~0u;
5072 }
5073 src += src_pitch;
5074 dst += pitch;
5075 }
5076
5077 break;
5078 }
5079
5080 case FT_GLYPH_FORMAT_OUTLINE:
5081 {
5082 unsigned int *dst;
5083 BYTE *src;
5084 INT x, src_pitch, src_width, src_height, rgb_interval, hmul, vmul;
5085 INT x_shift, y_shift;
5086 BOOL rgb;
5087 FT_LcdFilter lcdfilter = FT_LCD_FILTER_DEFAULT;
5088 FT_Render_Mode render_mode =
5089 (format == WINE_GGO_HRGB_BITMAP || format == WINE_GGO_HBGR_BITMAP)?
5090 FT_RENDER_MODE_LCD: FT_RENDER_MODE_LCD_V;
5091
5092 if ( lcdfilter == FT_LCD_FILTER_DEFAULT || lcdfilter == FT_LCD_FILTER_LIGHT )
5093 {
5094 if ( render_mode == FT_RENDER_MODE_LCD)
5095 {
5096 lpgm->gmBlackBoxX += 2;
5097 lpgm->gmptGlyphOrigin.x -= 1;
5098 }
5099 else
5100 {
5101 lpgm->gmBlackBoxY += 2;
5102 lpgm->gmptGlyphOrigin.y += 1;
5103 }
5104 }
5105
5106 width = lpgm->gmBlackBoxX;
5107 height = lpgm->gmBlackBoxY;
5108 pitch = width * 4;
5109 needed = pitch * height;
5110
5111 if (!buf || !buflen) break;
5112
5113 memset(buf, 0, buflen);
5114 dst = buf;
5115 rgb = (format == WINE_GGO_HRGB_BITMAP || format == WINE_GGO_VRGB_BITMAP);
5116
5117 if ( needsTransform )
5118 pFT_Outline_Transform (&ft_face->glyph->outline, &transMat);
5119
5120 if ( pFT_Library_SetLcdFilter )
5121 pFT_Library_SetLcdFilter( library, lcdfilter );
5122 pFT_Render_Glyph (ft_face->glyph, render_mode);
5123
5124 src = ft_face->glyph->bitmap.buffer;
5125 src_pitch = ft_face->glyph->bitmap.pitch;
5126 src_width = ft_face->glyph->bitmap.width;
5127 src_height = ft_face->glyph->bitmap.rows;
5128
5129 if ( render_mode == FT_RENDER_MODE_LCD)
5130 {
5131 rgb_interval = 1;
5132 hmul = 3;
5133 vmul = 1;
5134 }
5135 else
5136 {
5137 rgb_interval = src_pitch;
5138 hmul = 1;
5139 vmul = 3;
5140 }
5141
5142 x_shift = ft_face->glyph->bitmap_left - lpgm->gmptGlyphOrigin.x;
5143 if ( x_shift < 0 ) x_shift = 0;
5144 if ( x_shift + (src_width / hmul) > width )
5145 x_shift = width - (src_width / hmul);
5146
5147 y_shift = lpgm->gmptGlyphOrigin.y - ft_face->glyph->bitmap_top;
5148 if ( y_shift < 0 ) y_shift = 0;
5149 if ( y_shift + (src_height / vmul) > height )
5150 y_shift = height - (src_height / vmul);
5151
5152 dst += x_shift + y_shift * ( pitch / 4 );
5153 while ( src_height )
5154 {
5155 for ( x = 0; x < src_width / hmul; x++ )
5156 {
5157 if ( rgb )
5158 {
5159 dst[x] = ((unsigned int)src[hmul * x + rgb_interval * 0] << 16) |
5160 ((unsigned int)src[hmul * x + rgb_interval * 1] << 8) |
5161 ((unsigned int)src[hmul * x + rgb_interval * 2] << 0) |
5162 ((unsigned int)src[hmul * x + rgb_interval * 1] << 24) ;
5163 }
5164 else
5165 {
5166 dst[x] = ((unsigned int)src[hmul * x + rgb_interval * 2] << 16) |
5167 ((unsigned int)src[hmul * x + rgb_interval * 1] << 8) |
5168 ((unsigned int)src[hmul * x + rgb_interval * 0] << 0) |
5169 ((unsigned int)src[hmul * x + rgb_interval * 1] << 24) ;
5170 }
5171 }
5172 src += src_pitch * vmul;
5173 dst += pitch / 4;
5174 src_height -= vmul;
5175 }
5176
5177 break;
5178 }
5179
5180 default:
5181 FIXME ("loaded glyph format %x\n", ft_face->glyph->format);
5182 LeaveCriticalSection ( &freetype_cs );
5183 return GDI_ERROR;
5184 }
5185
5186 break;
5187 }
5188 #else
5189 LeaveCriticalSection( &freetype_cs );
5190 return GDI_ERROR;
5191 #endif
5192
5193 case GGO_NATIVE:
5194 {
5195 int contour, point = 0, first_pt;
5196 FT_Outline *outline = &ft_face->glyph->outline;
5197 TTPOLYGONHEADER *pph;
5198 TTPOLYCURVE *ppc;
5199 DWORD pph_start, cpfx, type;
5200
5201 if(buflen == 0) buf = NULL;
5202
5203 if (needsTransform && buf) {
5204 pFT_Outline_Transform(outline, &transMat);
5205 }
5206
5207 for(contour = 0; contour < outline->n_contours; contour++) {
5208 pph_start = needed;
5209 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
5210 first_pt = point;
5211 if(buf) {
5212 pph->dwType = TT_POLYGON_TYPE;
5213 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
5214 }
5215 needed += sizeof(*pph);
5216 point++;
5217 while(point <= outline->contours[contour]) {
5218 ppc = (TTPOLYCURVE *)((char *)buf + needed);
5219 type = (outline->tags[point] & FT_Curve_Tag_On) ?
5220 TT_PRIM_LINE : TT_PRIM_QSPLINE;
5221 cpfx = 0;
5222 do {
5223 if(buf)
5224 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
5225 cpfx++;
5226 point++;
5227 } while(point <= outline->contours[contour] &&
5228 (outline->tags[point] & FT_Curve_Tag_On) ==
5229 (outline->tags[point-1] & FT_Curve_Tag_On));
5230 /* At the end of a contour Windows adds the start point, but
5231 only for Beziers */
5232 if(point > outline->contours[contour] &&
5233 !(outline->tags[point-1] & FT_Curve_Tag_On)) {
5234 if(buf)
5235 FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
5236 cpfx++;
5237 } else if(point <= outline->contours[contour] &&
5238 outline->tags[point] & FT_Curve_Tag_On) {
5239 /* add closing pt for bezier */
5240 if(buf)
5241 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
5242 cpfx++;
5243 point++;
5244 }
5245 if(buf) {
5246 ppc->wType = type;
5247 ppc->cpfx = cpfx;
5248 }
5249 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
5250 }
5251 if(buf)
5252 pph->cb = needed - pph_start;
5253 }
5254 break;
5255 }
5256 case GGO_BEZIER:
5257 {
5258 /* Convert the quadratic Beziers to cubic Beziers.
5259 The parametric eqn for a cubic Bezier is, from PLRM:
5260 r(t) = at^3 + bt^2 + ct + r0
5261 with the control points:
5262 r1 = r0 + c/3
5263 r2 = r1 + (c + b)/3
5264 r3 = r0 + c + b + a
5265
5266 A quadratic Bezier has the form:
5267 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
5268
5269 So equating powers of t leads to:
5270 r1 = 2/3 p1 + 1/3 p0
5271 r2 = 2/3 p1 + 1/3 p2
5272 and of course r0 = p0, r3 = p2
5273 */
5274
5275 int contour, point = 0, first_pt;
5276 FT_Outline *outline = &ft_face->glyph->outline;
5277 TTPOLYGONHEADER *pph;
5278 TTPOLYCURVE *ppc;
5279 DWORD pph_start, cpfx, type;
5280 FT_Vector cubic_control[4];
5281 if(buflen == 0) buf = NULL;
5282
5283 if (needsTransform && buf) {
5284 pFT_Outline_Transform(outline, &transMat);
5285 }
5286
5287 for(contour = 0; contour < outline->n_contours; contour++) {
5288 pph_start = needed;
5289 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
5290 first_pt = point;
5291 if(buf) {
5292 pph->dwType = TT_POLYGON_TYPE;
5293 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
5294 }
5295 needed += sizeof(*pph);
5296 point++;
5297 while(point <= outline->contours[contour]) {
5298 ppc = (TTPOLYCURVE *)((char *)buf + needed);
5299 type = (outline->tags[point] & FT_Curve_Tag_On) ?
5300 TT_PRIM_LINE : TT_PRIM_CSPLINE;
5301 cpfx = 0;
5302 do {
5303 if(type == TT_PRIM_LINE) {
5304 if(buf)
5305 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
5306 cpfx++;
5307 point++;
5308 } else {
5309 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
5310 so cpfx = 3n */
5311
5312 /* FIXME: Possible optimization in endpoint calculation
5313 if there are two consecutive curves */
5314 cubic_control[0] = outline->points[point-1];
5315 if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
5316 cubic_control[0].x += outline->points[point].x + 1;
5317 cubic_control[0].y += outline->points[point].y + 1;
5318 cubic_control[0].x >>= 1;
5319 cubic_control[0].y >>= 1;
5320 }
5321 if(point+1 > outline->contours[contour])
5322 cubic_control[3] = outline->points[first_pt];
5323 else {
5324 cubic_control[3] = outline->points[point+1];
5325 if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
5326 cubic_control[3].x += outline->points[point].x + 1;
5327 cubic_control[3].y += outline->points[point].y + 1;
5328 cubic_control[3].x >>= 1;
5329 cubic_control[3].y >>= 1;
5330 }
5331 }
5332 /* r1 = 1/3 p0 + 2/3 p1
5333 r2 = 1/3 p2 + 2/3 p1 */
5334 cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
5335 cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
5336 cubic_control[2] = cubic_control[1];
5337 cubic_control[1].x += (cubic_control[0].x + 1) / 3;
5338 cubic_control[1].y += (cubic_control[0].y + 1) / 3;
5339 cubic_control[2].x += (cubic_control[3].x + 1) / 3;
5340 cubic_control[2].y += (cubic_control[3].y + 1) / 3;
5341 if(buf) {
5342 FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
5343 FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
5344 FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
5345 }
5346 cpfx += 3;
5347 point++;
5348 }
5349 } while(point <= outline->contours[contour] &&
5350 (outline->tags[point] & FT_Curve_Tag_On) ==
5351 (outline->tags[point-1] & FT_Curve_Tag_On));
5352 /* At the end of a contour Windows adds the start point,
5353 but only for Beziers and we've already done that.
5354 */
5355 if(point <= outline->contours[contour] &&
5356 outline->tags[point] & FT_Curve_Tag_On) {
5357 /* This is the closing pt of a bezier, but we've already
5358 added it, so just inc point and carry on */
5359 point++;
5360 }
5361 if(buf) {
5362 ppc->wType = type;
5363 ppc->cpfx = cpfx;
5364 }
5365 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
5366 }
5367 if(buf)
5368 pph->cb = needed - pph_start;
5369 }
5370 break;
5371 }
5372
5373 default:
5374 FIXME("Unsupported format %d\n", format);
5375 LeaveCriticalSection( &freetype_cs );
5376 return GDI_ERROR;
5377 }
5378 LeaveCriticalSection( &freetype_cs );
5379 return needed;
5380 }
5381
5382 static BOOL get_bitmap_text_metrics(GdiFont *font)
5383 {
5384 FT_Face ft_face = font->ft_face;
5385 #ifdef HAVE_FREETYPE_FTWINFNT_H
5386 FT_WinFNT_HeaderRec winfnt_header;
5387 #endif
5388 const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
5389 font->potm = HeapAlloc(GetProcessHeap(), 0, size);
5390 font->potm->otmSize = size;
5391
5392 #define TM font->potm->otmTextMetrics
5393 #ifdef HAVE_FREETYPE_FTWINFNT_H
5394 if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
5395 {
5396 TM.tmHeight = winfnt_header.pixel_height;
5397 TM.tmAscent = winfnt_header.ascent;
5398 TM.tmDescent = TM.tmHeight - TM.tmAscent;
5399 TM.tmInternalLeading = winfnt_header.internal_leading;
5400 TM.tmExternalLeading = winfnt_header.external_leading;
5401 TM.tmAveCharWidth = winfnt_header.avg_width;
5402 TM.tmMaxCharWidth = winfnt_header.max_width;
5403 TM.tmWeight = winfnt_header.weight;
5404 TM.tmOverhang = 0;
5405 TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
5406 TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
5407 TM.tmFirstChar = winfnt_header.first_char;
5408 TM.tmLastChar = winfnt_header.last_char;
5409 TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
5410 TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
5411 TM.tmItalic = winfnt_header.italic;
5412 TM.tmUnderlined = font->underline;
5413 TM.tmStruckOut = font->strikeout;
5414 TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
5415 TM.tmCharSet = winfnt_header.charset;
5416 }
5417 else
5418 #endif
5419 {
5420 TM.tmAscent = ft_face->size->metrics.ascender >> 6;
5421 TM.tmDescent = -ft_face->size->metrics.descender >> 6;
5422 TM.tmHeight = TM.tmAscent + TM.tmDescent;
5423 TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
5424 TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
5425 TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
5426 TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
5427 TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
5428 TM.tmOverhang = 0;
5429 TM.tmDigitizedAspectX = 96; /* FIXME */
5430 TM.tmDigitizedAspectY = 96; /* FIXME */
5431 TM.tmFirstChar = 1;
5432 TM.tmLastChar = 255;
5433 TM.tmDefaultChar = 32;
5434 TM.tmBreakChar = 32;
5435 TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
5436 TM.tmUnderlined = font->underline;
5437 TM.tmStruckOut = font->strikeout;
5438 /* NB inverted meaning of TMPF_FIXED_PITCH */
5439 TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
5440 TM.tmCharSet = font->charset;
5441 }
5442 #undef TM
5443
5444 return TRUE;
5445 }
5446
5447
5448 static void scale_font_metrics(const GdiFont *font, LPTEXTMETRICW ptm)
5449 {
5450 double scale_x, scale_y;
5451
5452 if (font->aveWidth)
5453 {
5454 scale_x = (double)font->aveWidth;
5455 scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
5456 }
5457 else
5458 scale_x = font->scale_y;
5459
5460 scale_x *= fabs(font->font_desc.matrix.eM11);
5461 scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
5462
5463 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
5464 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
5465
5466 SCALE_Y(ptm->tmHeight);
5467 SCALE_Y(ptm->tmAscent);
5468 SCALE_Y(ptm->tmDescent);
5469 SCALE_Y(ptm->tmInternalLeading);
5470 SCALE_Y(ptm->tmExternalLeading);
5471 SCALE_Y(ptm->tmOverhang);
5472
5473 SCALE_X(ptm->tmAveCharWidth);
5474 SCALE_X(ptm->tmMaxCharWidth);
5475
5476 #undef SCALE_X
5477 #undef SCALE_Y
5478 }
5479
5480 static void scale_outline_font_metrics(const GdiFont *font, OUTLINETEXTMETRICW *potm)
5481 {
5482 double scale_x, scale_y;
5483
5484 if (font->aveWidth)
5485 {
5486 scale_x = (double)font->aveWidth;
5487 scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
5488 }
5489 else
5490 scale_x = font->scale_y;
5491
5492 scale_x *= fabs(font->font_desc.matrix.eM11);
5493 scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
5494
5495 scale_font_metrics(font, &potm->otmTextMetrics);
5496
5497 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
5498 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
5499
5500 SCALE_Y(potm->otmAscent);
5501 SCALE_Y(potm->otmDescent);
5502 SCALE_Y(potm->otmLineGap);
5503 SCALE_Y(potm->otmsCapEmHeight);
5504 SCALE_Y(potm->otmsXHeight);
5505 SCALE_Y(potm->otmrcFontBox.top);
5506 SCALE_Y(potm->otmrcFontBox.bottom);
5507 SCALE_X(potm->otmrcFontBox.left);
5508 SCALE_X(potm->otmrcFontBox.right);
5509 SCALE_Y(potm->otmMacAscent);
5510 SCALE_Y(potm->otmMacDescent);
5511 SCALE_Y(potm->otmMacLineGap);
5512 SCALE_X(potm->otmptSubscriptSize.x);
5513 SCALE_Y(potm->otmptSubscriptSize.y);
5514 SCALE_X(potm->otmptSubscriptOffset.x);
5515 SCALE_Y(potm->otmptSubscriptOffset.y);
5516 SCALE_X(potm->otmptSuperscriptSize.x);
5517 SCALE_Y(potm->otmptSuperscriptSize.y);
5518 SCALE_X(potm->otmptSuperscriptOffset.x);
5519 SCALE_Y(potm->otmptSuperscriptOffset.y);
5520 SCALE_Y(potm->otmsStrikeoutSize);
5521 SCALE_Y(potm->otmsStrikeoutPosition);
5522 SCALE_Y(potm->otmsUnderscoreSize);
5523 SCALE_Y(potm->otmsUnderscorePosition);
5524
5525 #undef SCALE_X
5526 #undef SCALE_Y
5527 }
5528
5529 /*************************************************************
5530 * WineEngGetTextMetrics
5531 *
5532 */
5533 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
5534 {
5535 GDI_CheckNotLock();
5536 EnterCriticalSection( &freetype_cs );
5537 if(!font->potm) {
5538 if(!WineEngGetOutlineTextMetrics(font, 0, NULL))
5539 if(!get_bitmap_text_metrics(font))
5540 {
5541 LeaveCriticalSection( &freetype_cs );
5542 return FALSE;
5543 }
5544
5545 /* Make sure that the font has sane width/height ratio */
5546 if (font->aveWidth)
5547 {
5548 if ((font->aveWidth + font->potm->otmTextMetrics.tmHeight - 1) / font->potm->otmTextMetrics.tmHeight > 100)
5549 {
5550 WARN("Ignoring too large font->aveWidth %d\n", font->aveWidth);
5551 font->aveWidth = 0;
5552 }
5553 }
5554 }
5555
5556 *ptm = font->potm->otmTextMetrics;
5557 scale_font_metrics(font, ptm);
5558 LeaveCriticalSection( &freetype_cs );
5559 return TRUE;
5560 }
5561
5562 static BOOL face_has_symbol_charmap(FT_Face ft_face)
5563 {
5564 int i;
5565
5566 for(i = 0; i < ft_face->num_charmaps; i++)
5567 {
5568 if(ft_face->charmaps[i]->encoding == FT_ENCODING_MS_SYMBOL)
5569 return TRUE;
5570 }
5571 return FALSE;
5572 }
5573
5574 /*************************************************************
5575 * WineEngGetOutlineTextMetrics
5576 *
5577 */
5578 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
5579 OUTLINETEXTMETRICW *potm)
5580 {
5581 FT_Face ft_face = font->ft_face;
5582 UINT needed, lenfam, lensty, ret;
5583 TT_OS2 *pOS2;
5584 TT_HoriHeader *pHori;
5585 TT_Postscript *pPost;
5586 FT_Fixed x_scale, y_scale;
5587 WCHAR *family_nameW, *style_nameW;
5588 static const WCHAR spaceW[] = {' ', '\0'};
5589 char *cp;
5590 INT ascent, descent;
5591
5592 TRACE("font=%p\n", font);
5593
5594 if(!FT_IS_SCALABLE(ft_face))
5595 return 0;
5596
5597 GDI_CheckNotLock();
5598 EnterCriticalSection( &freetype_cs );
5599
5600 if(font->potm) {
5601 if(cbSize >= font->potm->otmSize)
5602 {
5603 memcpy(potm, font->potm, font->potm->otmSize);
5604 scale_outline_font_metrics(font, potm);
5605 }
5606 LeaveCriticalSection( &freetype_cs );
5607 return font->potm->otmSize;
5608 }
5609
5610
5611 needed = sizeof(*potm);
5612
5613 lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
5614 family_nameW = strdupW(font->name);
5615
5616 lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
5617 * sizeof(WCHAR);
5618 style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
5619 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
5620 style_nameW, lensty/sizeof(WCHAR));
5621
5622 /* These names should be read from the TT name table */
5623
5624 /* length of otmpFamilyName */
5625 needed += lenfam;
5626
5627 /* length of otmpFaceName */
5628 if ((ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) == 0) {
5629 needed += lenfam; /* just the family name */
5630 } else {
5631 needed += lenfam + lensty; /* family + " " + style */
5632 }
5633
5634 /* length of otmpStyleName */
5635 needed += lensty;
5636
5637 /* length of otmpFullName */
5638 needed += lenfam + lensty;
5639
5640
5641 x_scale = ft_face->size->metrics.x_scale;
5642 y_scale = ft_face->size->metrics.y_scale;
5643
5644 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
5645 if(!pOS2) {
5646 FIXME("Can't find OS/2 table - not TT font?\n");
5647 ret = 0;
5648 goto end;
5649 }
5650
5651 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
5652 if(!pHori) {
5653 FIXME("Can't find HHEA table - not TT font?\n");
5654 ret = 0;
5655 goto end;
5656 }
5657
5658 pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
5659
5660 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",
5661 pOS2->usWinAscent, pOS2->usWinDescent,
5662 pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
5663 ft_face->ascender, ft_face->descender, ft_face->height,
5664 pHori->Ascender, pHori->Descender, pHori->Line_Gap,
5665 ft_face->bbox.yMax, ft_face->bbox.yMin);
5666
5667 font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
5668 font->potm->otmSize = needed;
5669
5670 #define TM font->potm->otmTextMetrics
5671
5672 if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
5673 ascent = pHori->Ascender;
5674 descent = -pHori->Descender;
5675 } else {
5676 ascent = pOS2->usWinAscent;
5677 descent = pOS2->usWinDescent;
5678 }
5679
5680 if(font->yMax) {
5681 TM.tmAscent = font->yMax;
5682 TM.tmDescent = -font->yMin;
5683 TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
5684 } else {
5685 TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
5686 TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
5687 TM.tmInternalLeading = (pFT_MulFix(ascent + descent
5688 - ft_face->units_per_EM, y_scale) + 32) >> 6;
5689 }
5690
5691 TM.tmHeight = TM.tmAscent + TM.tmDescent;
5692
5693 /* MSDN says:
5694 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
5695 */
5696 TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
5697 ((ascent + descent) -
5698 (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
5699
5700 TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
5701 if (TM.tmAveCharWidth == 0) {
5702 TM.tmAveCharWidth = 1;
5703 }
5704 TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
5705 TM.tmWeight = FW_REGULAR;
5706 if (font->fake_bold)
5707 TM.tmWeight = FW_BOLD;
5708 else
5709 {
5710 if (ft_face->style_flags & FT_STYLE_FLAG_BOLD)
5711 {
5712 if (pOS2->usWeightClass > FW_MEDIUM)
5713 TM.tmWeight = pOS2->usWeightClass;
5714 }
5715 else if (pOS2->usWeightClass <= FW_MEDIUM)
5716 TM.tmWeight = pOS2->usWeightClass;
5717 }
5718 TM.tmOverhang = 0;
5719 TM.tmDigitizedAspectX = 300;
5720 TM.tmDigitizedAspectY = 300;
5721 /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
5722 * symbol range to 0 - f0ff
5723 */
5724
5725 if (face_has_symbol_charmap(ft_face) || (pOS2->usFirstCharIndex >= 0xf000 && pOS2->usFirstCharIndex < 0xf100))
5726 {
5727 TM.tmFirstChar = 0;
5728 switch(GetACP())
5729 {
5730 case 1257: /* Baltic */
5731 TM.tmLastChar = 0xf8fd;
5732 break;
5733 default:
5734 TM.tmLastChar = 0xf0ff;
5735 }
5736 TM.tmBreakChar = 0x20;
5737 TM.tmDefaultChar = 0x1f;
5738 }
5739 else
5740 {
5741 TM.tmFirstChar = pOS2->usFirstCharIndex; /* Should be the first char in the cmap */
5742 TM.tmLastChar = pOS2->usLastCharIndex; /* Should be min(cmap_last, os2_last) */
5743
5744 if(pOS2->usFirstCharIndex <= 1)
5745 TM.tmBreakChar = pOS2->usFirstCharIndex + 2;
5746 else if (pOS2->usFirstCharIndex > 0xff)
5747 TM.tmBreakChar = 0x20;
5748 else
5749 TM.tmBreakChar = pOS2->usFirstCharIndex;
5750 TM.tmDefaultChar = TM.tmBreakChar - 1;
5751 }
5752 TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
5753 TM.tmUnderlined = font->underline;
5754 TM.tmStruckOut = font->strikeout;
5755
5756 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
5757 if(!FT_IS_FIXED_WIDTH(ft_face) &&
5758 (pOS2->version == 0xFFFFU ||
5759 pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
5760 TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
5761 else
5762 TM.tmPitchAndFamily = 0;
5763
5764 switch(pOS2->panose[PAN_FAMILYTYPE_INDEX])
5765 {
5766 case PAN_FAMILY_SCRIPT:
5767 TM.tmPitchAndFamily |= FF_SCRIPT;
5768 break;
5769
5770 case PAN_FAMILY_DECORATIVE:
5771 TM.tmPitchAndFamily |= FF_DECORATIVE;
5772 break;
5773
5774 case PAN_ANY:
5775 case PAN_NO_FIT:
5776 case PAN_FAMILY_TEXT_DISPLAY:
5777 case PAN_FAMILY_PICTORIAL: /* symbol fonts get treated as if they were text */
5778 /* which is clearly not what the panose spec says. */
5779 default:
5780 if(TM.tmPitchAndFamily == 0 || /* fixed */
5781 pOS2->panose[PAN_PROPORTION_INDEX] == PAN_PROP_MONOSPACED)
5782 TM.tmPitchAndFamily = FF_MODERN;
5783 else
5784 {
5785 switch(pOS2->panose[PAN_SERIFSTYLE_INDEX])
5786 {
5787 case PAN_ANY:
5788 case PAN_NO_FIT:
5789 default:
5790 TM.tmPitchAndFamily |= FF_DONTCARE;
5791 break;
5792
5793 case PAN_SERIF_COVE:
5794 case PAN_SERIF_OBTUSE_COVE:
5795 case PAN_SERIF_SQUARE_COVE:
5796 case PAN_SERIF_OBTUSE_SQUARE_COVE:
5797 case PAN_SERIF_SQUARE:
5798 case PAN_SERIF_THIN:
5799 case PAN_SERIF_BONE:
5800 case PAN_SERIF_EXAGGERATED:
5801 case PAN_SERIF_TRIANGLE:
5802 TM.tmPitchAndFamily |= FF_ROMAN;
5803 break;
5804
5805 case PAN_SERIF_NORMAL_SANS:
5806 case PAN_SERIF_OBTUSE_SANS:
5807 case PAN_SERIF_PERP_SANS:
5808 case PAN_SERIF_FLARED:
5809 case PAN_SERIF_ROUNDED:
5810 TM.tmPitchAndFamily |= FF_SWISS;
5811 break;
5812 }
5813 }
5814 break;
5815 }
5816
5817 if(FT_IS_SCALABLE(ft_face))
5818 TM.tmPitchAndFamily |= TMPF_VECTOR;
5819
5820 if(FT_IS_SFNT(ft_face))
5821 {
5822 if (font->ntmFlags & NTM_PS_OPENTYPE)
5823 TM.tmPitchAndFamily |= TMPF_DEVICE;
5824 else
5825 TM.tmPitchAndFamily |= TMPF_TRUETYPE;
5826 }
5827
5828 TM.tmCharSet = font->charset;
5829
5830 font->potm->otmFiller = 0;
5831 memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
5832 font->potm->otmfsSelection = pOS2->fsSelection;
5833 font->potm->otmfsType = pOS2->fsType;
5834 font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
5835 font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
5836 font->potm->otmItalicAngle = 0; /* POST table */
5837 font->potm->otmEMSquare = ft_face->units_per_EM;
5838 font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
5839 font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
5840 font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
5841 font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
5842 font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
5843 font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
5844 font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
5845 font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
5846 font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
5847 font->potm->otmMacAscent = TM.tmAscent;
5848 font->potm->otmMacDescent = -TM.tmDescent;
5849 font->potm->otmMacLineGap = font->potm->otmLineGap;
5850 font->potm->otmusMinimumPPEM = 0; /* TT Header */
5851 font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
5852 font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
5853 font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
5854 font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
5855 font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
5856 font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
5857 font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
5858 font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
5859 font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
5860 font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
5861 if(!pPost) {
5862 font->potm->otmsUnderscoreSize = 0;
5863 font->potm->otmsUnderscorePosition = 0;
5864 } else {
5865 font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
5866 font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
5867 }
5868 #undef TM
5869
5870 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
5871 cp = (char*)font->potm + sizeof(*font->potm);
5872 font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
5873 strcpyW((WCHAR*)cp, family_nameW);
5874 cp += lenfam;
5875 font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
5876 strcpyW((WCHAR*)cp, style_nameW);
5877 cp += lensty;
5878 font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
5879 strcpyW((WCHAR*)cp, family_nameW);
5880 if (ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) {
5881 strcatW((WCHAR*)cp, spaceW);
5882 strcatW((WCHAR*)cp, style_nameW);
5883 cp += lenfam + lensty;
5884 } else
5885 cp += lenfam;
5886 font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
5887 strcpyW((WCHAR*)cp, family_nameW);
5888 strcatW((WCHAR*)cp, spaceW);
5889 strcatW((WCHAR*)cp, style_nameW);
5890 ret = needed;
5891
5892 if(potm && needed <= cbSize)
5893 {
5894 memcpy(potm, font->potm, font->potm->otmSize);
5895 scale_outline_font_metrics(font, potm);
5896 }
5897
5898 end:
5899 HeapFree(GetProcessHeap(), 0, style_nameW);
5900 HeapFree(GetProcessHeap(), 0, family_nameW);
5901
5902 LeaveCriticalSection( &freetype_cs );
5903 return ret;
5904 }
5905
5906 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
5907 {
5908 HFONTLIST *hfontlist;
5909 child->font = alloc_font();
5910 child->font->ft_face = OpenFontFace(child->font, child->face, 0, -font->ppem);
5911 if(!child->font->ft_face)
5912 {
5913 free_font(child->font);
5914 child->font = NULL;
5915 return FALSE;
5916 }
5917
5918 child->font->font_desc = font->font_desc;
5919 child->font->ntmFlags = child->face->ntmFlags;
5920 child->font->orientation = font->orientation;
5921 child->font->scale_y = font->scale_y;
5922 hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
5923 hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
5924 child->font->name = strdupW(child->face->family->FamilyName);
5925 list_add_head(&child->font->hfontlist, &hfontlist->entry);
5926 child->font->base_font = font;
5927 list_add_head(&child_font_list, &child->font->entry);
5928 TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
5929 return TRUE;
5930 }
5931
5932 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
5933 {
5934 FT_UInt g;
5935 CHILD_FONT *child_font;
5936
5937 if(font->base_font)
5938 font = font->base_font;
5939
5940 *linked_font = font;
5941
5942 if((*glyph = get_glyph_index(font, c)))
5943 return TRUE;
5944
5945 LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
5946 {
5947 if(!child_font->font)
5948 if(!load_child_font(font, child_font))
5949 continue;
5950
5951 if(!child_font->font->ft_face)
5952 continue;
5953 g = get_glyph_index(child_font->font, c);
5954 if(g)
5955 {
5956 *glyph = g;
5957 *linked_font = child_font->font;
5958 return TRUE;
5959 }
5960 }
5961 return FALSE;
5962 }
5963
5964 /*************************************************************
5965 * WineEngGetCharWidth
5966 *
5967 */
5968 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
5969 LPINT buffer)
5970 {
5971 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
5972 UINT c;
5973 GLYPHMETRICS gm;
5974 FT_UInt glyph_index;
5975 GdiFont *linked_font;
5976
5977 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
5978
5979 GDI_CheckNotLock();
5980 EnterCriticalSection( &freetype_cs );
5981 for(c = firstChar; c <= lastChar; c++) {
5982 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
5983 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5984 &gm, 0, NULL, &identity);
5985 buffer[c - firstChar] = FONT_GM(linked_font,glyph_index)->adv;
5986 }
5987 LeaveCriticalSection( &freetype_cs );
5988 return TRUE;
5989 }
5990
5991 /*************************************************************
5992 * WineEngGetCharABCWidths
5993 *
5994 */
5995 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
5996 LPABC buffer)
5997 {
5998 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
5999 UINT c;
6000 GLYPHMETRICS gm;
6001 FT_UInt glyph_index;
6002 GdiFont *linked_font;
6003
6004 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
6005
6006 if(!FT_IS_SCALABLE(font->ft_face))
6007 return FALSE;
6008
6009 GDI_CheckNotLock();
6010 EnterCriticalSection( &freetype_cs );
6011
6012 for(c = firstChar; c <= lastChar; c++) {
6013 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
6014 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
6015 &gm, 0, NULL, &identity);
6016 buffer[c - firstChar].abcA = FONT_GM(linked_font,glyph_index)->lsb;
6017 buffer[c - firstChar].abcB = FONT_GM(linked_font,glyph_index)->bbx;
6018 buffer[c - firstChar].abcC = FONT_GM(linked_font,glyph_index)->adv - FONT_GM(linked_font,glyph_index)->lsb -
6019 FONT_GM(linked_font,glyph_index)->bbx;
6020 }
6021 LeaveCriticalSection( &freetype_cs );
6022 return TRUE;
6023 }
6024
6025 /*************************************************************
6026 * WineEngGetCharABCWidthsFloat
6027 *
6028 */
6029 BOOL WineEngGetCharABCWidthsFloat(GdiFont *font, UINT first, UINT last, LPABCFLOAT buffer)
6030 {
6031 static const MAT2 identity = {{0,1}, {0,0}, {0,0}, {0,1}};
6032 UINT c;
6033 GLYPHMETRICS gm;
6034 FT_UInt glyph_index;
6035 GdiFont *linked_font;
6036
6037 TRACE("%p, %d, %d, %p\n", font, first, last, buffer);
6038
6039 GDI_CheckNotLock();
6040 EnterCriticalSection( &freetype_cs );
6041
6042 for (c = first; c <= last; c++)
6043 {
6044 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
6045 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
6046 &gm, 0, NULL, &identity);
6047 buffer[c - first].abcfA = FONT_GM(linked_font, glyph_index)->lsb;
6048 buffer[c - first].abcfB = FONT_GM(linked_font, glyph_index)->bbx;
6049 buffer[c - first].abcfC = FONT_GM(linked_font, glyph_index)->adv -
6050 FONT_GM(linked_font, glyph_index)->lsb -
6051 FONT_GM(linked_font, glyph_index)->bbx;
6052 }
6053 LeaveCriticalSection( &freetype_cs );
6054 return TRUE;
6055 }
6056
6057 /*************************************************************
6058 * WineEngGetCharABCWidthsI
6059 *
6060 */
6061 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
6062 LPABC buffer)
6063 {
6064 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6065 UINT c;
6066 GLYPHMETRICS gm;
6067 FT_UInt glyph_index;
6068 GdiFont *linked_font;
6069
6070 if(!FT_HAS_HORIZONTAL(font->ft_face))
6071 return FALSE;
6072
6073 GDI_CheckNotLock();
6074 EnterCriticalSection( &freetype_cs );
6075
6076 get_glyph_index_linked(font, 'a', &linked_font, &glyph_index);
6077 if (!pgi)
6078 for(c = firstChar; c < firstChar+count; c++) {
6079 WineEngGetGlyphOutline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
6080 &gm, 0, NULL, &identity);
6081 buffer[c - firstChar].abcA = FONT_GM(linked_font,c)->lsb;
6082 buffer[c - firstChar].abcB = FONT_GM(linked_font,c)->bbx;
6083 buffer[c - firstChar].abcC = FONT_GM(linked_font,c)->adv - FONT_GM(linked_font,c)->lsb
6084 - FONT_GM(linked_font,c)->bbx;
6085 }
6086 else
6087 for(c = 0; c < count; c++) {
6088 WineEngGetGlyphOutline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
6089 &gm, 0, NULL, &identity);
6090 buffer[c].abcA = FONT_GM(linked_font,pgi[c])->lsb;
6091 buffer[c].abcB = FONT_GM(linked_font,pgi[c])->bbx;
6092 buffer[c].abcC = FONT_GM(linked_font,pgi[c])->adv
6093 - FONT_GM(linked_font,pgi[c])->lsb - FONT_GM(linked_font,pgi[c])->bbx;
6094 }
6095
6096 LeaveCriticalSection( &freetype_cs );
6097 return TRUE;
6098 }
6099
6100 /*************************************************************
6101 * WineEngGetTextExtentExPoint
6102 *
6103 */
6104 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
6105 INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
6106 {
6107 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6108 INT idx;
6109 INT nfit = 0, ext;
6110 GLYPHMETRICS gm;
6111 TEXTMETRICW tm;
6112 FT_UInt glyph_index;
6113 GdiFont *linked_font;
6114
6115 TRACE("%p, %s, %d, %d, %p\n", font, debugstr_wn(wstr, count), count,
6116 max_ext, size);
6117
6118 GDI_CheckNotLock();
6119 EnterCriticalSection( &freetype_cs );
6120
6121 size->cx = 0;
6122 WineEngGetTextMetrics(font, &tm);
6123 size->cy = tm.tmHeight;
6124
6125 for(idx = 0; idx < count; idx++) {
6126 get_glyph_index_linked(font, wstr[idx], &linked_font, &glyph_index);
6127 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
6128 &gm, 0, NULL, &identity);
6129 size->cx += FONT_GM(linked_font,glyph_index)->adv;
6130 ext = size->cx;
6131 if (! pnfit || ext <= max_ext) {
6132 ++nfit;
6133 if (dxs)
6134 dxs[idx] = ext;
6135 }
6136 }
6137
6138 if (pnfit)
6139 *pnfit = nfit;
6140
6141 LeaveCriticalSection( &freetype_cs );
6142 TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
6143 return TRUE;
6144 }
6145
6146 /*************************************************************
6147 * WineEngGetTextExtentExPointI
6148 *
6149 */
6150 BOOL WineEngGetTextExtentExPointI(GdiFont *font, const WORD *indices, INT count,
6151 INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
6152 {
6153 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6154 INT idx;
6155 INT nfit = 0, ext;
6156 GLYPHMETRICS gm;
6157 TEXTMETRICW tm;
6158
6159 TRACE("%p, %p, %d, %d, %p\n", font, indices, count, max_ext, size);
6160
6161 GDI_CheckNotLock();
6162 EnterCriticalSection( &freetype_cs );
6163
6164 size->cx = 0;
6165 WineEngGetTextMetrics(font, &tm);
6166 size->cy = tm.tmHeight;
6167
6168 for(idx = 0; idx < count; idx++) {
6169 WineEngGetGlyphOutline(font, indices[idx],
6170 GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL,
6171 &identity);
6172 size->cx += FONT_GM(font,indices[idx])->adv;
6173 ext = size->cx;
6174 if (! pnfit || ext <= max_ext) {
6175 ++nfit;
6176 if (dxs)
6177 dxs[idx] = ext;
6178 }
6179 }
6180
6181 if (pnfit)
6182 *pnfit = nfit;
6183
6184 LeaveCriticalSection( &freetype_cs );
6185 TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
6186 return TRUE;
6187 }
6188
6189 /*************************************************************
6190 * WineEngGetFontData
6191 *
6192 */
6193 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
6194 DWORD cbData)
6195 {
6196 FT_Face ft_face = font->ft_face;
6197 FT_ULong len;
6198 FT_Error err;
6199
6200 TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
6201 font, LOBYTE(LOWORD(table)), HIBYTE(LOWORD(table)),
6202 LOBYTE(HIWORD(table)), HIBYTE(HIWORD(table)), offset, buf, cbData);
6203
6204 if(!FT_IS_SFNT(ft_face))
6205 return GDI_ERROR;
6206
6207 if(!buf)
6208 len = 0;
6209 else
6210 len = cbData;
6211
6212 if(table) { /* MS tags differ in endianness from FT ones */
6213 table = table >> 24 | table << 24 |
6214 (table >> 8 & 0xff00) | (table << 8 & 0xff0000);
6215 }
6216
6217 /* make sure value of len is the value freetype says it needs */
6218 if(buf && len)
6219 {
6220 FT_ULong needed = 0;
6221 err = load_sfnt_table(ft_face, table, offset, NULL, &needed);
6222 if( !err && needed < len) len = needed;
6223 }
6224 err = load_sfnt_table(ft_face, table, offset, buf, &len);
6225
6226 if(err) {
6227 TRACE("Can't find table %c%c%c%c\n",
6228 /* bytes were reversed */
6229 HIBYTE(HIWORD(table)), LOBYTE(HIWORD(table)),
6230 HIBYTE(LOWORD(table)), LOBYTE(LOWORD(table)));
6231 return GDI_ERROR;
6232 }
6233 return len;
6234 }
6235
6236 /*************************************************************
6237 * WineEngGetTextFace
6238 *
6239 */
6240 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
6241 {
6242 INT n = strlenW(font->name) + 1;
6243 if(str) {
6244 lstrcpynW(str, font->name, count);
6245 return min(count, n);
6246 } else
6247 return n;
6248 }
6249
6250 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
6251 {
6252 if (fs) *fs = font->fs;
6253 return font->charset;
6254 }
6255
6256 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
6257 {
6258 GdiFont *font = dc->gdiFont, *linked_font;
6259 struct list *first_hfont;
6260 BOOL ret;
6261
6262 GDI_CheckNotLock();
6263 EnterCriticalSection( &freetype_cs );
6264 ret = get_glyph_index_linked(font, c, &linked_font, glyph);
6265 TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
6266 if(font == linked_font)
6267 *new_hfont = dc->hFont;
6268 else
6269 {
6270 first_hfont = list_head(&linked_font->hfontlist);
6271 *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
6272 }
6273 LeaveCriticalSection( &freetype_cs );
6274 return ret;
6275 }
6276
6277 /* Retrieve a list of supported Unicode ranges for a given font.
6278 * Can be called with NULL gs to calculate the buffer size. Returns
6279 * the number of ranges found.
6280 */
6281 static DWORD get_font_unicode_ranges(FT_Face face, GLYPHSET *gs)
6282 {
6283 DWORD num_ranges = 0;
6284
6285 if (face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
6286 {
6287 FT_UInt glyph_code;
6288 FT_ULong char_code, char_code_prev;
6289
6290 glyph_code = 0;
6291 char_code_prev = char_code = pFT_Get_First_Char(face, &glyph_code);
6292
6293 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
6294 face->num_glyphs, glyph_code, char_code);
6295
6296 if (!glyph_code) return 0;
6297
6298 if (gs)
6299 {
6300 gs->ranges[0].wcLow = (USHORT)char_code;
6301 gs->ranges[0].cGlyphs = 0;
6302 gs->cGlyphsSupported = 0;
6303 }
6304
6305 num_ranges = 1;
6306 while (glyph_code)
6307 {
6308 if (char_code < char_code_prev)
6309 {
6310 ERR("expected increasing char code from FT_Get_Next_Char\n");
6311 return 0;
6312 }
6313 if (char_code - char_code_prev > 1)
6314 {
6315 num_ranges++;
6316 if (gs)
6317 {
6318 gs->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
6319 gs->ranges[num_ranges - 1].cGlyphs = 1;
6320 gs->cGlyphsSupported++;
6321 }
6322 }
6323 else if (gs)
6324 {
6325 gs->ranges[num_ranges - 1].cGlyphs++;
6326 gs->cGlyphsSupported++;
6327 }
6328 char_code_prev = char_code;
6329 char_code = pFT_Get_Next_Char(face, char_code, &glyph_code);
6330 }
6331 }
6332 else
6333 FIXME("encoding %u not supported\n", face->charmap->encoding);
6334
6335 return num_ranges;
6336 }
6337
6338 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
6339 {
6340 DWORD size = 0;
6341 DWORD num_ranges = get_font_unicode_ranges(font->ft_face, glyphset);
6342
6343 size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
6344 if (glyphset)
6345 {
6346 glyphset->cbThis = size;
6347 glyphset->cRanges = num_ranges;
6348 glyphset->flAccel = 0;
6349 }
6350 return size;
6351 }
6352
6353 /*************************************************************
6354 * FontIsLinked
6355 */
6356 BOOL WineEngFontIsLinked(GdiFont *font)
6357 {
6358 BOOL ret;
6359 GDI_CheckNotLock();
6360 EnterCriticalSection( &freetype_cs );
6361 ret = !list_empty(&font->child_fonts);
6362 LeaveCriticalSection( &freetype_cs );
6363 return ret;
6364 }
6365
6366 static BOOL is_hinting_enabled(void)
6367 {
6368 /* Use the >= 2.2.0 function if available */
6369 if(pFT_Get_TrueType_Engine_Type)
6370 {
6371 FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
6372 return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
6373 }
6374 #ifdef FT_DRIVER_HAS_HINTER
6375 else
6376 {
6377 FT_Module mod;
6378
6379 /* otherwise if we've been compiled with < 2.2.0 headers
6380 use the internal macro */
6381 mod = pFT_Get_Module(library, "truetype");
6382 if(mod && FT_DRIVER_HAS_HINTER(mod))
6383 return TRUE;
6384 }
6385 #endif
6386
6387 return FALSE;
6388 }
6389
6390 static BOOL is_subpixel_rendering_enabled( void )
6391 {
6392 #ifdef HAVE_FREETYPE_FTLCDFIL_H
6393 return pFT_Library_SetLcdFilter &&
6394 pFT_Library_SetLcdFilter( NULL, 0 ) != FT_Err_Unimplemented_Feature;
6395 #else
6396 return FALSE;
6397 #endif
6398 }
6399
6400 /*************************************************************************
6401 * GetRasterizerCaps (GDI32.@)
6402 */
6403 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
6404 {
6405 static int hinting = -1;
6406 static int subpixel = -1;
6407
6408 if(hinting == -1)
6409 {
6410 hinting = is_hinting_enabled();
6411 TRACE("hinting is %senabled\n", hinting ? "" : "NOT ");
6412 }
6413
6414 if ( subpixel == -1 )
6415 {
6416 subpixel = is_subpixel_rendering_enabled();
6417 TRACE("subpixel rendering is %senabled\n", subpixel ? "" : "NOT ");
6418 }
6419
6420 lprs->nSize = sizeof(RASTERIZER_STATUS);
6421 lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
6422 if ( subpixel )
6423 lprs->wFlags |= WINE_TT_SUBPIXEL_RENDERING_ENABLED;
6424 lprs->nLanguageID = 0;
6425 return TRUE;
6426 }
6427
6428 /*************************************************************
6429 * WineEngRealizationInfo
6430 */
6431 BOOL WineEngRealizationInfo(GdiFont *font, realization_info_t *info)
6432 {
6433 FIXME("(%p, %p): stub!\n", font, info);
6434
6435 info->flags = 1;
6436 if(FT_IS_SCALABLE(font->ft_face))
6437 info->flags |= 2;
6438
6439 info->cache_num = font->cache_num;
6440 info->unknown2 = -1;
6441 return TRUE;
6442 }
6443
6444 /*************************************************************************
6445 * Kerning support for TrueType fonts
6446 */
6447 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
6448
6449 struct TT_kern_table
6450 {
6451 USHORT version;
6452 USHORT nTables;
6453 };
6454
6455 struct TT_kern_subtable
6456 {
6457 USHORT version;
6458 USHORT length;
6459 union
6460 {
6461 USHORT word;
6462 struct
6463 {
6464 USHORT horizontal : 1;
6465 USHORT minimum : 1;
6466 USHORT cross_stream: 1;
6467 USHORT override : 1;
6468 USHORT reserved1 : 4;
6469 USHORT format : 8;
6470 } bits;
6471 } coverage;
6472 };
6473
6474 struct TT_format0_kern_subtable
6475 {
6476 USHORT nPairs;
6477 USHORT searchRange;
6478 USHORT entrySelector;
6479 USHORT rangeShift;
6480 };
6481
6482 struct TT_kern_pair
6483 {
6484 USHORT left;
6485 USHORT right;
6486 short value;
6487 };
6488
6489 static DWORD parse_format0_kern_subtable(GdiFont *font,
6490 const struct TT_format0_kern_subtable *tt_f0_ks,
6491 const USHORT *glyph_to_char,
6492 KERNINGPAIR *kern_pair, DWORD cPairs)
6493 {
6494 USHORT i, nPairs;
6495 const struct TT_kern_pair *tt_kern_pair;
6496
6497 TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
6498
6499 nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
6500
6501 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
6502 nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
6503 GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
6504
6505 if (!kern_pair || !cPairs)
6506 return nPairs;
6507
6508 tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
6509
6510 nPairs = min(nPairs, cPairs);
6511
6512 for (i = 0; i < nPairs; i++)
6513 {
6514 kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
6515 kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
6516 /* this algorithm appears to better match what Windows does */
6517 kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
6518 if (kern_pair->iKernAmount < 0)
6519 {
6520 kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
6521 kern_pair->iKernAmount -= font->ppem;
6522 }
6523 else if (kern_pair->iKernAmount > 0)
6524 {
6525 kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
6526 kern_pair->iKernAmount += font->ppem;
6527 }
6528 kern_pair->iKernAmount /= font->ft_face->units_per_EM;
6529
6530 TRACE("left %u right %u value %d\n",
6531 kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
6532
6533 kern_pair++;
6534 }
6535 TRACE("copied %u entries\n", nPairs);
6536 return nPairs;
6537 }
6538
6539 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
6540 {
6541 DWORD length;
6542 void *buf;
6543 const struct TT_kern_table *tt_kern_table;
6544 const struct TT_kern_subtable *tt_kern_subtable;
6545 USHORT i, nTables;
6546 USHORT *glyph_to_char;
6547
6548 GDI_CheckNotLock();
6549 EnterCriticalSection( &freetype_cs );
6550 if (font->total_kern_pairs != (DWORD)-1)
6551 {
6552 if (cPairs && kern_pair)
6553 {
6554 cPairs = min(cPairs, font->total_kern_pairs);
6555 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
6556 LeaveCriticalSection( &freetype_cs );
6557 return cPairs;
6558 }
6559 LeaveCriticalSection( &freetype_cs );
6560 return font->total_kern_pairs;
6561 }
6562
6563 font->total_kern_pairs = 0;
6564
6565 length = WineEngGetFontData(font, MS_KERN_TAG, 0, NULL, 0);
6566
6567 if (length == GDI_ERROR)
6568 {
6569 TRACE("no kerning data in the font\n");
6570 LeaveCriticalSection( &freetype_cs );
6571 return 0;
6572 }
6573
6574 buf = HeapAlloc(GetProcessHeap(), 0, length);
6575 if (!buf)
6576 {
6577 WARN("Out of memory\n");
6578 LeaveCriticalSection( &freetype_cs );
6579 return 0;
6580 }
6581
6582 WineEngGetFontData(font, MS_KERN_TAG, 0, buf, length);
6583
6584 /* build a glyph index to char code map */
6585 glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
6586 if (!glyph_to_char)
6587 {
6588 WARN("Out of memory allocating a glyph index to char code map\n");
6589 HeapFree(GetProcessHeap(), 0, buf);
6590 LeaveCriticalSection( &freetype_cs );
6591 return 0;
6592 }
6593
6594 if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
6595 {
6596 FT_UInt glyph_code;
6597 FT_ULong char_code;
6598
6599 glyph_code = 0;
6600 char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
6601
6602 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
6603 font->ft_face->num_glyphs, glyph_code, char_code);
6604
6605 while (glyph_code)
6606 {
6607 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
6608
6609 /* FIXME: This doesn't match what Windows does: it does some fancy
6610 * things with duplicate glyph index to char code mappings, while
6611 * we just avoid overriding existing entries.
6612 */
6613 if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
6614 glyph_to_char[glyph_code] = (USHORT)char_code;
6615
6616 char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
6617 }
6618 }
6619 else
6620 {
6621 ULONG n;
6622
6623 FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
6624 for (n = 0; n <= 65535; n++)
6625 glyph_to_char[n] = (USHORT)n;
6626 }
6627
6628 tt_kern_table = buf;
6629 nTables = GET_BE_WORD(tt_kern_table->nTables);
6630 TRACE("version %u, nTables %u\n",
6631 GET_BE_WORD(tt_kern_table->version), nTables);
6632
6633 tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
6634
6635 for (i = 0; i < nTables; i++)
6636 {
6637 struct TT_kern_subtable tt_kern_subtable_copy;
6638
6639 tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
6640 tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
6641 tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
6642
6643 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
6644 tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
6645 tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
6646
6647 /* According to the TrueType specification this is the only format
6648 * that will be properly interpreted by Windows and OS/2
6649 */
6650 if (tt_kern_subtable_copy.coverage.bits.format == 0)
6651 {
6652 DWORD new_chunk, old_total = font->total_kern_pairs;
6653
6654 new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
6655 glyph_to_char, NULL, 0);
6656 font->total_kern_pairs += new_chunk;
6657
6658 if (!font->kern_pairs)
6659 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
6660 font->total_kern_pairs * sizeof(*font->kern_pairs));
6661 else
6662 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
6663 font->total_kern_pairs * sizeof(*font->kern_pairs));
6664
6665 parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
6666 glyph_to_char, font->kern_pairs + old_total, new_chunk);
6667 }
6668 else
6669 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
6670
6671 tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
6672 }
6673
6674 HeapFree(GetProcessHeap(), 0, glyph_to_char);
6675 HeapFree(GetProcessHeap(), 0, buf);
6676
6677 if (cPairs && kern_pair)
6678 {
6679 cPairs = min(cPairs, font->total_kern_pairs);
6680 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
6681 LeaveCriticalSection( &freetype_cs );
6682 return cPairs;
6683 }
6684 LeaveCriticalSection( &freetype_cs );
6685 return font->total_kern_pairs;
6686 }
6687
6688 #else /* HAVE_FREETYPE */
6689
6690 /*************************************************************************/
6691
6692 BOOL WineEngInit(void)
6693 {
6694 return FALSE;
6695 }
6696 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
6697 {
6698 return NULL;
6699 }
6700 BOOL WineEngDestroyFontInstance(HFONT hfont)
6701 {
6702 return FALSE;
6703 }
6704
6705 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
6706 {
6707 return 1;
6708 }
6709
6710 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
6711 LPWORD pgi, DWORD flags)
6712 {
6713 return GDI_ERROR;
6714 }
6715
6716 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
6717 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
6718 const MAT2* lpmat)
6719 {
6720 ERR("called but we don't have FreeType\n");
6721 return GDI_ERROR;
6722 }
6723
6724 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
6725 {
6726 ERR("called but we don't have FreeType\n");
6727 return FALSE;
6728 }
6729
6730 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
6731 OUTLINETEXTMETRICW *potm)
6732 {
6733 ERR("called but we don't have FreeType\n");
6734 return 0;
6735 }
6736
6737 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
6738 LPINT buffer)
6739 {
6740 ERR("called but we don't have FreeType\n");
6741 return FALSE;
6742 }
6743
6744 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
6745 LPABC buffer)
6746 {
6747 ERR("called but we don't have FreeType\n");
6748 return FALSE;
6749 }
6750
6751 BOOL WineEngGetCharABCWidthsFloat(GdiFont *font, UINT first, UINT last, LPABCFLOAT buffer)
6752 {
6753 ERR("called but we don't have FreeType\n");
6754 return FALSE;
6755 }
6756
6757 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
6758 LPABC buffer)
6759 {
6760 ERR("called but we don't have FreeType\n");
6761 return FALSE;
6762 }
6763
6764 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
6765 INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
6766 {
6767 ERR("called but we don't have FreeType\n");
6768 return FALSE;
6769 }
6770
6771 BOOL WineEngGetTextExtentExPointI(GdiFont *font, const WORD *indices, INT count,
6772 INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
6773 {
6774 ERR("called but we don't have FreeType\n");
6775 return FALSE;
6776 }
6777
6778 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
6779 DWORD cbData)
6780 {
6781 ERR("called but we don't have FreeType\n");
6782 return GDI_ERROR;
6783 }
6784
6785 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
6786 {
6787 ERR("called but we don't have FreeType\n");
6788 return 0;
6789 }
6790
6791 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
6792 {
6793 FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
6794 return 1;
6795 }
6796
6797 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
6798 {
6799 FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
6800 return TRUE;
6801 }
6802
6803 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
6804 {
6805 FIXME("(%p, %u, %p, %p): stub\n", pbFont, cbFont, pdv, pcFonts);
6806 return NULL;
6807 }
6808
6809 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
6810 {
6811 FIXME("(%p, %p, %u): stub\n", font, fs, flags);
6812 return DEFAULT_CHARSET;
6813 }
6814
6815 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
6816 {
6817 return FALSE;
6818 }
6819
6820 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
6821 {
6822 FIXME("(%p, %p): stub\n", font, glyphset);
6823 return 0;
6824 }
6825
6826 BOOL WineEngFontIsLinked(GdiFont *font)
6827 {
6828 return FALSE;
6829 }
6830
6831 /*************************************************************************
6832 * GetRasterizerCaps (GDI32.@)
6833 */
6834 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
6835 {
6836 lprs->nSize = sizeof(RASTERIZER_STATUS);
6837 lprs->wFlags = 0;
6838 lprs->nLanguageID = 0;
6839 return TRUE;
6840 }
6841
6842 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
6843 {
6844 ERR("called but we don't have FreeType\n");
6845 return 0;
6846 }
6847
6848 BOOL WineEngRealizationInfo(GdiFont *font, realization_info_t *info)
6849 {
6850 ERR("called but we don't have FreeType\n");
6851 return FALSE;
6852 }
6853
6854 #endif /* HAVE_FREETYPE */
Maarten's multimedia branch