?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d9: Initialize the test rectangle correctly.
[wine/multimedia.git] / dlls / gdi32 / freetype.c
bloba79f41d8b86e752d3655c7978d734a4441d00ef0
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 #include <dirent.h>
37 #include <stdio.h>
38 #include <assert.h>
39
40 #ifdef HAVE_CARBON_CARBON_H
41 #define LoadResource __carbon_LoadResource
42 #define CompareString __carbon_CompareString
43 #define GetCurrentThread __carbon_GetCurrentThread
44 #define GetCurrentProcess __carbon_GetCurrentProcess
45 #define AnimatePalette __carbon_AnimatePalette
46 #define EqualRgn __carbon_EqualRgn
47 #define FillRgn __carbon_FillRgn
48 #define FrameRgn __carbon_FrameRgn
49 #define GetPixel __carbon_GetPixel
50 #define InvertRgn __carbon_InvertRgn
51 #define LineTo __carbon_LineTo
52 #define OffsetRgn __carbon_OffsetRgn
53 #define PaintRgn __carbon_PaintRgn
54 #define Polygon __carbon_Polygon
55 #define ResizePalette __carbon_ResizePalette
56 #define SetRectRgn __carbon_SetRectRgn
57 #include <Carbon/Carbon.h>
58 #undef LoadResource
59 #undef CompareString
60 #undef GetCurrentThread
61 #undef _CDECL
62 #undef DPRINTF
63 #undef GetCurrentProcess
64 #undef AnimatePalette
65 #undef EqualRgn
66 #undef FillRgn
67 #undef FrameRgn
68 #undef GetPixel
69 #undef InvertRgn
70 #undef LineTo
71 #undef OffsetRgn
72 #undef PaintRgn
73 #undef Polygon
74 #undef ResizePalette
75 #undef SetRectRgn
76 #endif /* HAVE_CARBON_CARBON_H */
77
78 #include "windef.h"
79 #include "winbase.h"
80 #include "winternl.h"
81 #include "winerror.h"
82 #include "winreg.h"
83 #include "wingdi.h"
84 #include "gdi_private.h"
85 #include "wine/unicode.h"
86 #include "wine/debug.h"
87 #include "wine/list.h"
88
89 WINE_DEFAULT_DEBUG_CHANNEL(font);
90
91 #ifdef HAVE_FREETYPE
92
93 #ifdef HAVE_FT2BUILD_H
94 #include <ft2build.h>
95 #endif
96 #ifdef HAVE_FREETYPE_FREETYPE_H
97 #include <freetype/freetype.h>
98 #endif
99 #ifdef HAVE_FREETYPE_FTGLYPH_H
100 #include <freetype/ftglyph.h>
101 #endif
102 #ifdef HAVE_FREETYPE_TTTABLES_H
103 #include <freetype/tttables.h>
104 #endif
105 #ifdef HAVE_FREETYPE_FTTYPES_H
106 #include <freetype/fttypes.h>
107 #endif
108 #ifdef HAVE_FREETYPE_FTSNAMES_H
109 #include <freetype/ftsnames.h>
110 #else
111 # ifdef HAVE_FREETYPE_FTNAMES_H
112 # include <freetype/ftnames.h>
113 # endif
114 #endif
115 #ifdef HAVE_FREETYPE_TTNAMEID_H
116 #include <freetype/ttnameid.h>
117 #endif
118 #ifdef HAVE_FREETYPE_FTOUTLN_H
119 #include <freetype/ftoutln.h>
120 #endif
121 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
122 #include <freetype/internal/sfnt.h>
123 #endif
124 #ifdef HAVE_FREETYPE_FTTRIGON_H
125 #include <freetype/fttrigon.h>
126 #endif
127 #ifdef HAVE_FREETYPE_FTWINFNT_H
128 #include <freetype/ftwinfnt.h>
129 #endif
130 #ifdef HAVE_FREETYPE_FTMODAPI_H
131 #include <freetype/ftmodapi.h>
132 #endif
133
134 #ifndef HAVE_FT_TRUETYPEENGINETYPE
135 typedef enum
136 {
137 FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
138 FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
139 FT_TRUETYPE_ENGINE_TYPE_PATENTED
140 } FT_TrueTypeEngineType;
141 #endif
142
143 static FT_Library library = 0;
144 typedef struct
145 {
146 FT_Int major;
147 FT_Int minor;
148 FT_Int patch;
149 } FT_Version_t;
150 static FT_Version_t FT_Version;
151 static DWORD FT_SimpleVersion;
152
153 static void *ft_handle = NULL;
154
155 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
156 MAKE_FUNCPTR(FT_Vector_Unit);
157 MAKE_FUNCPTR(FT_Done_Face);
158 MAKE_FUNCPTR(FT_Get_Char_Index);
159 MAKE_FUNCPTR(FT_Get_Module);
160 MAKE_FUNCPTR(FT_Get_Sfnt_Name);
161 MAKE_FUNCPTR(FT_Get_Sfnt_Name_Count);
162 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
163 MAKE_FUNCPTR(FT_Init_FreeType);
164 MAKE_FUNCPTR(FT_Load_Glyph);
165 MAKE_FUNCPTR(FT_Matrix_Multiply);
166 MAKE_FUNCPTR(FT_MulFix);
167 MAKE_FUNCPTR(FT_New_Face);
168 MAKE_FUNCPTR(FT_New_Memory_Face);
169 MAKE_FUNCPTR(FT_Outline_Get_Bitmap);
170 MAKE_FUNCPTR(FT_Outline_Transform);
171 MAKE_FUNCPTR(FT_Outline_Translate);
172 MAKE_FUNCPTR(FT_Select_Charmap);
173 MAKE_FUNCPTR(FT_Set_Charmap);
174 MAKE_FUNCPTR(FT_Set_Pixel_Sizes);
175 MAKE_FUNCPTR(FT_Vector_Transform);
176 static void (*pFT_Library_Version)(FT_Library,FT_Int*,FT_Int*,FT_Int*);
177 static FT_Error (*pFT_Load_Sfnt_Table)(FT_Face,FT_ULong,FT_Long,FT_Byte*,FT_ULong*);
178 static FT_ULong (*pFT_Get_First_Char)(FT_Face,FT_UInt*);
179 static FT_ULong (*pFT_Get_Next_Char)(FT_Face,FT_ULong,FT_UInt*);
180 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type)(FT_Library);
181 #ifdef HAVE_FREETYPE_FTWINFNT_H
182 MAKE_FUNCPTR(FT_Get_WinFNT_Header);
183 #endif
184
185 #ifdef SONAME_LIBFONTCONFIG
186 #include <fontconfig/fontconfig.h>
187 MAKE_FUNCPTR(FcConfigGetCurrent);
188 MAKE_FUNCPTR(FcFontList);
189 MAKE_FUNCPTR(FcFontSetDestroy);
190 MAKE_FUNCPTR(FcInit);
191 MAKE_FUNCPTR(FcObjectSetAdd);
192 MAKE_FUNCPTR(FcObjectSetCreate);
193 MAKE_FUNCPTR(FcObjectSetDestroy);
194 MAKE_FUNCPTR(FcPatternCreate);
195 MAKE_FUNCPTR(FcPatternDestroy);
196 MAKE_FUNCPTR(FcPatternGetBool);
197 MAKE_FUNCPTR(FcPatternGetString);
198 #endif
199
200 #undef MAKE_FUNCPTR
201
202 #ifndef FT_MAKE_TAG
203 #define FT_MAKE_TAG( ch0, ch1, ch2, ch3 ) \
204 ( ((DWORD)(BYTE)(ch0) << 24) | ((DWORD)(BYTE)(ch1) << 16) | \
205 ((DWORD)(BYTE)(ch2) << 8) | (DWORD)(BYTE)(ch3) )
206 #endif
207
208 #ifndef ft_encoding_none
209 #define FT_ENCODING_NONE ft_encoding_none
210 #endif
211 #ifndef ft_encoding_ms_symbol
212 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
213 #endif
214 #ifndef ft_encoding_unicode
215 #define FT_ENCODING_UNICODE ft_encoding_unicode
216 #endif
217 #ifndef ft_encoding_apple_roman
218 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
219 #endif
220
221 #ifdef WORDS_BIGENDIAN
222 #define GET_BE_WORD(x) (x)
223 #else
224 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
225 #endif
226
227 /* This is bascially a copy of FT_Bitmap_Size with an extra element added */
228 typedef struct {
229 FT_Short height;
230 FT_Short width;
231 FT_Pos size;
232 FT_Pos x_ppem;
233 FT_Pos y_ppem;
234 FT_Short internal_leading;
235 } Bitmap_Size;
236
237 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
238 So to let this compile on older versions of FreeType we'll define the
239 new structure here. */
240 typedef struct {
241 FT_Short height, width;
242 FT_Pos size, x_ppem, y_ppem;
243 } My_FT_Bitmap_Size;
244
245 typedef struct tagFace {
246 struct list entry;
247 WCHAR *StyleName;
248 char *file;
249 void *font_data_ptr;
250 DWORD font_data_size;
251 FT_Long face_index;
252 BOOL Italic;
253 BOOL Bold;
254 FONTSIGNATURE fs;
255 FONTSIGNATURE fs_links;
256 DWORD ntmFlags; /* Only some bits stored here. Others are computed on the fly */
257 FT_Fixed font_version;
258 BOOL scalable;
259 Bitmap_Size size; /* set if face is a bitmap */
260 BOOL external; /* TRUE if we should manually add this font to the registry */
261 struct tagFamily *family;
262 } Face;
263
264 typedef struct tagFamily {
265 struct list entry;
266 const WCHAR *FamilyName;
267 struct list faces;
268 } Family;
269
270 typedef struct {
271 GLYPHMETRICS gm;
272 INT adv; /* These three hold to widths of the unrotated chars */
273 INT lsb;
274 INT bbx;
275 BOOL init;
276 } GM;
277
278 typedef struct {
279 FLOAT eM11, eM12;
280 FLOAT eM21, eM22;
281 } FMAT2;
282
283 typedef struct {
284 DWORD hash;
285 LOGFONTW lf;
286 FMAT2 matrix;
287 BOOL can_use_bitmap;
288 } FONT_DESC;
289
290 typedef struct tagHFONTLIST {
291 struct list entry;
292 HFONT hfont;
293 } HFONTLIST;
294
295 typedef struct {
296 struct list entry;
297 Face *face;
298 GdiFont *font;
299 } CHILD_FONT;
300
301 struct tagGdiFont {
302 struct list entry;
303 FT_Face ft_face;
304 struct font_mapping *mapping;
305 LPWSTR name;
306 int charset;
307 int codepage;
308 BOOL fake_italic;
309 BOOL fake_bold;
310 BYTE underline;
311 BYTE strikeout;
312 INT orientation;
313 GM **gm;
314 DWORD gmsize;
315 struct list hfontlist;
316 FONT_DESC font_desc;
317 LONG aveWidth;
318 SHORT yMax;
319 SHORT yMin;
320 OUTLINETEXTMETRICW *potm;
321 DWORD ntmFlags;
322 DWORD total_kern_pairs;
323 KERNINGPAIR *kern_pairs;
324 FONTSIGNATURE fs;
325 GdiFont *base_font;
326 struct list child_fonts;
327 LONG ppem;
328 };
329
330 typedef struct {
331 struct list entry;
332 const WCHAR *font_name;
333 struct list links;
334 } SYSTEM_LINKS;
335
336 #define GM_BLOCK_SIZE 128
337 #define FONT_GM(font,idx) (&(font)->gm[(idx) / GM_BLOCK_SIZE][(idx) % GM_BLOCK_SIZE])
338
339 static struct list gdi_font_list = LIST_INIT(gdi_font_list);
340 static struct list unused_gdi_font_list = LIST_INIT(unused_gdi_font_list);
341 #define UNUSED_CACHE_SIZE 10
342 static struct list child_font_list = LIST_INIT(child_font_list);
343 static struct list system_links = LIST_INIT(system_links);
344
345 static struct list font_subst_list = LIST_INIT(font_subst_list);
346
347 static struct list font_list = LIST_INIT(font_list);
348
349 static const WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
350 static const WCHAR defSans[] = {'A','r','i','a','l','\0'};
351 static const WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
352
353 static const WCHAR RegularW[] = {'R','e','g','u','l','a','r','\0'};
354
355 static const WCHAR fontsW[] = {'\\','f','o','n','t','s','\0'};
356 static const WCHAR win9x_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
357 'W','i','n','d','o','w','s','\\',
358 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
359 'F','o','n','t','s','\0'};
360
361 static const WCHAR winnt_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
362 'W','i','n','d','o','w','s',' ','N','T','\\',
363 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
364 'F','o','n','t','s','\0'};
365
366 static const WCHAR system_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
367 static const WCHAR FixedSys_Value[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
368 static const WCHAR System_Value[] = {'F','O','N','T','S','.','F','O','N','\0'};
369 static const WCHAR OEMFont_Value[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
370
371 static const WCHAR * const SystemFontValues[4] = {
372 System_Value,
373 OEMFont_Value,
374 FixedSys_Value,
375 NULL
376 };
377
378 static const WCHAR external_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
379 'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
380
381 static const WCHAR ArabicW[] = {'A','r','a','b','i','c','\0'};
382 static const WCHAR BalticW[] = {'B','a','l','t','i','c','\0'};
383 static const WCHAR CHINESE_BIG5W[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
384 static const WCHAR CHINESE_GB2312W[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
385 static const WCHAR Central_EuropeanW[] = {'C','e','n','t','r','a','l',' ',
386 'E','u','r','o','p','e','a','n','\0'};
387 static const WCHAR CyrillicW[] = {'C','y','r','i','l','l','i','c','\0'};
388 static const WCHAR GreekW[] = {'G','r','e','e','k','\0'};
389 static const WCHAR HangulW[] = {'H','a','n','g','u','l','\0'};
390 static const WCHAR Hangul_Johab_W[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
391 static const WCHAR HebrewW[] = {'H','e','b','r','e','w','\0'};
392 static const WCHAR JapaneseW[] = {'J','a','p','a','n','e','s','e','\0'};
393 static const WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
394 static const WCHAR ThaiW[] = {'T','h','a','i','\0'};
395 static const WCHAR TurkishW[] = {'T','u','r','k','i','s','h','\0'};
396 static const WCHAR VietnameseW[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
397 static const WCHAR WesternW[] = {'W','e','s','t','e','r','n','\0'};
398 static const WCHAR OEM_DOSW[] = {'O','E','M','/','D','O','S','\0'};
399
400 static const WCHAR * const ElfScriptsW[32] = { /* these are in the order of the fsCsb[0] bits */
401 WesternW, /*00*/
402 Central_EuropeanW,
403 CyrillicW,
404 GreekW,
405 TurkishW,
406 HebrewW,
407 ArabicW,
408 BalticW,
409 VietnameseW, /*08*/
410 NULL, NULL, NULL, NULL, NULL, NULL, NULL, /*15*/
411 ThaiW,
412 JapaneseW,
413 CHINESE_GB2312W,
414 HangulW,
415 CHINESE_BIG5W,
416 Hangul_Johab_W,
417 NULL, NULL, /*23*/
418 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
419 SymbolW /*31*/
420 };
421
422 typedef struct {
423 WCHAR *name;
424 INT charset;
425 } NameCs;
426
427 typedef struct tagFontSubst {
428 struct list entry;
429 NameCs from;
430 NameCs to;
431 } FontSubst;
432
433 struct font_mapping
434 {
435 struct list entry;
436 int refcount;
437 dev_t dev;
438 ino_t ino;
439 void *data;
440 size_t size;
441 };
442
443 static struct list mappings_list = LIST_INIT( mappings_list );
444
445 static BOOL have_installed_roman_font = FALSE; /* CreateFontInstance will fail if this is still FALSE */
446
447 static const WCHAR font_mutex_nameW[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
448
449 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph);
450
451 /****************************************
452 * Notes on .fon files
453 *
454 * The fonts System, FixedSys and Terminal are special. There are typically multiple
455 * versions installed for different resolutions and codepages. Windows stores which one to use
456 * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
457 * Key Meaning
458 * FIXEDFON.FON FixedSys
459 * FONTS.FON System
460 * OEMFONT.FON Terminal
461 * LogPixels Current dpi set by the display control panel applet
462 * (HKLM\\Software\\Microsft\\Windows NT\\CurrentVersion\\FontDPI
463 * also has a LogPixels value that appears to mirror this)
464 *
465 * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
466 * (vgaoem.fon would be your oemfont.fon if you have a US setup).
467 * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
468 * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
469 * so that makes sense.
470 *
471 * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
472 * to be mapped into the registry on Windows 2000 at least).
473 * I have
474 * woafont=app850.fon
475 * ega80woa.fon=ega80850.fon
476 * ega40woa.fon=ega40850.fon
477 * cga80woa.fon=cga80850.fon
478 * cga40woa.fon=cga40850.fon
479 */
480
481 #ifdef HAVE_CARBON_CARBON_H
482 static char *find_cache_dir(void)
483 {
484 FSRef ref;
485 OSErr err;
486 static char cached_path[MAX_PATH];
487 static const char *wine = "/Wine", *fonts = "/Fonts";
488
489 if(*cached_path) return cached_path;
490
491 err = FSFindFolder(kUserDomain, kCachedDataFolderType, kCreateFolder, &ref);
492 if(err != noErr)
493 {
494 WARN("can't create cached data folder\n");
495 return NULL;
496 }
497 err = FSRefMakePath(&ref, (unsigned char*)cached_path, sizeof(cached_path));
498 if(err != noErr)
499 {
500 WARN("can't create cached data path\n");
501 *cached_path = '\0';
502 return NULL;
503 }
504 if(strlen(cached_path) + strlen(wine) + strlen(fonts) + 1 > sizeof(cached_path))
505 {
506 ERR("Could not create full path\n");
507 *cached_path = '\0';
508 return NULL;
509 }
510 strcat(cached_path, wine);
511
512 if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
513 {
514 WARN("Couldn't mkdir %s\n", cached_path);
515 *cached_path = '\0';
516 return NULL;
517 }
518 strcat(cached_path, fonts);
519 if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
520 {
521 WARN("Couldn't mkdir %s\n", cached_path);
522 *cached_path = '\0';
523 return NULL;
524 }
525 return cached_path;
526 }
527
528 /******************************************************************
529 * expand_mac_font
530 *
531 * Extracts individual TrueType font files from a Mac suitcase font
532 * and saves them into the user's caches directory (see
533 * find_cache_dir()).
534 * Returns a NULL terminated array of filenames.
535 *
536 * We do this because they are apps that try to read ttf files
537 * themselves and they don't like Mac suitcase files.
538 */
539 static char **expand_mac_font(const char *path)
540 {
541 FSRef ref;
542 SInt16 res_ref;
543 OSStatus s;
544 unsigned int idx;
545 const char *out_dir;
546 const char *filename;
547 int output_len;
548 struct {
549 char **array;
550 unsigned int size, max_size;
551 } ret;
552
553 TRACE("path %s\n", path);
554
555 s = FSPathMakeRef((unsigned char*)path, &ref, FALSE);
556 if(s != noErr)
557 {
558 WARN("failed to get ref\n");
559 return NULL;
560 }
561
562 s = FSOpenResourceFile(&ref, 0, NULL, fsRdPerm, &res_ref);
563 if(s != noErr)
564 {
565 TRACE("no data fork, so trying resource fork\n");
566 res_ref = FSOpenResFile(&ref, fsRdPerm);
567 if(res_ref == -1)
568 {
569 TRACE("unable to open resource fork\n");
570 return NULL;
571 }
572 }
573
574 ret.size = 0;
575 ret.max_size = 10;
576 ret.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.max_size * sizeof(*ret.array));
577 if(!ret.array)
578 {
579 CloseResFile(res_ref);
580 return NULL;
581 }
582
583 out_dir = find_cache_dir();
584
585 filename = strrchr(path, '/');
586 if(!filename) filename = path;
587 else filename++;
588
589 /* output filename has the form out_dir/filename_%04x.ttf */
590 output_len = strlen(out_dir) + 1 + strlen(filename) + 5 + 5;
591
592 UseResFile(res_ref);
593 idx = 1;
594 while(1)
595 {
596 FamRec *fam_rec;
597 unsigned short *num_faces_ptr, num_faces, face;
598 AsscEntry *assoc;
599 Handle fond;
600 ResType fond_res = FT_MAKE_TAG('F','O','N','D');
601
602 fond = Get1IndResource(fond_res, idx);
603 if(!fond) break;
604 TRACE("got fond resource %d\n", idx);
605 HLock(fond);
606
607 fam_rec = *(FamRec**)fond;
608 num_faces_ptr = (unsigned short *)(fam_rec + 1);
609 num_faces = GET_BE_WORD(*num_faces_ptr);
610 num_faces++;
611 assoc = (AsscEntry*)(num_faces_ptr + 1);
612 TRACE("num faces %04x\n", num_faces);
613 for(face = 0; face < num_faces; face++, assoc++)
614 {
615 Handle sfnt;
616 ResType sfnt_res = FT_MAKE_TAG('s','f','n','t');
617 unsigned short size, font_id;
618 char *output;
619
620 size = GET_BE_WORD(assoc->fontSize);
621 font_id = GET_BE_WORD(assoc->fontID);
622 if(size != 0)
623 {
624 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id, size);
625 continue;
626 }
627
628 TRACE("trying to load sfnt id %04x\n", font_id);
629 sfnt = GetResource(sfnt_res, font_id);
630 if(!sfnt)
631 {
632 TRACE("can't get sfnt resource %04x\n", font_id);
633 continue;
634 }
635
636 output = HeapAlloc(GetProcessHeap(), 0, output_len);
637 if(output)
638 {
639 int fd;
640
641 sprintf(output, "%s/%s_%04x.ttf", out_dir, filename, font_id);
642
643 fd = open(output, O_CREAT | O_EXCL | O_WRONLY, 0600);
644 if(fd != -1 || errno == EEXIST)
645 {
646 if(fd != -1)
647 {
648 unsigned char *sfnt_data;
649
650 HLock(sfnt);
651 sfnt_data = *(unsigned char**)sfnt;
652 write(fd, sfnt_data, GetHandleSize(sfnt));
653 HUnlock(sfnt);
654 close(fd);
655 }
656 if(ret.size >= ret.max_size - 1) /* Always want the last element to be NULL */
657 {
658 ret.max_size *= 2;
659 ret.array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.array, ret.max_size * sizeof(*ret.array));
660 }
661 ret.array[ret.size++] = output;
662 }
663 else
664 {
665 WARN("unable to create %s\n", output);
666 HeapFree(GetProcessHeap(), 0, output);
667 }
668 }
669 ReleaseResource(sfnt);
670 }
671 HUnlock(fond);
672 ReleaseResource(fond);
673 idx++;
674 }
675 CloseResFile(res_ref);
676
677 return ret.array;
678 }
679
680 #endif /* HAVE_CARBON_CARBON_H */
681
682 static inline BOOL is_win9x(void)
683 {
684 return GetVersion() & 0x80000000;
685 }
686 /*
687 This function builds an FT_Fixed from a float. It puts the integer part
688 in the highest 16 bits and the decimal part in the lowest 16 bits of the FT_Fixed.
689 It fails if the integer part of the float number is greater than SHORT_MAX.
690 */
691 static inline FT_Fixed FT_FixedFromFloat(float f)
692 {
693 short value = f;
694 unsigned short fract = (f - value) * 0xFFFF;
695 return (FT_Fixed)((long)value << 16 | (unsigned long)fract);
696 }
697
698 /*
699 This function builds an FT_Fixed from a FIXED. It simply put f.value
700 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
701 */
702 static inline FT_Fixed FT_FixedFromFIXED(FIXED f)
703 {
704 return (FT_Fixed)((long)f.value << 16 | (unsigned long)f.fract);
705 }
706
707
708 static Face *find_face_from_filename(const WCHAR *file_name, const WCHAR *face_name)
709 {
710 Family *family;
711 Face *face;
712 const char *file;
713 DWORD len = WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, NULL, 0, NULL, NULL);
714 char *file_nameA = HeapAlloc(GetProcessHeap(), 0, len);
715
716 WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, file_nameA, len, NULL, NULL);
717 TRACE("looking for file %s name %s\n", debugstr_a(file_nameA), debugstr_w(face_name));
718
719 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
720 {
721 if(face_name && strcmpiW(face_name, family->FamilyName))
722 continue;
723 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
724 {
725 if (!face->file)
726 continue;
727 file = strrchr(face->file, '/');
728 if(!file)
729 file = face->file;
730 else
731 file++;
732 if(!strcasecmp(file, file_nameA))
733 {
734 HeapFree(GetProcessHeap(), 0, file_nameA);
735 return face;
736 }
737 }
738 }
739 HeapFree(GetProcessHeap(), 0, file_nameA);
740 return NULL;
741 }
742
743 static Family *find_family_from_name(const WCHAR *name)
744 {
745 Family *family;
746
747 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
748 {
749 if(!strcmpiW(family->FamilyName, name))
750 return family;
751 }
752
753 return NULL;
754 }
755
756 static void DumpSubstList(void)
757 {
758 FontSubst *psub;
759
760 LIST_FOR_EACH_ENTRY(psub, &font_subst_list, FontSubst, entry)
761 {
762 if(psub->from.charset != -1 || psub->to.charset != -1)
763 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
764 psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
765 else
766 TRACE("%s -> %s\n", debugstr_w(psub->from.name),
767 debugstr_w(psub->to.name));
768 }
769 return;
770 }
771
772 static LPWSTR strdupW(LPCWSTR p)
773 {
774 LPWSTR ret;
775 DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
776 ret = HeapAlloc(GetProcessHeap(), 0, len);
777 memcpy(ret, p, len);
778 return ret;
779 }
780
781 static LPSTR strdupA(LPCSTR p)
782 {
783 LPSTR ret;
784 DWORD len = (strlen(p) + 1);
785 ret = HeapAlloc(GetProcessHeap(), 0, len);
786 memcpy(ret, p, len);
787 return ret;
788 }
789
790 static FontSubst *get_font_subst(const struct list *subst_list, const WCHAR *from_name,
791 INT from_charset)
792 {
793 FontSubst *element;
794
795 LIST_FOR_EACH_ENTRY(element, subst_list, FontSubst, entry)
796 {
797 if(!strcmpiW(element->from.name, from_name) &&
798 (element->from.charset == from_charset ||
799 element->from.charset == -1))
800 return element;
801 }
802
803 return NULL;
804 }
805
806 #define ADD_FONT_SUBST_FORCE 1
807
808 static BOOL add_font_subst(struct list *subst_list, FontSubst *subst, INT flags)
809 {
810 FontSubst *from_exist, *to_exist;
811
812 from_exist = get_font_subst(subst_list, subst->from.name, subst->from.charset);
813
814 if(from_exist && (flags & ADD_FONT_SUBST_FORCE))
815 {
816 list_remove(&from_exist->entry);
817 HeapFree(GetProcessHeap(), 0, &from_exist->from.name);
818 HeapFree(GetProcessHeap(), 0, &from_exist->to.name);
819 HeapFree(GetProcessHeap(), 0, from_exist);
820 from_exist = NULL;
821 }
822
823 if(!from_exist)
824 {
825 to_exist = get_font_subst(subst_list, subst->to.name, subst->to.charset);
826
827 if(to_exist)
828 {
829 HeapFree(GetProcessHeap(), 0, subst->to.name);
830 subst->to.name = strdupW(to_exist->to.name);
831 }
832
833 list_add_tail(subst_list, &subst->entry);
834
835 return TRUE;
836 }
837
838 HeapFree(GetProcessHeap(), 0, subst->from.name);
839 HeapFree(GetProcessHeap(), 0, subst->to.name);
840 HeapFree(GetProcessHeap(), 0, subst);
841 return FALSE;
842 }
843
844 static void split_subst_info(NameCs *nc, LPSTR str)
845 {
846 CHAR *p = strrchr(str, ',');
847 DWORD len;
848
849 nc->charset = -1;
850 if(p && *(p+1)) {
851 nc->charset = strtol(p+1, NULL, 10);
852 *p = '\0';
853 }
854 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
855 nc->name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
856 MultiByteToWideChar(CP_ACP, 0, str, -1, nc->name, len);
857 }
858
859 static void LoadSubstList(void)
860 {
861 FontSubst *psub;
862 HKEY hkey;
863 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
864 LPSTR value;
865 LPVOID data;
866
867 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
868 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
869 &hkey) == ERROR_SUCCESS) {
870
871 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
872 &valuelen, &datalen, NULL, NULL);
873
874 valuelen++; /* returned value doesn't include room for '\0' */
875 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
876 data = HeapAlloc(GetProcessHeap(), 0, datalen);
877
878 dlen = datalen;
879 vlen = valuelen;
880 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
881 &dlen) == ERROR_SUCCESS) {
882 TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
883
884 psub = HeapAlloc(GetProcessHeap(), 0, sizeof(*psub));
885 split_subst_info(&psub->from, value);
886 split_subst_info(&psub->to, data);
887
888 /* Win 2000 doesn't allow mapping between different charsets
889 or mapping of DEFAULT_CHARSET */
890 if((psub->to.charset != psub->from.charset) ||
891 psub->to.charset == DEFAULT_CHARSET) {
892 HeapFree(GetProcessHeap(), 0, psub->to.name);
893 HeapFree(GetProcessHeap(), 0, psub->from.name);
894 HeapFree(GetProcessHeap(), 0, psub);
895 } else {
896 add_font_subst(&font_subst_list, psub, 0);
897 }
898 /* reset dlen and vlen */
899 dlen = datalen;
900 vlen = valuelen;
901 }
902 HeapFree(GetProcessHeap(), 0, data);
903 HeapFree(GetProcessHeap(), 0, value);
904 RegCloseKey(hkey);
905 }
906 }
907
908 static WCHAR *get_familyname(FT_Face ft_face)
909 {
910 WCHAR *family = NULL;
911 FT_SfntName name;
912 FT_UInt num_names, name_index, i;
913
914 if(FT_IS_SFNT(ft_face))
915 {
916 num_names = pFT_Get_Sfnt_Name_Count(ft_face);
917
918 for(name_index = 0; name_index < num_names; name_index++)
919 {
920 if(!pFT_Get_Sfnt_Name(ft_face, name_index, &name))
921 {
922 if((name.name_id == TT_NAME_ID_FONT_FAMILY) &&
923 (name.language_id == GetUserDefaultLCID()) &&
924 (name.platform_id == TT_PLATFORM_MICROSOFT) &&
925 (name.encoding_id == TT_MS_ID_UNICODE_CS))
926 {
927 /* String is not nul terminated and string_len is a byte length. */
928 family = HeapAlloc(GetProcessHeap(), 0, name.string_len + 2);
929 for(i = 0; i < name.string_len / 2; i++)
930 {
931 WORD *tmp = (WORD *)&name.string[i * 2];
932 family[i] = GET_BE_WORD(*tmp);
933 }
934 family[i] = 0;
935
936 TRACE("Got localised name %s\n", debugstr_w(family));
937 return family;
938 }
939 }
940 }
941 }
942
943 return NULL;
944 }
945
946
947 /*****************************************************************
948 * load_sfnt_table
949 *
950 * Wrapper around FT_Load_Sfnt_Table to cope with older versions
951 * of FreeType that don't export this function.
952 *
953 */
954 static FT_Error load_sfnt_table(FT_Face ft_face, FT_ULong table, FT_Long offset, FT_Byte *buf, FT_ULong *len)
955 {
956
957 FT_Error err;
958
959 /* If the FT_Load_Sfnt_Table function is there we'll use it */
960 if(pFT_Load_Sfnt_Table)
961 {
962 err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, len);
963 }
964 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
965 else /* Do it the hard way */
966 {
967 TT_Face tt_face = (TT_Face) ft_face;
968 SFNT_Interface *sfnt;
969 if (FT_Version.major==2 && FT_Version.minor==0)
970 {
971 /* 2.0.x */
972 sfnt = *(SFNT_Interface**)((char*)tt_face + 528);
973 }
974 else
975 {
976 /* A field was added in the middle of the structure in 2.1.x */
977 sfnt = *(SFNT_Interface**)((char*)tt_face + 532);
978 }
979 err = sfnt->load_any(tt_face, table, offset, buf, len);
980 }
981 #else
982 else
983 {
984 static int msg;
985 if(!msg)
986 {
987 MESSAGE("This version of Wine was compiled with freetype headers later than 2.2.0\n"
988 "but is being run with a freetype library without the FT_Load_Sfnt_Table function.\n"
989 "Please upgrade your freetype library.\n");
990 msg++;
991 }
992 err = FT_Err_Unimplemented_Feature;
993 }
994 #endif
995 return err;
996 }
997
998
999 #define ADDFONT_EXTERNAL_FONT 0x01
1000 #define ADDFONT_FORCE_BITMAP 0x02
1001 static INT AddFontToList(const char *file, void *font_data_ptr, DWORD font_data_size, char *fake_family, const WCHAR *target_family, DWORD flags)
1002 {
1003 FT_Face ft_face;
1004 TT_OS2 *pOS2;
1005 TT_Header *pHeader = NULL;
1006 WCHAR *english_family, *localised_family, *StyleW;
1007 DWORD len;
1008 Family *family;
1009 Face *face;
1010 struct list *family_elem_ptr, *face_elem_ptr;
1011 FT_Error err;
1012 FT_Long face_index = 0, num_faces;
1013 #ifdef HAVE_FREETYPE_FTWINFNT_H
1014 FT_WinFNT_HeaderRec winfnt_header;
1015 #endif
1016 int i, bitmap_num, internal_leading;
1017 FONTSIGNATURE fs;
1018
1019 /* we always load external fonts from files - otherwise we would get a crash in update_reg_entries */
1020 assert(file || !(flags & ADDFONT_EXTERNAL_FONT));
1021
1022 #ifdef HAVE_CARBON_CARBON_H
1023 if(file && !fake_family)
1024 {
1025 char **mac_list = expand_mac_font(file);
1026 if(mac_list)
1027 {
1028 BOOL had_one = FALSE;
1029 char **cursor;
1030 for(cursor = mac_list; *cursor; cursor++)
1031 {
1032 had_one = TRUE;
1033 AddFontToList(*cursor, NULL, 0, NULL, NULL, flags);
1034 HeapFree(GetProcessHeap(), 0, *cursor);
1035 }
1036 HeapFree(GetProcessHeap(), 0, mac_list);
1037 if(had_one)
1038 return 1;
1039 }
1040 }
1041 #endif /* HAVE_CARBON_CARBON_H */
1042
1043 do {
1044 char *family_name = fake_family;
1045
1046 if (file)
1047 {
1048 TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
1049 err = pFT_New_Face(library, file, face_index, &ft_face);
1050 } else
1051 {
1052 TRACE("Loading font from ptr %p size %d, index %ld\n", font_data_ptr, font_data_size, face_index);
1053 err = pFT_New_Memory_Face(library, font_data_ptr, font_data_size, face_index, &ft_face);
1054 }
1055
1056 if(err != 0) {
1057 WARN("Unable to load font %s/%p err = %x\n", debugstr_a(file), font_data_ptr, err);
1058 return 0;
1059 }
1060
1061 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*/
1062 WARN("Ignoring font %s/%p\n", debugstr_a(file), font_data_ptr);
1063 pFT_Done_Face(ft_face);
1064 return 0;
1065 }
1066
1067 /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1068 if(!FT_IS_SCALABLE(ft_face) && FT_SimpleVersion < ((2 << 16) | (1 << 8) | (9 << 0))) {
1069 WARN("FreeType version < 2.1.9, skipping bitmap font %s/%p\n", debugstr_a(file), font_data_ptr);
1070 pFT_Done_Face(ft_face);
1071 return 0;
1072 }
1073
1074 if(FT_IS_SFNT(ft_face))
1075 {
1076 if(!(pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2)) ||
1077 !pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea) ||
1078 !(pHeader = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_head)))
1079 {
1080 TRACE("Font %s/%p lacks either an OS2, HHEA or HEAD table.\n"
1081 "Skipping this font.\n", debugstr_a(file), font_data_ptr);
1082 pFT_Done_Face(ft_face);
1083 return 0;
1084 }
1085
1086 /* Wine uses ttfs as an intermediate step in building its bitmap fonts;
1087 we don't want to load these. */
1088 if(!memcmp(pOS2->achVendID, "Wine", sizeof(pOS2->achVendID)))
1089 {
1090 FT_ULong len = 0;
1091
1092 if(!load_sfnt_table(ft_face, FT_MAKE_TAG('E','B','S','C'), 0, NULL, &len))
1093 {
1094 TRACE("Skipping Wine bitmap-only TrueType font %s\n", debugstr_a(file));
1095 pFT_Done_Face(ft_face);
1096 return 0;
1097 }
1098 }
1099 }
1100
1101 if(!ft_face->family_name || !ft_face->style_name) {
1102 TRACE("Font %s/%p lacks either a family or style name\n", debugstr_a(file), font_data_ptr);
1103 pFT_Done_Face(ft_face);
1104 return 0;
1105 }
1106
1107 if (target_family)
1108 {
1109 localised_family = get_familyname(ft_face);
1110 if (localised_family && strcmpiW(localised_family,target_family)!=0)
1111 {
1112 TRACE("Skipping Index %i: Incorrect Family name for replacement\n",(INT)face_index);
1113 HeapFree(GetProcessHeap(), 0, localised_family);
1114 num_faces = ft_face->num_faces;
1115 pFT_Done_Face(ft_face);
1116 continue;
1117 }
1118 HeapFree(GetProcessHeap(), 0, localised_family);
1119 }
1120
1121 if(!family_name)
1122 family_name = ft_face->family_name;
1123
1124 bitmap_num = 0;
1125 do {
1126 My_FT_Bitmap_Size *size = NULL;
1127 FT_ULong tmp_size;
1128
1129 if(!FT_IS_SCALABLE(ft_face))
1130 size = (My_FT_Bitmap_Size *)ft_face->available_sizes + bitmap_num;
1131
1132 len = MultiByteToWideChar(CP_ACP, 0, family_name, -1, NULL, 0);
1133 english_family = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1134 MultiByteToWideChar(CP_ACP, 0, family_name, -1, english_family, len);
1135
1136 localised_family = NULL;
1137 if(!fake_family) {
1138 localised_family = get_familyname(ft_face);
1139 if(localised_family && !strcmpW(localised_family, english_family)) {
1140 HeapFree(GetProcessHeap(), 0, localised_family);
1141 localised_family = NULL;
1142 }
1143 }
1144
1145 family = NULL;
1146 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1147 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1148 if(!strcmpW(family->FamilyName, localised_family ? localised_family : english_family))
1149 break;
1150 family = NULL;
1151 }
1152 if(!family) {
1153 family = HeapAlloc(GetProcessHeap(), 0, sizeof(*family));
1154 family->FamilyName = strdupW(localised_family ? localised_family : english_family);
1155 list_init(&family->faces);
1156 list_add_tail(&font_list, &family->entry);
1157
1158 if(localised_family) {
1159 FontSubst *subst = HeapAlloc(GetProcessHeap(), 0, sizeof(*subst));
1160 subst->from.name = strdupW(english_family);
1161 subst->from.charset = -1;
1162 subst->to.name = strdupW(localised_family);
1163 subst->to.charset = -1;
1164 add_font_subst(&font_subst_list, subst, 0);
1165 }
1166 }
1167 HeapFree(GetProcessHeap(), 0, localised_family);
1168 HeapFree(GetProcessHeap(), 0, english_family);
1169
1170 len = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0);
1171 StyleW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1172 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, StyleW, len);
1173
1174 internal_leading = 0;
1175 memset(&fs, 0, sizeof(fs));
1176
1177 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
1178 if(pOS2) {
1179 fs.fsCsb[0] = pOS2->ulCodePageRange1;
1180 fs.fsCsb[1] = pOS2->ulCodePageRange2;
1181 fs.fsUsb[0] = pOS2->ulUnicodeRange1;
1182 fs.fsUsb[1] = pOS2->ulUnicodeRange2;
1183 fs.fsUsb[2] = pOS2->ulUnicodeRange3;
1184 fs.fsUsb[3] = pOS2->ulUnicodeRange4;
1185 if(pOS2->version == 0) {
1186 FT_UInt dummy;
1187
1188 if(!pFT_Get_First_Char || (pFT_Get_First_Char( ft_face, &dummy ) < 0x100))
1189 fs.fsCsb[0] |= 1;
1190 else
1191 fs.fsCsb[0] |= 1L << 31;
1192 }
1193 }
1194 #ifdef HAVE_FREETYPE_FTWINFNT_H
1195 else if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header)) {
1196 CHARSETINFO csi;
1197 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header.pixel_height, winfnt_header.charset,
1198 winfnt_header.vertical_resolution,winfnt_header.horizontal_resolution, winfnt_header.nominal_point_size);
1199 if(TranslateCharsetInfo((DWORD*)(UINT_PTR)winfnt_header.charset, &csi, TCI_SRCCHARSET))
1200 memcpy(&fs, &csi.fs, sizeof(csi.fs));
1201 internal_leading = winfnt_header.internal_leading;
1202 }
1203 #endif
1204
1205 face_elem_ptr = list_head(&family->faces);
1206 while(face_elem_ptr) {
1207 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1208 face_elem_ptr = list_next(&family->faces, face_elem_ptr);
1209 if(!strcmpW(face->StyleName, StyleW) &&
1210 (FT_IS_SCALABLE(ft_face) || ((size->y_ppem == face->size.y_ppem) && !memcmp(&fs, &face->fs, sizeof(fs)) ))) {
1211 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1212 debugstr_w(family->FamilyName), debugstr_w(StyleW),
1213 face->font_version, pHeader ? pHeader->Font_Revision : 0);
1214
1215 if(fake_family) {
1216 TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
1217 HeapFree(GetProcessHeap(), 0, StyleW);
1218 pFT_Done_Face(ft_face);
1219 return 1;
1220 }
1221 if(!pHeader || pHeader->Font_Revision <= face->font_version) {
1222 TRACE("Original font is newer so skipping this one\n");
1223 HeapFree(GetProcessHeap(), 0, StyleW);
1224 pFT_Done_Face(ft_face);
1225 return 1;
1226 } else {
1227 TRACE("Replacing original with this one\n");
1228 list_remove(&face->entry);
1229 HeapFree(GetProcessHeap(), 0, face->file);
1230 HeapFree(GetProcessHeap(), 0, face->StyleName);
1231 HeapFree(GetProcessHeap(), 0, face);
1232 break;
1233 }
1234 }
1235 }
1236 face = HeapAlloc(GetProcessHeap(), 0, sizeof(*face));
1237 list_add_tail(&family->faces, &face->entry);
1238 face->StyleName = StyleW;
1239 if (file)
1240 {
1241 face->file = strdupA(file);
1242 face->font_data_ptr = NULL;
1243 face->font_data_size = 0;
1244 }
1245 else
1246 {
1247 face->file = NULL;
1248 face->font_data_ptr = font_data_ptr;
1249 face->font_data_size = font_data_size;
1250 }
1251 face->face_index = face_index;
1252 face->Italic = (ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 1 : 0;
1253 face->Bold = (ft_face->style_flags & FT_STYLE_FLAG_BOLD) ? 1 : 0;
1254 face->font_version = pHeader ? pHeader->Font_Revision : 0;
1255 face->family = family;
1256 face->external = (flags & ADDFONT_EXTERNAL_FONT) ? TRUE : FALSE;
1257 memcpy(&face->fs, &fs, sizeof(face->fs));
1258 memset(&face->fs_links, 0, sizeof(face->fs_links));
1259
1260 if(FT_IS_SCALABLE(ft_face)) {
1261 memset(&face->size, 0, sizeof(face->size));
1262 face->scalable = TRUE;
1263 } else {
1264 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1265 size->height, size->width, size->size >> 6,
1266 size->x_ppem >> 6, size->y_ppem >> 6);
1267 face->size.height = size->height;
1268 face->size.width = size->width;
1269 face->size.size = size->size;
1270 face->size.x_ppem = size->x_ppem;
1271 face->size.y_ppem = size->y_ppem;
1272 face->size.internal_leading = internal_leading;
1273 face->scalable = FALSE;
1274 }
1275
1276 /* check for the presence of the 'CFF ' table to check if the font is Type1 */
1277 tmp_size = 0;
1278 if (pFT_Load_Sfnt_Table && !pFT_Load_Sfnt_Table(ft_face, FT_MAKE_TAG('C','F','F',' '), 0, NULL, &tmp_size))
1279 {
1280 TRACE("Font %s/%p is OTF Type1\n", wine_dbgstr_a(file), font_data_ptr);
1281 face->ntmFlags = NTM_PS_OPENTYPE;
1282 }
1283 else
1284 face->ntmFlags = 0;
1285
1286 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1287 face->fs.fsCsb[0], face->fs.fsCsb[1],
1288 face->fs.fsUsb[0], face->fs.fsUsb[1],
1289 face->fs.fsUsb[2], face->fs.fsUsb[3]);
1290
1291
1292 if(face->fs.fsCsb[0] == 0) { /* let's see if we can find any interesting cmaps */
1293 for(i = 0; i < ft_face->num_charmaps; i++) {
1294 switch(ft_face->charmaps[i]->encoding) {
1295 case FT_ENCODING_UNICODE:
1296 case FT_ENCODING_APPLE_ROMAN:
1297 face->fs.fsCsb[0] |= 1;
1298 break;
1299 case FT_ENCODING_MS_SYMBOL:
1300 face->fs.fsCsb[0] |= 1L << 31;
1301 break;
1302 default:
1303 break;
1304 }
1305 }
1306 }
1307
1308 if(face->fs.fsCsb[0] & ~(1L << 31))
1309 have_installed_roman_font = TRUE;
1310 } while(!FT_IS_SCALABLE(ft_face) && ++bitmap_num < ft_face->num_fixed_sizes);
1311
1312 num_faces = ft_face->num_faces;
1313 pFT_Done_Face(ft_face);
1314 TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
1315 debugstr_w(StyleW));
1316 } while(num_faces > ++face_index);
1317 return num_faces;
1318 }
1319
1320 static INT AddFontFileToList(const char *file, char *fake_family, const WCHAR *target_family, DWORD flags)
1321 {
1322 return AddFontToList(file, NULL, 0, fake_family, target_family, flags);
1323 }
1324
1325 static void DumpFontList(void)
1326 {
1327 Family *family;
1328 Face *face;
1329 struct list *family_elem_ptr, *face_elem_ptr;
1330
1331 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1332 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1333 TRACE("Family: %s\n", debugstr_w(family->FamilyName));
1334 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1335 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1336 TRACE("\t%s\t%08x", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
1337 if(!face->scalable)
1338 TRACE(" %d", face->size.height);
1339 TRACE("\n");
1340 }
1341 }
1342 return;
1343 }
1344
1345 /***********************************************************
1346 * The replacement list is a way to map an entire font
1347 * family onto another family. For example adding
1348 *
1349 * [HKCU\Software\Wine\Fonts\Replacements]
1350 * "Wingdings"="Winedings"
1351 *
1352 * would enumerate the Winedings font both as Winedings and
1353 * Wingdings. However if a real Wingdings font is present the
1354 * replacement does not take place.
1355 *
1356 */
1357 static void LoadReplaceList(void)
1358 {
1359 HKEY hkey;
1360 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1361 LPWSTR value;
1362 LPVOID data;
1363 Family *family;
1364 Face *face;
1365 struct list *family_elem_ptr, *face_elem_ptr;
1366 CHAR familyA[400];
1367
1368 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1369 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
1370 {
1371 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1372 &valuelen, &datalen, NULL, NULL);
1373
1374 valuelen++; /* returned value doesn't include room for '\0' */
1375 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1376 data = HeapAlloc(GetProcessHeap(), 0, datalen);
1377
1378 dlen = datalen;
1379 vlen = valuelen;
1380 while(RegEnumValueW(hkey, i++, value, &vlen, NULL, &type, data,
1381 &dlen) == ERROR_SUCCESS) {
1382 TRACE("Got %s=%s\n", debugstr_w(value), debugstr_w(data));
1383 /* "NewName"="Oldname" */
1384 WideCharToMultiByte(CP_ACP, 0, value, -1, familyA, sizeof(familyA), NULL, NULL);
1385
1386 /* Find the old family and hence all of the font files
1387 in that family */
1388 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1389 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1390 if(!strcmpiW(family->FamilyName, data)) {
1391 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1392 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1393 TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
1394 debugstr_w(face->StyleName), familyA);
1395 /* Now add a new entry with the new family name */
1396 AddFontToList(face->file, face->font_data_ptr, face->font_data_size, familyA, family->FamilyName, ADDFONT_FORCE_BITMAP | (face->external ? ADDFONT_EXTERNAL_FONT : 0));
1397 }
1398 break;
1399 }
1400 }
1401 /* reset dlen and vlen */
1402 dlen = datalen;
1403 vlen = valuelen;
1404 }
1405 HeapFree(GetProcessHeap(), 0, data);
1406 HeapFree(GetProcessHeap(), 0, value);
1407 RegCloseKey(hkey);
1408 }
1409 }
1410
1411 /*************************************************************
1412 * init_system_links
1413 */
1414 static BOOL init_system_links(void)
1415 {
1416 static const WCHAR system_link[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1417 'W','i','n','d','o','w','s',' ','N','T','\\',
1418 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
1419 'S','y','s','t','e','m','L','i','n','k',0};
1420 HKEY hkey;
1421 BOOL ret = FALSE;
1422 DWORD type, max_val, max_data, val_len, data_len, index;
1423 WCHAR *value, *data;
1424 WCHAR *entry, *next;
1425 SYSTEM_LINKS *font_link, *system_font_link;
1426 CHILD_FONT *child_font;
1427 static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
1428 static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
1429 static const WCHAR System[] = {'S','y','s','t','e','m',0};
1430 FONTSIGNATURE fs;
1431 Family *family;
1432 Face *face;
1433 FontSubst *psub;
1434
1435 if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
1436 {
1437 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
1438 value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
1439 data = HeapAlloc(GetProcessHeap(), 0, max_data);
1440 val_len = max_val + 1;
1441 data_len = max_data;
1442 index = 0;
1443 while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
1444 {
1445 TRACE("%s:\n", debugstr_w(value));
1446
1447 memset(&fs, 0, sizeof(fs));
1448 font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
1449 psub = get_font_subst(&font_subst_list, value, -1);
1450 font_link->font_name = (psub)? strdupW(psub->to.name) : strdupW(value);
1451 list_init(&font_link->links);
1452 for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
1453 {
1454 WCHAR *face_name;
1455 CHILD_FONT *child_font;
1456
1457 TRACE("\t%s\n", debugstr_w(entry));
1458
1459 next = entry + strlenW(entry) + 1;
1460
1461 face_name = strchrW(entry, ',');
1462 if(face_name)
1463 {
1464 *face_name++ = 0;
1465 while(isspaceW(*face_name))
1466 face_name++;
1467
1468 psub = get_font_subst(&font_subst_list, face_name, -1);
1469 if(psub)
1470 face_name = psub->to.name;
1471 }
1472 face = find_face_from_filename(entry, face_name);
1473 if(!face)
1474 {
1475 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
1476 continue;
1477 }
1478
1479 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1480 child_font->face = face;
1481 child_font->font = NULL;
1482 fs.fsCsb[0] |= face->fs.fsCsb[0];
1483 fs.fsCsb[1] |= face->fs.fsCsb[1];
1484 TRACE("Adding file %s index %ld\n", child_font->face->file, child_font->face->face_index);
1485 list_add_tail(&font_link->links, &child_font->entry);
1486 }
1487 family = find_family_from_name(font_link->font_name);
1488 if(family)
1489 {
1490 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
1491 {
1492 memcpy(&face->fs_links, &fs, sizeof(fs));
1493 }
1494 }
1495 list_add_tail(&system_links, &font_link->entry);
1496 val_len = max_val + 1;
1497 data_len = max_data;
1498 }
1499
1500 HeapFree(GetProcessHeap(), 0, value);
1501 HeapFree(GetProcessHeap(), 0, data);
1502 RegCloseKey(hkey);
1503 }
1504
1505 /* Explicitly add an entry for the system font, this links to Tahoma and any links
1506 that Tahoma has */
1507
1508 system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
1509 system_font_link->font_name = strdupW(System);
1510 list_init(&system_font_link->links);
1511
1512 face = find_face_from_filename(tahoma_ttf, Tahoma);
1513 if(face)
1514 {
1515 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1516 child_font->face = face;
1517 child_font->font = NULL;
1518 TRACE("Found Tahoma in %s index %ld\n", child_font->face->file, child_font->face->face_index);
1519 list_add_tail(&system_font_link->links, &child_font->entry);
1520 }
1521 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
1522 {
1523 if(!strcmpiW(font_link->font_name, Tahoma))
1524 {
1525 CHILD_FONT *font_link_entry;
1526 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
1527 {
1528 CHILD_FONT *new_child;
1529 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
1530 new_child->face = font_link_entry->face;
1531 new_child->font = NULL;
1532 list_add_tail(&system_font_link->links, &new_child->entry);
1533 }
1534 break;
1535 }
1536 }
1537 list_add_tail(&system_links, &system_font_link->entry);
1538 return ret;
1539 }
1540
1541 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
1542 {
1543 DIR *dir;
1544 struct dirent *dent;
1545 char path[MAX_PATH];
1546
1547 TRACE("Loading fonts from %s\n", debugstr_a(dirname));
1548
1549 dir = opendir(dirname);
1550 if(!dir) {
1551 WARN("Can't open directory %s\n", debugstr_a(dirname));
1552 return FALSE;
1553 }
1554 while((dent = readdir(dir)) != NULL) {
1555 struct stat statbuf;
1556
1557 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
1558 continue;
1559
1560 TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
1561
1562 sprintf(path, "%s/%s", dirname, dent->d_name);
1563
1564 if(stat(path, &statbuf) == -1)
1565 {
1566 WARN("Can't stat %s\n", debugstr_a(path));
1567 continue;
1568 }
1569 if(S_ISDIR(statbuf.st_mode))
1570 ReadFontDir(path, external_fonts);
1571 else
1572 AddFontFileToList(path, NULL, NULL, external_fonts ? ADDFONT_EXTERNAL_FONT : 0);
1573 }
1574 closedir(dir);
1575 return TRUE;
1576 }
1577
1578 static void load_fontconfig_fonts(void)
1579 {
1580 #ifdef SONAME_LIBFONTCONFIG
1581 void *fc_handle = NULL;
1582 FcConfig *config;
1583 FcPattern *pat;
1584 FcObjectSet *os;
1585 FcFontSet *fontset;
1586 int i, len;
1587 char *file;
1588 const char *ext;
1589
1590 fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
1591 if(!fc_handle) {
1592 TRACE("Wine cannot find the fontconfig library (%s).\n",
1593 SONAME_LIBFONTCONFIG);
1594 return;
1595 }
1596 #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;}
1597 LOAD_FUNCPTR(FcConfigGetCurrent);
1598 LOAD_FUNCPTR(FcFontList);
1599 LOAD_FUNCPTR(FcFontSetDestroy);
1600 LOAD_FUNCPTR(FcInit);
1601 LOAD_FUNCPTR(FcObjectSetAdd);
1602 LOAD_FUNCPTR(FcObjectSetCreate);
1603 LOAD_FUNCPTR(FcObjectSetDestroy);
1604 LOAD_FUNCPTR(FcPatternCreate);
1605 LOAD_FUNCPTR(FcPatternDestroy);
1606 LOAD_FUNCPTR(FcPatternGetBool);
1607 LOAD_FUNCPTR(FcPatternGetString);
1608 #undef LOAD_FUNCPTR
1609
1610 if(!pFcInit()) return;
1611
1612 config = pFcConfigGetCurrent();
1613 pat = pFcPatternCreate();
1614 os = pFcObjectSetCreate();
1615 pFcObjectSetAdd(os, FC_FILE);
1616 pFcObjectSetAdd(os, FC_SCALABLE);
1617 fontset = pFcFontList(config, pat, os);
1618 if(!fontset) return;
1619 for(i = 0; i < fontset->nfont; i++) {
1620 FcBool scalable;
1621
1622 if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
1623 continue;
1624 TRACE("fontconfig: %s\n", file);
1625
1626 /* We're just interested in OT/TT fonts for now, so this hack just
1627 picks up the scalable fonts without extensions .pf[ab] to save time
1628 loading every other font */
1629
1630 if(pFcPatternGetBool(fontset->fonts[i], FC_SCALABLE, 0, &scalable) == FcResultMatch && !scalable)
1631 {
1632 TRACE("not scalable\n");
1633 continue;
1634 }
1635
1636 len = strlen( file );
1637 if(len < 4) continue;
1638 ext = &file[ len - 3 ];
1639 if(strcasecmp(ext, "pfa") && strcasecmp(ext, "pfb"))
1640 AddFontFileToList(file, NULL, NULL, ADDFONT_EXTERNAL_FONT);
1641 }
1642 pFcFontSetDestroy(fontset);
1643 pFcObjectSetDestroy(os);
1644 pFcPatternDestroy(pat);
1645 sym_not_found:
1646 #endif
1647 return;
1648 }
1649
1650 static BOOL load_font_from_data_dir(LPCWSTR file)
1651 {
1652 BOOL ret = FALSE;
1653 const char *data_dir = wine_get_data_dir();
1654
1655 if (!data_dir) data_dir = wine_get_build_dir();
1656
1657 if (data_dir)
1658 {
1659 INT len;
1660 char *unix_name;
1661
1662 len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
1663
1664 unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
1665
1666 strcpy(unix_name, data_dir);
1667 strcat(unix_name, "/fonts/");
1668
1669 WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
1670
1671 ret = AddFontFileToList(unix_name, NULL, NULL, ADDFONT_FORCE_BITMAP);
1672 HeapFree(GetProcessHeap(), 0, unix_name);
1673 }
1674 return ret;
1675 }
1676
1677 static void load_system_fonts(void)
1678 {
1679 HKEY hkey;
1680 WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
1681 const WCHAR * const *value;
1682 DWORD dlen, type;
1683 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
1684 char *unixname;
1685
1686 if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
1687 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1688 strcatW(windowsdir, fontsW);
1689 for(value = SystemFontValues; *value; value++) {
1690 dlen = sizeof(data);
1691 if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
1692 type == REG_SZ) {
1693 BOOL added = FALSE;
1694
1695 sprintfW(pathW, fmtW, windowsdir, data);
1696 if((unixname = wine_get_unix_file_name(pathW))) {
1697 added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
1698 HeapFree(GetProcessHeap(), 0, unixname);
1699 }
1700 if (!added)
1701 load_font_from_data_dir(data);
1702 }
1703 }
1704 RegCloseKey(hkey);
1705 }
1706 }
1707
1708 /*************************************************************
1709 *
1710 * This adds registry entries for any externally loaded fonts
1711 * (fonts from fontconfig or FontDirs). It also deletes entries
1712 * of no longer existing fonts.
1713 *
1714 */
1715 static void update_reg_entries(void)
1716 {
1717 HKEY winkey = 0, externalkey = 0;
1718 LPWSTR valueW;
1719 LPVOID data;
1720 DWORD dlen, vlen, datalen, valuelen, i, type, len, len_fam;
1721 Family *family;
1722 Face *face;
1723 struct list *family_elem_ptr, *face_elem_ptr;
1724 WCHAR *file;
1725 static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
1726 static const WCHAR spaceW[] = {' ', '\0'};
1727 char *path;
1728
1729 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
1730 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winkey, NULL) != ERROR_SUCCESS) {
1731 ERR("Can't create Windows font reg key\n");
1732 goto end;
1733 }
1734 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\ExternalFonts */
1735 if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &externalkey) != ERROR_SUCCESS) {
1736 ERR("Can't create external font reg key\n");
1737 goto end;
1738 }
1739
1740 /* Delete all external fonts added last time */
1741
1742 RegQueryInfoKeyW(externalkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1743 &valuelen, &datalen, NULL, NULL);
1744 valuelen++; /* returned value doesn't include room for '\0' */
1745 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1746 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
1747
1748 dlen = datalen * sizeof(WCHAR);
1749 vlen = valuelen;
1750 i = 0;
1751 while(RegEnumValueW(externalkey, i++, valueW, &vlen, NULL, &type, data,
1752 &dlen) == ERROR_SUCCESS) {
1753
1754 RegDeleteValueW(winkey, valueW);
1755 /* reset dlen and vlen */
1756 dlen = datalen;
1757 vlen = valuelen;
1758 }
1759 HeapFree(GetProcessHeap(), 0, data);
1760 HeapFree(GetProcessHeap(), 0, valueW);
1761
1762 /* Delete the old external fonts key */
1763 RegCloseKey(externalkey);
1764 externalkey = 0;
1765 RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
1766
1767 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\ExternalFonts */
1768 if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
1769 0, NULL, 0, KEY_ALL_ACCESS, NULL, &externalkey, NULL) != ERROR_SUCCESS) {
1770 ERR("Can't create external font reg key\n");
1771 goto end;
1772 }
1773
1774 /* enumerate the fonts and add external ones to the two keys */
1775
1776 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1777 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1778 len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
1779 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1780 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1781 if(!face->external) continue;
1782 len = len_fam;
1783 if(strcmpiW(face->StyleName, RegularW))
1784 len = len_fam + strlenW(face->StyleName) + 1;
1785 valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1786 strcpyW(valueW, family->FamilyName);
1787 if(len != len_fam) {
1788 strcatW(valueW, spaceW);
1789 strcatW(valueW, face->StyleName);
1790 }
1791 strcatW(valueW, TrueType);
1792 if((path = strrchr(face->file, '/')) == NULL)
1793 path = face->file;
1794 else
1795 path++;
1796 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
1797
1798 file = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1799 MultiByteToWideChar(CP_ACP, 0, path, -1, file, len);
1800 RegSetValueExW(winkey, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1801 RegSetValueExW(externalkey, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1802
1803 HeapFree(GetProcessHeap(), 0, file);
1804 HeapFree(GetProcessHeap(), 0, valueW);
1805 }
1806 }
1807 end:
1808 if(externalkey)
1809 RegCloseKey(externalkey);
1810 if(winkey)
1811 RegCloseKey(winkey);
1812 return;
1813 }
1814
1815
1816 /*************************************************************
1817 * WineEngAddFontResourceEx
1818 *
1819 */
1820 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
1821 {
1822 if (ft_handle) /* do it only if we have freetype up and running */
1823 {
1824 char *unixname;
1825
1826 if(flags)
1827 FIXME("Ignoring flags %x\n", flags);
1828
1829 if((unixname = wine_get_unix_file_name(file)))
1830 {
1831 INT ret = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
1832 HeapFree(GetProcessHeap(), 0, unixname);
1833 return ret;
1834 }
1835 }
1836 return 0;
1837 }
1838
1839 /*************************************************************
1840 * WineEngAddFontMemResourceEx
1841 *
1842 */
1843 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
1844 {
1845 if (ft_handle) /* do it only if we have freetype up and running */
1846 {
1847 PVOID pFontCopy = HeapAlloc(GetProcessHeap(), 0, cbFont);
1848
1849 TRACE("Copying %d bytes of data from %p to %p\n", cbFont, pbFont, pFontCopy);
1850 memcpy(pFontCopy, pbFont, cbFont);
1851
1852 *pcFonts = AddFontToList(NULL, pFontCopy, cbFont, NULL, NULL, ADDFONT_FORCE_BITMAP);
1853
1854 if (*pcFonts == 0)
1855 {
1856 TRACE("AddFontToList failed\n");
1857 HeapFree(GetProcessHeap(), 0, pFontCopy);
1858 return NULL;
1859 }
1860 /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
1861 * For now return something unique but quite random
1862 */
1863 TRACE("Returning handle %lx\n", ((INT_PTR)pFontCopy)^0x87654321);
1864 return (HANDLE)(((INT_PTR)pFontCopy)^0x87654321);
1865 }
1866
1867 *pcFonts = 0;
1868 return 0;
1869 }
1870
1871 /*************************************************************
1872 * WineEngRemoveFontResourceEx
1873 *
1874 */
1875 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
1876 {
1877 FIXME(":stub\n");
1878 return TRUE;
1879 }
1880
1881 static const struct nls_update_font_list
1882 {
1883 UINT ansi_cp, oem_cp;
1884 const char *oem, *fixed, *system;
1885 const char *courier, *serif, *small, *sserif;
1886 /* these are for font substitute */
1887 const char *shelldlg, *tmsrmn;
1888 } nls_update_font_list[] =
1889 {
1890 /* Latin 1 (United States) */
1891 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
1892 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1893 "Tahoma","Times New Roman",
1894 },
1895 /* Latin 1 (Multilingual) */
1896 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
1897 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1898 "Tahoma","Times New Roman", /* FIXME unverified */
1899 },
1900 /* Eastern Europe */
1901 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
1902 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
1903 "Tahoma","Times New Roman", /* FIXME unverified */
1904 },
1905 /* Cyrillic */
1906 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
1907 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
1908 "Tahoma","Times New Roman", /* FIXME unverified */
1909 },
1910 /* Greek */
1911 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
1912 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
1913 "Tahoma","Times New Roman", /* FIXME unverified */
1914 },
1915 /* Turkish */
1916 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
1917 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
1918 "Tahoma","Times New Roman", /* FIXME unverified */
1919 },
1920 /* Hebrew */
1921 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
1922 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
1923 "Tahoma","Times New Roman", /* FIXME unverified */
1924 },
1925 /* Arabic */
1926 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
1927 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
1928 "Tahoma","Times New Roman", /* FIXME unverified */
1929 },
1930 /* Baltic */
1931 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
1932 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
1933 "Tahoma","Times New Roman", /* FIXME unverified */
1934 },
1935 /* Vietnamese */
1936 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
1937 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1938 "Tahoma","Times New Roman", /* FIXME unverified */
1939 },
1940 /* Thai */
1941 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
1942 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
1943 "Tahoma","Times New Roman", /* FIXME unverified */
1944 },
1945 /* Japanese */
1946 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
1947 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
1948 "MS UI Gothic","MS Serif",
1949 },
1950 /* Chinese Simplified */
1951 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
1952 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1953 "Tahoma", "Times New Roman", /* FIXME unverified */
1954 },
1955 /* Korean */
1956 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
1957 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1958 "Gulim", "Batang",
1959 },
1960 /* Chinese Traditional */
1961 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
1962 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1963 "Tahoma", "Times New Roman", /* FIXME unverified */
1964 }
1965 };
1966
1967 static inline HKEY create_fonts_NT_registry_key(void)
1968 {
1969 HKEY hkey = 0;
1970
1971 RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
1972 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1973 return hkey;
1974 }
1975
1976 static inline HKEY create_fonts_9x_registry_key(void)
1977 {
1978 HKEY hkey = 0;
1979
1980 RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
1981 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1982 return hkey;
1983 }
1984
1985 static inline HKEY create_config_fonts_registry_key(void)
1986 {
1987 HKEY hkey = 0;
1988
1989 RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
1990 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1991 return hkey;
1992 }
1993
1994 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl)
1995 {
1996 RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
1997 RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
1998 RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)fl->sserif, strlen(fl->sserif)+1);
1999 RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
2000 }
2001
2002 static void update_font_info(void)
2003 {
2004 char buf[40], cpbuf[40];
2005 DWORD len, type;
2006 HKEY hkey = 0;
2007 UINT i, ansi_cp = 0, oem_cp = 0;
2008
2009 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL) != ERROR_SUCCESS)
2010 return;
2011
2012 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
2013 (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
2014 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
2015 (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
2016 sprintf( cpbuf, "%u,%u", ansi_cp, oem_cp );
2017
2018 len = sizeof(buf);
2019 if (RegQueryValueExA(hkey, "Codepages", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
2020 {
2021 if (!strcmp( buf, cpbuf )) /* already set correctly */
2022 {
2023 RegCloseKey(hkey);
2024 return;
2025 }
2026 TRACE("updating registry, codepages changed %s -> %u,%u\n", buf, ansi_cp, oem_cp);
2027 }
2028 else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp, oem_cp);
2029
2030 RegSetValueExA(hkey, "Codepages", 0, REG_SZ, (const BYTE *)cpbuf, strlen(cpbuf)+1);
2031 RegCloseKey(hkey);
2032
2033 for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
2034 {
2035 if (nls_update_font_list[i].ansi_cp == ansi_cp &&
2036 nls_update_font_list[i].oem_cp == oem_cp)
2037 {
2038 HKEY hkey;
2039
2040 hkey = create_config_fonts_registry_key();
2041 RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
2042 RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
2043 RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
2044 RegCloseKey(hkey);
2045
2046 hkey = create_fonts_NT_registry_key();
2047 add_font_list(hkey, &nls_update_font_list[i]);
2048 RegCloseKey(hkey);
2049
2050 hkey = create_fonts_9x_registry_key();
2051 add_font_list(hkey, &nls_update_font_list[i]);
2052 RegCloseKey(hkey);
2053
2054 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
2055 {
2056 RegSetValueExA(hkey, "MS Shell Dlg", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].shelldlg,
2057 strlen(nls_update_font_list[i].shelldlg)+1);
2058 RegSetValueExA(hkey, "Tms Rmn", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].tmsrmn,
2059 strlen(nls_update_font_list[i].tmsrmn)+1);
2060 RegCloseKey(hkey);
2061 }
2062 return;
2063 }
2064 }
2065 FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp, oem_cp);
2066 }
2067
2068 /*************************************************************
2069 * WineEngInit
2070 *
2071 * Initialize FreeType library and create a list of available faces
2072 */
2073 BOOL WineEngInit(void)
2074 {
2075 static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
2076 static const WCHAR pathW[] = {'P','a','t','h',0};
2077 HKEY hkey;
2078 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
2079 LPVOID data;
2080 WCHAR windowsdir[MAX_PATH];
2081 char *unixname;
2082 HANDLE font_mutex;
2083 const char *data_dir;
2084
2085 TRACE("\n");
2086
2087 /* update locale dependent font info in registry */
2088 update_font_info();
2089
2090 ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
2091 if(!ft_handle) {
2092 WINE_MESSAGE(
2093 "Wine cannot find the FreeType font library. To enable Wine to\n"
2094 "use TrueType fonts please install a version of FreeType greater than\n"
2095 "or equal to 2.0.5.\n"
2096 "http://www.freetype.org\n");
2097 return FALSE;
2098 }
2099
2100 #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;}
2101
2102 LOAD_FUNCPTR(FT_Vector_Unit)
2103 LOAD_FUNCPTR(FT_Done_Face)
2104 LOAD_FUNCPTR(FT_Get_Char_Index)
2105 LOAD_FUNCPTR(FT_Get_Module)
2106 LOAD_FUNCPTR(FT_Get_Sfnt_Name)
2107 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
2108 LOAD_FUNCPTR(FT_Get_Sfnt_Table)
2109 LOAD_FUNCPTR(FT_Init_FreeType)
2110 LOAD_FUNCPTR(FT_Load_Glyph)
2111 LOAD_FUNCPTR(FT_Matrix_Multiply)
2112 LOAD_FUNCPTR(FT_MulFix)
2113 LOAD_FUNCPTR(FT_New_Face)
2114 LOAD_FUNCPTR(FT_New_Memory_Face)
2115 LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
2116 LOAD_FUNCPTR(FT_Outline_Transform)
2117 LOAD_FUNCPTR(FT_Outline_Translate)
2118 LOAD_FUNCPTR(FT_Select_Charmap)
2119 LOAD_FUNCPTR(FT_Set_Charmap)
2120 LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
2121 LOAD_FUNCPTR(FT_Vector_Transform)
2122
2123 #undef LOAD_FUNCPTR
2124 /* Don't warn if this one is missing */
2125 pFT_Library_Version = wine_dlsym(ft_handle, "FT_Library_Version", NULL, 0);
2126 pFT_Load_Sfnt_Table = wine_dlsym(ft_handle, "FT_Load_Sfnt_Table", NULL, 0);
2127 pFT_Get_First_Char = wine_dlsym(ft_handle, "FT_Get_First_Char", NULL, 0);
2128 pFT_Get_Next_Char = wine_dlsym(ft_handle, "FT_Get_Next_Char", NULL, 0);
2129 pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
2130 #ifdef HAVE_FREETYPE_FTWINFNT_H
2131 pFT_Get_WinFNT_Header = wine_dlsym(ft_handle, "FT_Get_WinFNT_Header", NULL, 0);
2132 #endif
2133 if(!wine_dlsym(ft_handle, "FT_Get_Postscript_Name", NULL, 0) &&
2134 !wine_dlsym(ft_handle, "FT_Sqrt64", NULL, 0)) {
2135 /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
2136 <= 2.0.3 has FT_Sqrt64 */
2137 goto sym_not_found;
2138 }
2139
2140 if(pFT_Init_FreeType(&library) != 0) {
2141 ERR("Can't init FreeType library\n");
2142 wine_dlclose(ft_handle, NULL, 0);
2143 ft_handle = NULL;
2144 return FALSE;
2145 }
2146 FT_Version.major=FT_Version.minor=FT_Version.patch=-1;
2147 if (pFT_Library_Version)
2148 {
2149 pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
2150 }
2151 if (FT_Version.major<=0)
2152 {
2153 FT_Version.major=2;
2154 FT_Version.minor=0;
2155 FT_Version.patch=5;
2156 }
2157 TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
2158 FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
2159 ((FT_Version.minor << 8) & 0x00ff00) |
2160 ((FT_Version.patch ) & 0x0000ff);
2161
2162 if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL) {
2163 ERR("Failed to create font mutex\n");
2164 return FALSE;
2165 }
2166 WaitForSingleObject(font_mutex, INFINITE);
2167
2168 /* load the system bitmap fonts */
2169 load_system_fonts();
2170
2171 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
2172 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2173 strcatW(windowsdir, fontsW);
2174 if((unixname = wine_get_unix_file_name(windowsdir)))
2175 {
2176 ReadFontDir(unixname, FALSE);
2177 HeapFree(GetProcessHeap(), 0, unixname);
2178 }
2179
2180 /* load the system truetype fonts */
2181 data_dir = wine_get_data_dir();
2182 if (!data_dir) data_dir = wine_get_build_dir();
2183 if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/")))) {
2184 strcpy(unixname, data_dir);
2185 strcat(unixname, "/fonts/");
2186 ReadFontDir(unixname, TRUE);
2187 HeapFree(GetProcessHeap(), 0, unixname);
2188 }
2189
2190 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
2191 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
2192 full path as the entry. Also look for any .fon fonts, since ReadFontDir
2193 will skip these. */
2194 if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
2195 is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
2196 &hkey) == ERROR_SUCCESS) {
2197 LPWSTR valueW;
2198 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2199 &valuelen, &datalen, NULL, NULL);
2200
2201 valuelen++; /* returned value doesn't include room for '\0' */
2202 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2203 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
2204 if (valueW && data)
2205 {
2206 dlen = datalen * sizeof(WCHAR);
2207 vlen = valuelen;
2208 while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, data,
2209 &dlen) == ERROR_SUCCESS) {
2210 if(((LPWSTR)data)[0] && ((LPWSTR)data)[1] == ':')
2211 {
2212 if((unixname = wine_get_unix_file_name((LPWSTR)data)))
2213 {
2214 AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2215 HeapFree(GetProcessHeap(), 0, unixname);
2216 }
2217 }
2218 else if(dlen / 2 >= 6 && !strcmpiW(((LPWSTR)data) + dlen / 2 - 5, dot_fonW))
2219 {
2220 WCHAR pathW[MAX_PATH];
2221 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
2222 BOOL added = FALSE;
2223
2224 sprintfW(pathW, fmtW, windowsdir, data);
2225 if((unixname = wine_get_unix_file_name(pathW)))
2226 {
2227 added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2228 HeapFree(GetProcessHeap(), 0, unixname);
2229 }
2230 if (!added)
2231 load_font_from_data_dir(data);
2232 }
2233 /* reset dlen and vlen */
2234 dlen = datalen;
2235 vlen = valuelen;
2236 }
2237 }
2238 HeapFree(GetProcessHeap(), 0, data);
2239 HeapFree(GetProcessHeap(), 0, valueW);
2240 RegCloseKey(hkey);
2241 }
2242
2243 load_fontconfig_fonts();
2244
2245 /* then look in any directories that we've specified in the config file */
2246 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
2247 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
2248 {
2249 DWORD len;
2250 LPWSTR valueW;
2251 LPSTR valueA, ptr;
2252
2253 if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
2254 {
2255 len += sizeof(WCHAR);
2256 valueW = HeapAlloc( GetProcessHeap(), 0, len );
2257 if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
2258 {
2259 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
2260 valueA = HeapAlloc( GetProcessHeap(), 0, len );
2261 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
2262 TRACE( "got font path %s\n", debugstr_a(valueA) );
2263 ptr = valueA;
2264 while (ptr)
2265 {
2266 LPSTR next = strchr( ptr, ':' );
2267 if (next) *next++ = 0;
2268 ReadFontDir( ptr, TRUE );
2269 ptr = next;
2270 }
2271 HeapFree( GetProcessHeap(), 0, valueA );
2272 }
2273 HeapFree( GetProcessHeap(), 0, valueW );
2274 }
2275 RegCloseKey(hkey);
2276 }
2277
2278 DumpFontList();
2279 LoadSubstList();
2280 DumpSubstList();
2281 LoadReplaceList();
2282 update_reg_entries();
2283
2284 init_system_links();
2285
2286 ReleaseMutex(font_mutex);
2287 return TRUE;
2288 sym_not_found:
2289 WINE_MESSAGE(
2290 "Wine cannot find certain functions that it needs inside the FreeType\n"
2291 "font library. To enable Wine to use TrueType fonts please upgrade\n"
2292 "FreeType to at least version 2.0.5.\n"
2293 "http://www.freetype.org\n");
2294 wine_dlclose(ft_handle, NULL, 0);
2295 ft_handle = NULL;
2296 return FALSE;
2297 }
2298
2299
2300 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
2301 {
2302 TT_OS2 *pOS2;
2303 TT_HoriHeader *pHori;
2304
2305 LONG ppem;
2306
2307 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
2308 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
2309
2310 if(height == 0) height = 16;
2311
2312 /* Calc. height of EM square:
2313 *
2314 * For +ve lfHeight we have
2315 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
2316 * Re-arranging gives:
2317 * ppem = units_per_em * lfheight / (winAscent + winDescent)
2318 *
2319 * For -ve lfHeight we have
2320 * |lfHeight| = ppem
2321 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
2322 * with il = winAscent + winDescent - units_per_em]
2323 *
2324 */
2325
2326 if(height > 0) {
2327 if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
2328 ppem = ft_face->units_per_EM * height /
2329 (pHori->Ascender - pHori->Descender);
2330 else
2331 ppem = ft_face->units_per_EM * height /
2332 (pOS2->usWinAscent + pOS2->usWinDescent);
2333 }
2334 else
2335 ppem = -height;
2336
2337 return ppem;
2338 }
2339
2340 static struct font_mapping *map_font_file( const char *name )
2341 {
2342 struct font_mapping *mapping;
2343 struct stat st;
2344 int fd;
2345
2346 if ((fd = open( name, O_RDONLY )) == -1) return NULL;
2347 if (fstat( fd, &st ) == -1) goto error;
2348
2349 LIST_FOR_EACH_ENTRY( mapping, &mappings_list, struct font_mapping, entry )
2350 {
2351 if (mapping->dev == st.st_dev && mapping->ino == st.st_ino)
2352 {
2353 mapping->refcount++;
2354 close( fd );
2355 return mapping;
2356 }
2357 }
2358 if (!(mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping) )))
2359 goto error;
2360
2361 mapping->data = mmap( NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );
2362 close( fd );
2363
2364 if (mapping->data == MAP_FAILED)
2365 {
2366 HeapFree( GetProcessHeap(), 0, mapping );
2367 return NULL;
2368 }
2369 mapping->refcount = 1;
2370 mapping->dev = st.st_dev;
2371 mapping->ino = st.st_ino;
2372 mapping->size = st.st_size;
2373 list_add_tail( &mappings_list, &mapping->entry );
2374 return mapping;
2375
2376 error:
2377 close( fd );
2378 return NULL;
2379 }
2380
2381 static void unmap_font_file( struct font_mapping *mapping )
2382 {
2383 if (!--mapping->refcount)
2384 {
2385 list_remove( &mapping->entry );
2386 munmap( mapping->data, mapping->size );
2387 HeapFree( GetProcessHeap(), 0, mapping );
2388 }
2389 }
2390
2391 static LONG load_VDMX(GdiFont*, LONG);
2392
2393 static FT_Face OpenFontFace(GdiFont *font, Face *face, LONG width, LONG height)
2394 {
2395 FT_Error err;
2396 FT_Face ft_face;
2397 void *data_ptr;
2398 DWORD data_size;
2399
2400 TRACE("%s/%p, %ld, %d x %d\n", debugstr_a(face->file), face->font_data_ptr, face->face_index, width, height);
2401
2402 if (face->file)
2403 {
2404 if (!(font->mapping = map_font_file( face->file )))
2405 {
2406 WARN("failed to map %s\n", debugstr_a(face->file));
2407 return 0;
2408 }
2409 data_ptr = font->mapping->data;
2410 data_size = font->mapping->size;
2411 }
2412 else
2413 {
2414 data_ptr = face->font_data_ptr;
2415 data_size = face->font_data_size;
2416 }
2417
2418 err = pFT_New_Memory_Face(library, data_ptr, data_size, face->face_index, &ft_face);
2419 if(err) {
2420 ERR("FT_New_Face rets %d\n", err);
2421 return 0;
2422 }
2423
2424 /* set it here, as load_VDMX needs it */
2425 font->ft_face = ft_face;
2426
2427 if(FT_IS_SCALABLE(ft_face)) {
2428 /* load the VDMX table if we have one */
2429 font->ppem = load_VDMX(font, height);
2430 if(font->ppem == 0)
2431 font->ppem = calc_ppem_for_height(ft_face, height);
2432
2433 if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
2434 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font->ppem, err);
2435 } else {
2436 font->ppem = height;
2437 if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
2438 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width, height, err);
2439 }
2440 return ft_face;
2441 }
2442
2443
2444 static int get_nearest_charset(Face *face, int *cp)
2445 {
2446 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
2447 a single face with the requested charset. The idea is to check if
2448 the selected font supports the current ANSI codepage, if it does
2449 return the corresponding charset, else return the first charset */
2450
2451 CHARSETINFO csi;
2452 int acp = GetACP(), i;
2453 DWORD fs0;
2454
2455 *cp = acp;
2456 if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
2457 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
2458 return csi.ciCharset;
2459
2460 for(i = 0; i < 32; i++) {
2461 fs0 = 1L << i;
2462 if(face->fs.fsCsb[0] & fs0) {
2463 if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
2464 *cp = csi.ciACP;
2465 return csi.ciCharset;
2466 }
2467 else
2468 FIXME("TCI failing on %x\n", fs0);
2469 }
2470 }
2471
2472 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
2473 face->fs.fsCsb[0], face->file);
2474 *cp = acp;
2475 return DEFAULT_CHARSET;
2476 }
2477
2478 static GdiFont *alloc_font(void)
2479 {
2480 GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
2481 ret->gmsize = 1;
2482 ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM*));
2483 ret->gm[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
2484 ret->potm = NULL;
2485 ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
2486 ret->total_kern_pairs = (DWORD)-1;
2487 ret->kern_pairs = NULL;
2488 list_init(&ret->hfontlist);
2489 list_init(&ret->child_fonts);
2490 return ret;
2491 }
2492
2493 static void free_font(GdiFont *font)
2494 {
2495 struct list *cursor, *cursor2;
2496 int i;
2497
2498 LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
2499 {
2500 CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
2501 struct list *first_hfont;
2502 HFONTLIST *hfontlist;
2503 list_remove(cursor);
2504 if(child->font)
2505 {
2506 first_hfont = list_head(&child->font->hfontlist);
2507 hfontlist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2508 DeleteObject(hfontlist->hfont);
2509 HeapFree(GetProcessHeap(), 0, hfontlist);
2510 free_font(child->font);
2511 }
2512 HeapFree(GetProcessHeap(), 0, child);
2513 }
2514
2515 if (font->ft_face) pFT_Done_Face(font->ft_face);
2516 if (font->mapping) unmap_font_file( font->mapping );
2517 HeapFree(GetProcessHeap(), 0, font->kern_pairs);
2518 HeapFree(GetProcessHeap(), 0, font->potm);
2519 HeapFree(GetProcessHeap(), 0, font->name);
2520 for (i = 0; i < font->gmsize; i++)
2521 HeapFree(GetProcessHeap(),0,font->gm[i]);
2522 HeapFree(GetProcessHeap(), 0, font->gm);
2523 HeapFree(GetProcessHeap(), 0, font);
2524 }
2525
2526
2527 /*************************************************************
2528 * load_VDMX
2529 *
2530 * load the vdmx entry for the specified height
2531 */
2532
2533 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
2534 ( ( (FT_ULong)_x4 << 24 ) | \
2535 ( (FT_ULong)_x3 << 16 ) | \
2536 ( (FT_ULong)_x2 << 8 ) | \
2537 (FT_ULong)_x1 )
2538
2539 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
2540
2541 typedef struct {
2542 BYTE bCharSet;
2543 BYTE xRatio;
2544 BYTE yStartRatio;
2545 BYTE yEndRatio;
2546 } Ratios;
2547
2548 typedef struct {
2549 WORD recs;
2550 BYTE startsz;
2551 BYTE endsz;
2552 } VDMX_group;
2553
2554 static LONG load_VDMX(GdiFont *font, LONG height)
2555 {
2556 WORD hdr[3], tmp;
2557 VDMX_group group;
2558 BYTE devXRatio, devYRatio;
2559 USHORT numRecs, numRatios;
2560 DWORD result, offset = -1;
2561 LONG ppem = 0;
2562 int i;
2563
2564 /* For documentation on VDMX records, see
2565 * http://www.microsoft.com/OpenType/OTSpec/vdmx.htm
2566 */
2567
2568 result = WineEngGetFontData(font, MS_VDMX_TAG, 0, hdr, 6);
2569
2570 if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
2571 return ppem;
2572
2573 /* FIXME: need the real device aspect ratio */
2574 devXRatio = 1;
2575 devYRatio = 1;
2576
2577 numRecs = GET_BE_WORD(hdr[1]);
2578 numRatios = GET_BE_WORD(hdr[2]);
2579
2580 TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
2581 for(i = 0; i < numRatios; i++) {
2582 Ratios ratio;
2583
2584 offset = (3 * 2) + (i * sizeof(Ratios));
2585 WineEngGetFontData(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
2586 offset = -1;
2587
2588 TRACE("Ratios[%d] %d %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
2589
2590 if((ratio.xRatio == 0 &&
2591 ratio.yStartRatio == 0 &&
2592 ratio.yEndRatio == 0) ||
2593 (devXRatio == ratio.xRatio &&
2594 devYRatio >= ratio.yStartRatio &&
2595 devYRatio <= ratio.yEndRatio))
2596 {
2597 offset = (3 * 2) + (numRatios * 4) + (i * 2);
2598 WineEngGetFontData(font, MS_VDMX_TAG, offset, &tmp, 2);
2599 offset = GET_BE_WORD(tmp);
2600 break;
2601 }
2602 }
2603
2604 if(offset == -1) {
2605 FIXME("No suitable ratio found\n");
2606 return ppem;
2607 }
2608
2609 if(WineEngGetFontData(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
2610 USHORT recs;
2611 BYTE startsz, endsz;
2612 WORD *vTable;
2613
2614 recs = GET_BE_WORD(group.recs);
2615 startsz = group.startsz;
2616 endsz = group.endsz;
2617
2618 TRACE("recs=%d startsz=%d endsz=%d\n", recs, startsz, endsz);
2619
2620 vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
2621 result = WineEngGetFontData(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
2622 if(result == GDI_ERROR) {
2623 FIXME("Failed to retrieve vTable\n");
2624 goto end;
2625 }
2626
2627 if(height > 0) {
2628 for(i = 0; i < recs; i++) {
2629 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2630 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2631 ppem = GET_BE_WORD(vTable[i * 3]);
2632
2633 if(yMax + -yMin == height) {
2634 font->yMax = yMax;
2635 font->yMin = yMin;
2636 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
2637 break;
2638 }
2639 if(yMax + -yMin > height) {
2640 if(--i < 0) {
2641 ppem = 0;
2642 goto end; /* failed */
2643 }
2644 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2645 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2646 ppem = GET_BE_WORD(vTable[i * 3]);
2647 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
2648 break;
2649 }
2650 }
2651 if(!font->yMax) {
2652 ppem = 0;
2653 TRACE("ppem not found for height %d\n", height);
2654 }
2655 } else {
2656 ppem = -height;
2657 if(ppem < startsz || ppem > endsz)
2658 goto end;
2659
2660 for(i = 0; i < recs; i++) {
2661 USHORT yPelHeight;
2662 yPelHeight = GET_BE_WORD(vTable[i * 3]);
2663
2664 if(yPelHeight > ppem)
2665 break; /* failed */
2666
2667 if(yPelHeight == ppem) {
2668 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2669 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2670 TRACE("ppem %d found; yMax=%d yMin=%d\n", ppem, font->yMax, font->yMin);
2671 break;
2672 }
2673 }
2674 }
2675 end:
2676 HeapFree(GetProcessHeap(), 0, vTable);
2677 }
2678
2679 return ppem;
2680 }
2681
2682 static BOOL fontcmp(GdiFont *font, FONT_DESC *fd)
2683 {
2684 if(font->font_desc.hash != fd->hash) return TRUE;
2685 if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
2686 if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
2687 if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
2688 return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
2689 }
2690
2691 static void calc_hash(FONT_DESC *pfd)
2692 {
2693 DWORD hash = 0, *ptr, two_chars;
2694 WORD *pwc;
2695 unsigned int i;
2696
2697 for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
2698 hash ^= *ptr;
2699 for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
2700 hash ^= *ptr;
2701 for(i = 0, ptr = (DWORD*)&pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
2702 two_chars = *ptr;
2703 pwc = (WCHAR *)&two_chars;
2704 if(!*pwc) break;
2705 *pwc = toupperW(*pwc);
2706 pwc++;
2707 *pwc = toupperW(*pwc);
2708 hash ^= two_chars;
2709 if(!*pwc) break;
2710 }
2711 hash ^= !pfd->can_use_bitmap;
2712 pfd->hash = hash;
2713 return;
2714 }
2715
2716 static GdiFont *find_in_cache(HFONT hfont, LOGFONTW *plf, XFORM *pxf, BOOL can_use_bitmap)
2717 {
2718 GdiFont *ret;
2719 FONT_DESC fd;
2720 HFONTLIST *hflist;
2721 struct list *font_elem_ptr, *hfontlist_elem_ptr;
2722
2723 memcpy(&fd.lf, plf, sizeof(LOGFONTW));
2724 memcpy(&fd.matrix, pxf, sizeof(FMAT2));
2725 fd.can_use_bitmap = can_use_bitmap;
2726 calc_hash(&fd);
2727
2728 /* try the in-use list */
2729 LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
2730 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2731 if(!fontcmp(ret, &fd)) {
2732 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2733 LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
2734 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
2735 if(hflist->hfont == hfont)
2736 return ret;
2737 }
2738 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2739 hflist->hfont = hfont;
2740 list_add_head(&ret->hfontlist, &hflist->entry);
2741 return ret;
2742 }
2743 }
2744
2745 /* then the unused list */
2746 font_elem_ptr = list_head(&unused_gdi_font_list);
2747 while(font_elem_ptr) {
2748 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2749 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2750 if(!fontcmp(ret, &fd)) {
2751 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2752 assert(list_empty(&ret->hfontlist));
2753 TRACE("Found %p in unused list\n", ret);
2754 list_remove(&ret->entry);
2755 list_add_head(&gdi_font_list, &ret->entry);
2756 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2757 hflist->hfont = hfont;
2758 list_add_head(&ret->hfontlist, &hflist->entry);
2759 return ret;
2760 }
2761 }
2762 return NULL;
2763 }
2764
2765
2766 /*************************************************************
2767 * create_child_font_list
2768 */
2769 static BOOL create_child_font_list(GdiFont *font)
2770 {
2771 BOOL ret = FALSE;
2772 SYSTEM_LINKS *font_link;
2773 CHILD_FONT *font_link_entry, *new_child;
2774
2775 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2776 {
2777 if(!strcmpW(font_link->font_name, font->name))
2778 {
2779 TRACE("found entry in system list\n");
2780 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2781 {
2782 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
2783 new_child->face = font_link_entry->face;
2784 new_child->font = NULL;
2785 list_add_tail(&font->child_fonts, &new_child->entry);
2786 TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
2787 }
2788 ret = TRUE;
2789 break;
2790 }
2791 }
2792
2793 return ret;
2794 }
2795
2796 static BOOL select_charmap(FT_Face ft_face, FT_Encoding encoding)
2797 {
2798 FT_Error ft_err = FT_Err_Invalid_CharMap_Handle;
2799
2800 if (pFT_Set_Charmap)
2801 {
2802 FT_Int i;
2803 FT_CharMap cmap0, cmap1, cmap2, cmap3, cmap_def;
2804
2805 cmap0 = cmap1 = cmap2 = cmap3 = cmap_def = NULL;
2806
2807 for (i = 0; i < ft_face->num_charmaps; i++)
2808 {
2809 if (ft_face->charmaps[i]->encoding == encoding)
2810 {
2811 TRACE("found cmap with platform_id %u, encoding_id %u\n",
2812 ft_face->charmaps[i]->platform_id, ft_face->charmaps[i]->encoding_id);
2813
2814 switch (ft_face->charmaps[i]->platform_id)
2815 {
2816 default:
2817 cmap_def = ft_face->charmaps[i];
2818 break;
2819 case 0: /* Apple Unicode */
2820 cmap0 = ft_face->charmaps[i];
2821 break;
2822 case 1: /* Macintosh */
2823 cmap1 = ft_face->charmaps[i];
2824 break;
2825 case 2: /* ISO */
2826 cmap2 = ft_face->charmaps[i];
2827 break;
2828 case 3: /* Microsoft */
2829 cmap3 = ft_face->charmaps[i];
2830 break;
2831 }
2832 }
2833
2834 if (cmap3) /* prefer Microsoft cmap table */
2835 ft_err = pFT_Set_Charmap(ft_face, cmap3);
2836 else if (cmap1)
2837 ft_err = pFT_Set_Charmap(ft_face, cmap1);
2838 else if (cmap2)
2839 ft_err = pFT_Set_Charmap(ft_face, cmap2);
2840 else if (cmap0)
2841 ft_err = pFT_Set_Charmap(ft_face, cmap0);
2842 else if (cmap_def)
2843 ft_err = pFT_Set_Charmap(ft_face, cmap_def);
2844 }
2845 return ft_err == FT_Err_Ok;
2846 }
2847
2848 return pFT_Select_Charmap(ft_face, encoding) == FT_Err_Ok;
2849 }
2850
2851 /*************************************************************
2852 * WineEngCreateFontInstance
2853 *
2854 */
2855 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
2856 {
2857 GdiFont *ret;
2858 Face *face, *best, *best_bitmap;
2859 Family *family, *last_resort_family;
2860 struct list *family_elem_ptr, *face_elem_ptr;
2861 INT height, width = 0;
2862 unsigned int score = 0, new_score;
2863 signed int diff = 0, newdiff;
2864 BOOL bd, it, can_use_bitmap;
2865 LOGFONTW lf;
2866 CHARSETINFO csi;
2867 HFONTLIST *hflist;
2868
2869 LIST_FOR_EACH_ENTRY(ret, &child_font_list, struct tagGdiFont, entry)
2870 {
2871 struct list *first_hfont = list_head(&ret->hfontlist);
2872 hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2873 if(hflist->hfont == hfont)
2874 return ret;
2875 }
2876
2877 if (!GetObjectW( hfont, sizeof(lf), &lf )) return NULL;
2878 can_use_bitmap = GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_RA_ABLE;
2879
2880 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
2881 debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
2882 lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
2883 lf.lfEscapement);
2884
2885 /* check the cache first */
2886 if((ret = find_in_cache(hfont, &lf, &dc->xformWorld2Vport, can_use_bitmap)) != NULL) {
2887 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
2888 return ret;
2889 }
2890
2891 TRACE("not in cache\n");
2892 if(list_empty(&font_list)) /* No fonts installed */
2893 {
2894 TRACE("No fonts installed\n");
2895 return NULL;
2896 }
2897 if(!have_installed_roman_font)
2898 {
2899 TRACE("No roman font installed\n");
2900 return NULL;
2901 }
2902
2903 ret = alloc_font();
2904
2905 memcpy(&ret->font_desc.matrix, &dc->xformWorld2Vport, sizeof(FMAT2));
2906 memcpy(&ret->font_desc.lf, &lf, sizeof(LOGFONTW));
2907 ret->font_desc.can_use_bitmap = can_use_bitmap;
2908 calc_hash(&ret->font_desc);
2909 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2910 hflist->hfont = hfont;
2911 list_add_head(&ret->hfontlist, &hflist->entry);
2912
2913
2914 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
2915 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
2916 original value lfCharSet. Note this is a special case for
2917 Symbol and doesn't happen at least for "Wingdings*" */
2918
2919 if(!strcmpiW(lf.lfFaceName, SymbolW))
2920 lf.lfCharSet = SYMBOL_CHARSET;
2921
2922 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
2923 switch(lf.lfCharSet) {
2924 case DEFAULT_CHARSET:
2925 csi.fs.fsCsb[0] = 0;
2926 break;
2927 default:
2928 FIXME("Untranslated charset %d\n", lf.lfCharSet);
2929 csi.fs.fsCsb[0] = 0;
2930 break;
2931 }
2932 }
2933
2934 family = NULL;
2935 if(lf.lfFaceName[0] != '\0') {
2936 FontSubst *psub;
2937 SYSTEM_LINKS *font_link;
2938 CHILD_FONT *font_link_entry;
2939
2940 psub = get_font_subst(&font_subst_list, lf.lfFaceName, lf.lfCharSet);
2941
2942 if(psub) {
2943 TRACE("substituting %s -> %s\n", debugstr_w(lf.lfFaceName),
2944 debugstr_w(psub->to.name));
2945 strcpyW(lf.lfFaceName, psub->to.name);
2946 }
2947
2948 /* We want a match on name and charset or just name if
2949 charset was DEFAULT_CHARSET. If the latter then
2950 we fixup the returned charset later in get_nearest_charset
2951 where we'll either use the charset of the current ansi codepage
2952 or if that's unavailable the first charset that the font supports.
2953 */
2954 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2955 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2956 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
2957 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2958 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2959 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
2960 if(face->scalable || can_use_bitmap)
2961 goto found;
2962 }
2963 }
2964 }
2965
2966 /*
2967 * Try check the SystemLink list first for a replacement font.
2968 * We may find good replacements there.
2969 */
2970 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2971 {
2972 if(!strcmpiW(font_link->font_name, lf.lfFaceName))
2973 {
2974 TRACE("found entry in system list\n");
2975 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2976 {
2977 face = font_link_entry->face;
2978 family = face->family;
2979 if(csi.fs.fsCsb[0] &
2980 (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]) || !csi.fs.fsCsb[0])
2981 {
2982 if(face->scalable || can_use_bitmap)
2983 goto found;
2984 }
2985 }
2986 }
2987 }
2988 }
2989
2990 /* If requested charset was DEFAULT_CHARSET then try using charset
2991 corresponding to the current ansi codepage */
2992 if(!csi.fs.fsCsb[0]) {
2993 INT acp = GetACP();
2994 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
2995 FIXME("TCI failed on codepage %d\n", acp);
2996 csi.fs.fsCsb[0] = 0;
2997 } else
2998 lf.lfCharSet = csi.ciCharset;
2999 }
3000
3001 /* Face families are in the top 4 bits of lfPitchAndFamily,
3002 so mask with 0xF0 before testing */
3003
3004 if((lf.lfPitchAndFamily & FIXED_PITCH) ||
3005 (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
3006 strcpyW(lf.lfFaceName, defFixed);
3007 else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
3008 strcpyW(lf.lfFaceName, defSerif);
3009 else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
3010 strcpyW(lf.lfFaceName, defSans);
3011 else
3012 strcpyW(lf.lfFaceName, defSans);
3013 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3014 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3015 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
3016 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3017 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3018 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
3019 if(face->scalable || can_use_bitmap)
3020 goto found;
3021 }
3022 }
3023 }
3024
3025 last_resort_family = NULL;
3026 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3027 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3028 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3029 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3030 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) {
3031 if(face->scalable)
3032 goto found;
3033 if(can_use_bitmap && !last_resort_family)
3034 last_resort_family = family;
3035 }
3036 }
3037 }
3038
3039 if(last_resort_family) {
3040 family = last_resort_family;
3041 csi.fs.fsCsb[0] = 0;
3042 goto found;
3043 }
3044
3045 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3046 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3047 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3048 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3049 if(face->scalable) {
3050 csi.fs.fsCsb[0] = 0;
3051 WARN("just using first face for now\n");
3052 goto found;
3053 }
3054 if(can_use_bitmap && !last_resort_family)
3055 last_resort_family = family;
3056 }
3057 }
3058 if(!last_resort_family) {
3059 FIXME("can't find a single appropriate font - bailing\n");
3060 free_font(ret);
3061 return NULL;
3062 }
3063
3064 WARN("could only find a bitmap font - this will probably look awful!\n");
3065 family = last_resort_family;
3066 csi.fs.fsCsb[0] = 0;
3067
3068 found:
3069 it = lf.lfItalic ? 1 : 0;
3070 bd = lf.lfWeight > 550 ? 1 : 0;
3071
3072 height = GDI_ROUND( (FLOAT)lf.lfHeight * dc->xformWorld2Vport.eM22 );
3073 height = lf.lfHeight < 0 ? -abs(height) : abs(height);
3074
3075 face = best = best_bitmap = NULL;
3076 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
3077 {
3078 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
3079 {
3080 new_score = (face->Italic ^ it) + (face->Bold ^ bd);
3081 if(!best || new_score <= score)
3082 {
3083 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
3084 face->Italic, face->Bold, it, bd);
3085 score = new_score;
3086 best = face;
3087 if(best->scalable && score == 0) break;
3088 if(!best->scalable)
3089 {
3090 if(height > 0)
3091 newdiff = height - (signed int)(best->size.height);
3092 else
3093 newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
3094 if(!best_bitmap || new_score < score ||
3095 (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
3096 {
3097 TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
3098 diff = newdiff;
3099 best_bitmap = best;
3100 if(score == 0 && diff == 0) break;
3101 }
3102 }
3103 }
3104 }
3105 }
3106 if(best)
3107 face = best->scalable ? best : best_bitmap;
3108 ret->fake_italic = (it && !face->Italic);
3109 ret->fake_bold = (bd && !face->Bold);
3110
3111 memcpy(&ret->fs, &face->fs, sizeof(FONTSIGNATURE));
3112
3113 if(csi.fs.fsCsb[0]) {
3114 ret->charset = lf.lfCharSet;
3115 ret->codepage = csi.ciACP;
3116 }
3117 else
3118 ret->charset = get_nearest_charset(face, &ret->codepage);
3119
3120 TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family->FamilyName),
3121 debugstr_w(face->StyleName), face->file, face->font_data_ptr, face->face_index);
3122
3123 if(!face->scalable) {
3124 width = face->size.x_ppem >> 6;
3125 height = face->size.y_ppem >> 6;
3126 }
3127 ret->ft_face = OpenFontFace(ret, face, width, height);
3128
3129 if (!ret->ft_face)
3130 {
3131 free_font( ret );
3132 return 0;
3133 }
3134
3135 ret->ntmFlags = face->ntmFlags;
3136
3137 if (ret->charset == SYMBOL_CHARSET &&
3138 select_charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
3139 /* No ops */
3140 }
3141 else if (select_charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
3142 /* No ops */
3143 }
3144 else {
3145 select_charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
3146 }
3147
3148 ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
3149 ret->name = strdupW(family->FamilyName);
3150 ret->underline = lf.lfUnderline ? 0xff : 0;
3151 ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
3152 create_child_font_list(ret);
3153
3154 TRACE("caching: gdiFont=%p hfont=%p\n", ret, hfont);
3155
3156 ret->aveWidth = FT_IS_SCALABLE(ret->ft_face) ? abs(lf.lfWidth) : 0;
3157 list_add_head(&gdi_font_list, &ret->entry);
3158 return ret;
3159 }
3160
3161 static void dump_gdi_font_list(void)
3162 {
3163 GdiFont *gdiFont;
3164 struct list *elem_ptr;
3165
3166 TRACE("---------- gdiFont Cache ----------\n");
3167 LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
3168 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
3169 TRACE("gdiFont=%p %s %d\n",
3170 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
3171 }
3172
3173 TRACE("---------- Unused gdiFont Cache ----------\n");
3174 LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
3175 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
3176 TRACE("gdiFont=%p %s %d\n",
3177 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
3178 }
3179 }
3180
3181 /*************************************************************
3182 * WineEngDestroyFontInstance
3183 *
3184 * free the gdiFont associated with this handle
3185 *
3186 */
3187 BOOL WineEngDestroyFontInstance(HFONT handle)
3188 {
3189 GdiFont *gdiFont;
3190 HFONTLIST *hflist;
3191 BOOL ret = FALSE;
3192 struct list *font_elem_ptr, *hfontlist_elem_ptr;
3193 int i = 0;
3194
3195 LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
3196 {
3197 struct list *first_hfont = list_head(&gdiFont->hfontlist);
3198 hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
3199 if(hflist->hfont == handle)
3200 {
3201 TRACE("removing child font %p from child list\n", gdiFont);
3202 list_remove(&gdiFont->entry);
3203 return TRUE;
3204 }
3205 }
3206
3207 TRACE("destroying hfont=%p\n", handle);
3208 if(TRACE_ON(font))
3209 dump_gdi_font_list();
3210
3211 font_elem_ptr = list_head(&gdi_font_list);
3212 while(font_elem_ptr) {
3213 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3214 font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
3215
3216 hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
3217 while(hfontlist_elem_ptr) {
3218 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
3219 hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
3220 if(hflist->hfont == handle) {
3221 list_remove(&hflist->entry);
3222 HeapFree(GetProcessHeap(), 0, hflist);
3223 ret = TRUE;
3224 }
3225 }
3226 if(list_empty(&gdiFont->hfontlist)) {
3227 TRACE("Moving to Unused list\n");
3228 list_remove(&gdiFont->entry);
3229 list_add_head(&unused_gdi_font_list, &gdiFont->entry);
3230 }
3231 }
3232
3233
3234 font_elem_ptr = list_head(&unused_gdi_font_list);
3235 while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
3236 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3237 while(font_elem_ptr) {
3238 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3239 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3240 TRACE("freeing %p\n", gdiFont);
3241 list_remove(&gdiFont->entry);
3242 free_font(gdiFont);
3243 }
3244 return ret;
3245 }
3246
3247 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
3248 NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
3249 {
3250 OUTLINETEXTMETRICW *potm = NULL;
3251 UINT size;
3252 TEXTMETRICW tm, *ptm;
3253 GdiFont *font = alloc_font();
3254 LONG width, height;
3255
3256 if(face->scalable) {
3257 height = 100;
3258 width = 0;
3259 } else {
3260 height = face->size.y_ppem >> 6;
3261 width = face->size.x_ppem >> 6;
3262 }
3263
3264 if (!(font->ft_face = OpenFontFace(font, face, width, height)))
3265 {
3266 free_font(font);
3267 return;
3268 }
3269
3270 font->name = strdupW(face->family->FamilyName);
3271 font->ntmFlags = face->ntmFlags;
3272
3273 memset(&pelf->elfLogFont, 0, sizeof(LOGFONTW));
3274
3275 size = WineEngGetOutlineTextMetrics(font, 0, NULL);
3276 if(size) {
3277 potm = HeapAlloc(GetProcessHeap(), 0, size);
3278 WineEngGetOutlineTextMetrics(font, size, potm);
3279 ptm = (TEXTMETRICW*)&potm->otmTextMetrics;
3280 } else {
3281 WineEngGetTextMetrics(font, &tm);
3282 ptm = &tm;
3283 }
3284
3285 pntm->ntmTm.tmHeight = pelf->elfLogFont.lfHeight = ptm->tmHeight;
3286 pntm->ntmTm.tmAscent = ptm->tmAscent;
3287 pntm->ntmTm.tmDescent = ptm->tmDescent;
3288 pntm->ntmTm.tmInternalLeading = ptm->tmInternalLeading;
3289 pntm->ntmTm.tmExternalLeading = ptm->tmExternalLeading;
3290 pntm->ntmTm.tmAveCharWidth = pelf->elfLogFont.lfWidth = ptm->tmAveCharWidth;
3291 pntm->ntmTm.tmMaxCharWidth = ptm->tmMaxCharWidth;
3292 pntm->ntmTm.tmWeight = pelf->elfLogFont.lfWeight = ptm->tmWeight;
3293 pntm->ntmTm.tmOverhang = ptm->tmOverhang;
3294 pntm->ntmTm.tmDigitizedAspectX = ptm->tmDigitizedAspectX;
3295 pntm->ntmTm.tmDigitizedAspectY = ptm->tmDigitizedAspectY;
3296 pntm->ntmTm.tmFirstChar = ptm->tmFirstChar;
3297 pntm->ntmTm.tmLastChar = ptm->tmLastChar;
3298 pntm->ntmTm.tmDefaultChar = ptm->tmDefaultChar;
3299 pntm->ntmTm.tmBreakChar = ptm->tmBreakChar;
3300 pntm->ntmTm.tmItalic = pelf->elfLogFont.lfItalic = ptm->tmItalic;
3301 pntm->ntmTm.tmUnderlined = pelf->elfLogFont.lfUnderline = ptm->tmUnderlined;
3302 pntm->ntmTm.tmStruckOut = pelf->elfLogFont.lfStrikeOut = ptm->tmStruckOut;
3303 pntm->ntmTm.tmPitchAndFamily = ptm->tmPitchAndFamily;
3304 pelf->elfLogFont.lfPitchAndFamily = (ptm->tmPitchAndFamily & 0xf1) + 1;
3305 pntm->ntmTm.tmCharSet = pelf->elfLogFont.lfCharSet = ptm->tmCharSet;
3306 pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
3307 pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
3308 pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
3309
3310 *ptype = 0;
3311 if (ptm->tmPitchAndFamily & TMPF_TRUETYPE)
3312 *ptype |= TRUETYPE_FONTTYPE;
3313 if (ptm->tmPitchAndFamily & TMPF_DEVICE)
3314 *ptype |= DEVICE_FONTTYPE;
3315 if(!(ptm->tmPitchAndFamily & TMPF_VECTOR))
3316 *ptype |= RASTER_FONTTYPE;
3317
3318 pntm->ntmTm.ntmFlags = ptm->tmItalic ? NTM_ITALIC : 0;
3319 if(ptm->tmWeight > 550) pntm->ntmTm.ntmFlags |= NTM_BOLD;
3320 if(pntm->ntmTm.ntmFlags == 0) pntm->ntmTm.ntmFlags = NTM_REGULAR;
3321 pntm->ntmTm.ntmFlags |= face->ntmFlags;
3322
3323 pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
3324 pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
3325 memset(&pntm->ntmFontSig, 0, sizeof(FONTSIGNATURE));
3326
3327 if(potm) {
3328 pntm->ntmTm.ntmSizeEM = potm->otmEMSquare;
3329
3330 lstrcpynW(pelf->elfLogFont.lfFaceName,
3331 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFamilyName),
3332 LF_FACESIZE);
3333 lstrcpynW(pelf->elfFullName,
3334 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFaceName),
3335 LF_FULLFACESIZE);
3336 lstrcpynW(pelf->elfStyle,
3337 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpStyleName),
3338 LF_FACESIZE);
3339
3340 HeapFree(GetProcessHeap(), 0, potm);
3341 } else {
3342 pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
3343
3344 lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
3345 lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FACESIZE);
3346 pelf->elfStyle[0] = '\0';
3347 }
3348
3349 pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
3350
3351 free_font(font);
3352 }
3353
3354 /*************************************************************
3355 * WineEngEnumFonts
3356 *
3357 */
3358 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
3359 {
3360 Family *family;
3361 Face *face;
3362 struct list *family_elem_ptr, *face_elem_ptr;
3363 ENUMLOGFONTEXW elf;
3364 NEWTEXTMETRICEXW ntm;
3365 DWORD type, ret = 1;
3366 FONTSIGNATURE fs;
3367 CHARSETINFO csi;
3368 LOGFONTW lf;
3369 int i;
3370
3371 TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
3372
3373 if(plf->lfFaceName[0]) {
3374 FontSubst *psub;
3375 psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
3376
3377 if(psub) {
3378 TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
3379 debugstr_w(psub->to.name));
3380 memcpy(&lf, plf, sizeof(lf));
3381 strcpyW(lf.lfFaceName, psub->to.name);
3382 plf = &lf;
3383 }
3384
3385 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3386 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3387 if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
3388 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3389 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3390 GetEnumStructs(face, &elf, &ntm, &type);
3391 for(i = 0; i < 32; i++) {
3392 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3393 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3394 strcpyW(elf.elfScript, OEM_DOSW);
3395 i = 32; /* break out of loop */
3396 } else if(!(face->fs.fsCsb[0] & (1L << i)))
3397 continue;
3398 else {
3399 fs.fsCsb[0] = 1L << i;
3400 fs.fsCsb[1] = 0;
3401 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3402 TCI_SRCFONTSIG))
3403 csi.ciCharset = DEFAULT_CHARSET;
3404 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3405 if(csi.ciCharset != DEFAULT_CHARSET) {
3406 elf.elfLogFont.lfCharSet =
3407 ntm.ntmTm.tmCharSet = csi.ciCharset;
3408 if(ElfScriptsW[i])
3409 strcpyW(elf.elfScript, ElfScriptsW[i]);
3410 else
3411 FIXME("Unknown elfscript for bit %d\n", i);
3412 }
3413 }
3414 TRACE("enuming face %s full %s style %s charset %d type %d script %s it %d weight %d ntmflags %08x\n",
3415 debugstr_w(elf.elfLogFont.lfFaceName),
3416 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3417 csi.ciCharset, type, debugstr_w(elf.elfScript),
3418 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3419 ntm.ntmTm.ntmFlags);
3420 ret = proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam);
3421 if(!ret) goto end;
3422 }
3423 }
3424 }
3425 }
3426 } else {
3427 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3428 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3429 face_elem_ptr = list_head(&family->faces);
3430 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3431 GetEnumStructs(face, &elf, &ntm, &type);
3432 for(i = 0; i < 32; i++) {
3433 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3434 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3435 strcpyW(elf.elfScript, OEM_DOSW);
3436 i = 32; /* break out of loop */
3437 } else if(!(face->fs.fsCsb[0] & (1L << i)))
3438 continue;
3439 else {
3440 fs.fsCsb[0] = 1L << i;
3441 fs.fsCsb[1] = 0;
3442 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3443 TCI_SRCFONTSIG))
3444 csi.ciCharset = DEFAULT_CHARSET;
3445 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3446 if(csi.ciCharset != DEFAULT_CHARSET) {
3447 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet =
3448 csi.ciCharset;
3449 if(ElfScriptsW[i])
3450 strcpyW(elf.elfScript, ElfScriptsW[i]);
3451 else
3452 FIXME("Unknown elfscript for bit %d\n", i);
3453 }
3454 }
3455 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
3456 debugstr_w(elf.elfLogFont.lfFaceName),
3457 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3458 csi.ciCharset, type, debugstr_w(elf.elfScript),
3459 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3460 ntm.ntmTm.ntmFlags);
3461 ret = proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam);
3462 if(!ret) goto end;
3463 }
3464 }
3465 }
3466 end:
3467 return ret;
3468 }
3469
3470 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
3471 {
3472 pt->x.value = vec->x >> 6;
3473 pt->x.fract = (vec->x & 0x3f) << 10;
3474 pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
3475 pt->y.value = vec->y >> 6;
3476 pt->y.fract = (vec->y & 0x3f) << 10;
3477 pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
3478 return;
3479 }
3480
3481 /***************************************************
3482 * According to the MSDN documentation on WideCharToMultiByte,
3483 * certain codepages cannot set the default_used parameter.
3484 * This returns TRUE if the codepage can set that parameter, false else
3485 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
3486 */
3487 static BOOL codepage_sets_default_used(UINT codepage)
3488 {
3489 switch (codepage)
3490 {
3491 case CP_UTF7:
3492 case CP_UTF8:
3493 case CP_SYMBOL:
3494 return FALSE;
3495 default:
3496 return TRUE;
3497 }
3498 }
3499
3500 static FT_UInt get_glyph_index(GdiFont *font, UINT glyph)
3501 {
3502 if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
3503 WCHAR wc = (WCHAR)glyph;
3504 BOOL default_used;
3505 BOOL *default_used_pointer;
3506 FT_UInt ret;
3507 char buf;
3508 default_used_pointer = NULL;
3509 default_used = FALSE;
3510 if (codepage_sets_default_used(font->codepage))
3511 default_used_pointer = &default_used;
3512 if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
3513 ret = 0;
3514 else
3515 ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
3516 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
3517 return ret;
3518 }
3519
3520 if(font->charset == SYMBOL_CHARSET && glyph < 0x100)
3521 glyph = glyph + 0xf000;
3522 return pFT_Get_Char_Index(font->ft_face, glyph);
3523 }
3524
3525 /*************************************************************
3526 * WineEngGetGlyphIndices
3527 *
3528 * FIXME: add support for GGI_MARK_NONEXISTING_GLYPHS
3529 */
3530 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
3531 LPWORD pgi, DWORD flags)
3532 {
3533 int i;
3534 WCHAR default_char = 0;
3535 TEXTMETRICW textm;
3536
3537 if (flags & GGI_MARK_NONEXISTING_GLYPHS) default_char = 0x001f; /* Indicate non existence */
3538
3539 for(i = 0; i < count; i++)
3540 {
3541 pgi[i] = get_glyph_index(font, lpstr[i]);
3542 if (pgi[i] == 0)
3543 {
3544 if (!default_char)
3545 {
3546 WineEngGetTextMetrics(font, &textm);
3547 default_char = textm.tmDefaultChar;
3548 }
3549 pgi[i] = default_char;
3550 }
3551 }
3552 return count;
3553 }
3554
3555 /*************************************************************
3556 * WineEngGetGlyphOutline
3557 *
3558 * Behaves in exactly the same way as the win32 api GetGlyphOutline
3559 * except that the first parameter is the HWINEENGFONT of the font in
3560 * question rather than an HDC.
3561 *
3562 */
3563 DWORD WineEngGetGlyphOutline(GdiFont *incoming_font, UINT glyph, UINT format,
3564 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
3565 const MAT2* lpmat)
3566 {
3567 static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
3568 FT_Face ft_face = incoming_font->ft_face;
3569 GdiFont *font = incoming_font;
3570 FT_UInt glyph_index;
3571 DWORD width, height, pitch, needed = 0;
3572 FT_Bitmap ft_bitmap;
3573 FT_Error err;
3574 INT left, right, top = 0, bottom = 0, adv, lsb, bbx;
3575 FT_Angle angle = 0;
3576 FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
3577 float widthRatio = 1.0;
3578 FT_Matrix transMat = identityMat;
3579 BOOL needsTransform = FALSE;
3580
3581
3582 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
3583 buflen, buf, lpmat);
3584
3585 if(format & GGO_GLYPH_INDEX) {
3586 glyph_index = glyph;
3587 format &= ~GGO_GLYPH_INDEX;
3588 } else {
3589 get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
3590 ft_face = font->ft_face;
3591 }
3592
3593 if(glyph_index >= font->gmsize * GM_BLOCK_SIZE) {
3594 font->gmsize = (glyph_index / GM_BLOCK_SIZE + 1);
3595 font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
3596 font->gmsize * sizeof(GM*));
3597 } else {
3598 if(format == GGO_METRICS && font->gm[glyph_index / GM_BLOCK_SIZE] != NULL && FONT_GM(font,glyph_index)->init ) {
3599 *lpgm = FONT_GM(font,glyph_index)->gm;
3600 return 1; /* FIXME */
3601 }
3602 }
3603
3604 if (!font->gm[glyph_index / GM_BLOCK_SIZE])
3605 font->gm[glyph_index / GM_BLOCK_SIZE] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
3606
3607 if(font->orientation || (format != GGO_METRICS && format != GGO_BITMAP && format != WINE_GGO_GRAY16_BITMAP) || font->aveWidth || lpmat)
3608 load_flags |= FT_LOAD_NO_BITMAP;
3609
3610 err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
3611
3612 if(err) {
3613 WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
3614 return GDI_ERROR;
3615 }
3616
3617 /* Scaling factor */
3618 if (font->aveWidth && font->potm) {
3619 widthRatio = (float)font->aveWidth * font->font_desc.matrix.eM11 / (float) font->potm->otmTextMetrics.tmAveCharWidth;
3620 }
3621
3622 left = (INT)(ft_face->glyph->metrics.horiBearingX * widthRatio) & -64;
3623 right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) * widthRatio + 63) & -64;
3624
3625 adv = (INT)((ft_face->glyph->metrics.horiAdvance * widthRatio) + 63) >> 6;
3626 lsb = left >> 6;
3627 bbx = (right - left) >> 6;
3628
3629 /* Scaling transform */
3630 if(font->aveWidth) {
3631 FT_Matrix scaleMat;
3632 scaleMat.xx = FT_FixedFromFloat(widthRatio);
3633 scaleMat.xy = 0;
3634 scaleMat.yx = 0;
3635 scaleMat.yy = (1 << 16);
3636
3637 pFT_Matrix_Multiply(&scaleMat, &transMat);
3638 needsTransform = TRUE;
3639 }
3640
3641 /* Slant transform */
3642 if (font->fake_italic) {
3643 FT_Matrix slantMat;
3644
3645 slantMat.xx = (1 << 16);
3646 slantMat.xy = ((1 << 16) >> 2);
3647 slantMat.yx = 0;
3648 slantMat.yy = (1 << 16);
3649 pFT_Matrix_Multiply(&slantMat, &transMat);
3650 needsTransform = TRUE;
3651 }
3652
3653 /* Rotation transform */
3654 if(font->orientation) {
3655 FT_Matrix rotationMat;
3656 FT_Vector vecAngle;
3657 angle = FT_FixedFromFloat((float)font->orientation / 10.0);
3658 pFT_Vector_Unit(&vecAngle, angle);
3659 rotationMat.xx = vecAngle.x;
3660 rotationMat.xy = -vecAngle.y;
3661 rotationMat.yx = -rotationMat.xy;
3662 rotationMat.yy = rotationMat.xx;
3663
3664 pFT_Matrix_Multiply(&rotationMat, &transMat);
3665 needsTransform = TRUE;
3666 }
3667
3668 /* Extra transformation specified by caller */
3669 if (lpmat) {
3670 FT_Matrix extraMat;
3671 extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
3672 extraMat.xy = FT_FixedFromFIXED(lpmat->eM21);
3673 extraMat.yx = FT_FixedFromFIXED(lpmat->eM12);
3674 extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
3675 pFT_Matrix_Multiply(&extraMat, &transMat);
3676 needsTransform = TRUE;
3677 }
3678
3679 if(!needsTransform) {
3680 top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
3681 bottom = (ft_face->glyph->metrics.horiBearingY -
3682 ft_face->glyph->metrics.height) & -64;
3683 lpgm->gmCellIncX = adv;
3684 lpgm->gmCellIncY = 0;
3685 } else {
3686 INT xc, yc;
3687 FT_Vector vec;
3688 for(xc = 0; xc < 2; xc++) {
3689 for(yc = 0; yc < 2; yc++) {
3690 vec.x = (ft_face->glyph->metrics.horiBearingX +
3691 xc * ft_face->glyph->metrics.width);
3692 vec.y = ft_face->glyph->metrics.horiBearingY -
3693 yc * ft_face->glyph->metrics.height;
3694 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
3695 pFT_Vector_Transform(&vec, &transMat);
3696 if(xc == 0 && yc == 0) {
3697 left = right = vec.x;
3698 top = bottom = vec.y;
3699 } else {
3700 if(vec.x < left) left = vec.x;
3701 else if(vec.x > right) right = vec.x;
3702 if(vec.y < bottom) bottom = vec.y;
3703 else if(vec.y > top) top = vec.y;
3704 }
3705 }
3706 }
3707 left = left & -64;
3708 right = (right + 63) & -64;
3709 bottom = bottom & -64;
3710 top = (top + 63) & -64;
3711
3712 TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
3713 vec.x = ft_face->glyph->metrics.horiAdvance;
3714 vec.y = 0;
3715 pFT_Vector_Transform(&vec, &transMat);
3716 lpgm->gmCellIncX = (vec.x+63) >> 6;
3717 lpgm->gmCellIncY = -((vec.y+63) >> 6);
3718 }
3719 lpgm->gmBlackBoxX = (right - left) >> 6;
3720 lpgm->gmBlackBoxY = (top - bottom) >> 6;
3721 lpgm->gmptGlyphOrigin.x = left >> 6;
3722 lpgm->gmptGlyphOrigin.y = top >> 6;
3723
3724 if(format == GGO_METRICS || format == GGO_BITMAP || format == WINE_GGO_GRAY16_BITMAP)
3725 {
3726 FONT_GM(font,glyph_index)->gm = *lpgm;
3727 FONT_GM(font,glyph_index)->adv = adv;
3728 FONT_GM(font,glyph_index)->lsb = lsb;
3729 FONT_GM(font,glyph_index)->bbx = bbx;
3730 FONT_GM(font,glyph_index)->init = TRUE;
3731 }
3732
3733 if(format == GGO_METRICS)
3734 return 1; /* FIXME */
3735
3736 if(ft_face->glyph->format != ft_glyph_format_outline && format != GGO_BITMAP && format != WINE_GGO_GRAY16_BITMAP) {
3737 TRACE("loaded a bitmap\n");
3738 return GDI_ERROR;
3739 }
3740
3741 switch(format) {
3742 case GGO_BITMAP:
3743 width = lpgm->gmBlackBoxX;
3744 height = lpgm->gmBlackBoxY;
3745 pitch = ((width + 31) >> 5) << 2;
3746 needed = pitch * height;
3747
3748 if(!buf || !buflen) break;
3749
3750 switch(ft_face->glyph->format) {
3751 case ft_glyph_format_bitmap:
3752 {
3753 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
3754 INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
3755 INT h = ft_face->glyph->bitmap.rows;
3756 while(h--) {
3757 memcpy(dst, src, w);
3758 src += ft_face->glyph->bitmap.pitch;
3759 dst += pitch;
3760 }
3761 break;
3762 }
3763
3764 case ft_glyph_format_outline:
3765 ft_bitmap.width = width;
3766 ft_bitmap.rows = height;
3767 ft_bitmap.pitch = pitch;
3768 ft_bitmap.pixel_mode = ft_pixel_mode_mono;
3769 ft_bitmap.buffer = buf;
3770
3771 if(needsTransform) {
3772 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
3773 }
3774
3775 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
3776
3777 /* Note: FreeType will only set 'black' bits for us. */
3778 memset(buf, 0, needed);
3779 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
3780 break;
3781
3782 default:
3783 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
3784 return GDI_ERROR;
3785 }
3786 break;
3787
3788 case GGO_GRAY2_BITMAP:
3789 case GGO_GRAY4_BITMAP:
3790 case GGO_GRAY8_BITMAP:
3791 case WINE_GGO_GRAY16_BITMAP:
3792 {
3793 unsigned int mult, row, col;
3794 BYTE *start, *ptr;
3795
3796 width = lpgm->gmBlackBoxX;
3797 height = lpgm->gmBlackBoxY;
3798 pitch = (width + 3) / 4 * 4;
3799 needed = pitch * height;
3800
3801 if(!buf || !buflen) break;
3802
3803 switch(ft_face->glyph->format) {
3804 case ft_glyph_format_bitmap:
3805 {
3806 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
3807 INT h = ft_face->glyph->bitmap.rows;
3808 INT x;
3809 while(h--) {
3810 for(x = 0; x < pitch; x++)
3811 dst[x] = (src[x / 8] & (1 << ( (7 - (x % 8))))) ? 0xff : 0;
3812 src += ft_face->glyph->bitmap.pitch;
3813 dst += pitch;
3814 }
3815 return needed;
3816 }
3817 case ft_glyph_format_outline:
3818 {
3819 ft_bitmap.width = width;
3820 ft_bitmap.rows = height;
3821 ft_bitmap.pitch = pitch;
3822 ft_bitmap.pixel_mode = ft_pixel_mode_grays;
3823 ft_bitmap.buffer = buf;
3824
3825 if(needsTransform)
3826 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
3827
3828 pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
3829
3830 memset(ft_bitmap.buffer, 0, buflen);
3831
3832 pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
3833
3834 if(format == GGO_GRAY2_BITMAP)
3835 mult = 4;
3836 else if(format == GGO_GRAY4_BITMAP)
3837 mult = 16;
3838 else if(format == GGO_GRAY8_BITMAP)
3839 mult = 64;
3840 else /* format == WINE_GGO_GRAY16_BITMAP */
3841 return needed;
3842
3843 break;
3844 }
3845 default:
3846 FIXME("loaded glyph format %x\n", ft_face->glyph->format);
3847 return GDI_ERROR;
3848 }
3849
3850 start = buf;
3851 for(row = 0; row < height; row++) {
3852 ptr = start;
3853 for(col = 0; col < width; col++, ptr++) {
3854 *ptr = (((int)*ptr) * mult + 128) / 256;
3855 }
3856 start += pitch;
3857 }
3858 break;
3859 }
3860
3861 case GGO_NATIVE:
3862 {
3863 int contour, point = 0, first_pt;
3864 FT_Outline *outline = &ft_face->glyph->outline;
3865 TTPOLYGONHEADER *pph;
3866 TTPOLYCURVE *ppc;
3867 DWORD pph_start, cpfx, type;
3868
3869 if(buflen == 0) buf = NULL;
3870
3871 if (needsTransform && buf) {
3872 pFT_Outline_Transform(outline, &transMat);
3873 }
3874
3875 for(contour = 0; contour < outline->n_contours; contour++) {
3876 pph_start = needed;
3877 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
3878 first_pt = point;
3879 if(buf) {
3880 pph->dwType = TT_POLYGON_TYPE;
3881 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
3882 }
3883 needed += sizeof(*pph);
3884 point++;
3885 while(point <= outline->contours[contour]) {
3886 ppc = (TTPOLYCURVE *)((char *)buf + needed);
3887 type = (outline->tags[point] & FT_Curve_Tag_On) ?
3888 TT_PRIM_LINE : TT_PRIM_QSPLINE;
3889 cpfx = 0;
3890 do {
3891 if(buf)
3892 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3893 cpfx++;
3894 point++;
3895 } while(point <= outline->contours[contour] &&
3896 (outline->tags[point] & FT_Curve_Tag_On) ==
3897 (outline->tags[point-1] & FT_Curve_Tag_On));
3898 /* At the end of a contour Windows adds the start point, but
3899 only for Beziers */
3900 if(point > outline->contours[contour] &&
3901 !(outline->tags[point-1] & FT_Curve_Tag_On)) {
3902 if(buf)
3903 FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
3904 cpfx++;
3905 } else if(point <= outline->contours[contour] &&
3906 outline->tags[point] & FT_Curve_Tag_On) {
3907 /* add closing pt for bezier */
3908 if(buf)
3909 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3910 cpfx++;
3911 point++;
3912 }
3913 if(buf) {
3914 ppc->wType = type;
3915 ppc->cpfx = cpfx;
3916 }
3917 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
3918 }
3919 if(buf)
3920 pph->cb = needed - pph_start;
3921 }
3922 break;
3923 }
3924 case GGO_BEZIER:
3925 {
3926 /* Convert the quadratic Beziers to cubic Beziers.
3927 The parametric eqn for a cubic Bezier is, from PLRM:
3928 r(t) = at^3 + bt^2 + ct + r0
3929 with the control points:
3930 r1 = r0 + c/3
3931 r2 = r1 + (c + b)/3
3932 r3 = r0 + c + b + a
3933
3934 A quadratic Beizer has the form:
3935 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
3936
3937 So equating powers of t leads to:
3938 r1 = 2/3 p1 + 1/3 p0
3939 r2 = 2/3 p1 + 1/3 p2
3940 and of course r0 = p0, r3 = p2
3941 */
3942
3943 int contour, point = 0, first_pt;
3944 FT_Outline *outline = &ft_face->glyph->outline;
3945 TTPOLYGONHEADER *pph;
3946 TTPOLYCURVE *ppc;
3947 DWORD pph_start, cpfx, type;
3948 FT_Vector cubic_control[4];
3949 if(buflen == 0) buf = NULL;
3950
3951 if (needsTransform && buf) {
3952 pFT_Outline_Transform(outline, &transMat);
3953 }
3954
3955 for(contour = 0; contour < outline->n_contours; contour++) {
3956 pph_start = needed;
3957 pph = (TTPOLYGONHEADER *)((char *)buf + needed);
3958 first_pt = point;
3959 if(buf) {
3960 pph->dwType = TT_POLYGON_TYPE;
3961 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
3962 }
3963 needed += sizeof(*pph);
3964 point++;
3965 while(point <= outline->contours[contour]) {
3966 ppc = (TTPOLYCURVE *)((char *)buf + needed);
3967 type = (outline->tags[point] & FT_Curve_Tag_On) ?
3968 TT_PRIM_LINE : TT_PRIM_CSPLINE;
3969 cpfx = 0;
3970 do {
3971 if(type == TT_PRIM_LINE) {
3972 if(buf)
3973 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3974 cpfx++;
3975 point++;
3976 } else {
3977 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
3978 so cpfx = 3n */
3979
3980 /* FIXME: Possible optimization in endpoint calculation
3981 if there are two consecutive curves */
3982 cubic_control[0] = outline->points[point-1];
3983 if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
3984 cubic_control[0].x += outline->points[point].x + 1;
3985 cubic_control[0].y += outline->points[point].y + 1;
3986 cubic_control[0].x >>= 1;
3987 cubic_control[0].y >>= 1;
3988 }
3989 if(point+1 > outline->contours[contour])
3990 cubic_control[3] = outline->points[first_pt];
3991 else {
3992 cubic_control[3] = outline->points[point+1];
3993 if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
3994 cubic_control[3].x += outline->points[point].x + 1;
3995 cubic_control[3].y += outline->points[point].y + 1;
3996 cubic_control[3].x >>= 1;
3997 cubic_control[3].y >>= 1;
3998 }
3999 }
4000 /* r1 = 1/3 p0 + 2/3 p1
4001 r2 = 1/3 p2 + 2/3 p1 */
4002 cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
4003 cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
4004 cubic_control[2] = cubic_control[1];
4005 cubic_control[1].x += (cubic_control[0].x + 1) / 3;
4006 cubic_control[1].y += (cubic_control[0].y + 1) / 3;
4007 cubic_control[2].x += (cubic_control[3].x + 1) / 3;
4008 cubic_control[2].y += (cubic_control[3].y + 1) / 3;
4009 if(buf) {
4010 FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
4011 FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
4012 FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
4013 }
4014 cpfx += 3;
4015 point++;
4016 }
4017 } while(point <= outline->contours[contour] &&
4018 (outline->tags[point] & FT_Curve_Tag_On) ==
4019 (outline->tags[point-1] & FT_Curve_Tag_On));
4020 /* At the end of a contour Windows adds the start point,
4021 but only for Beziers and we've already done that.
4022 */
4023 if(point <= outline->contours[contour] &&
4024 outline->tags[point] & FT_Curve_Tag_On) {
4025 /* This is the closing pt of a bezier, but we've already
4026 added it, so just inc point and carry on */
4027 point++;
4028 }
4029 if(buf) {
4030 ppc->wType = type;
4031 ppc->cpfx = cpfx;
4032 }
4033 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
4034 }
4035 if(buf)
4036 pph->cb = needed - pph_start;
4037 }
4038 break;
4039 }
4040
4041 default:
4042 FIXME("Unsupported format %d\n", format);
4043 return GDI_ERROR;
4044 }
4045 return needed;
4046 }
4047
4048 static BOOL get_bitmap_text_metrics(GdiFont *font)
4049 {
4050 FT_Face ft_face = font->ft_face;
4051 #ifdef HAVE_FREETYPE_FTWINFNT_H
4052 FT_WinFNT_HeaderRec winfnt_header;
4053 #endif
4054 const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
4055 font->potm = HeapAlloc(GetProcessHeap(), 0, size);
4056 font->potm->otmSize = size;
4057
4058 #define TM font->potm->otmTextMetrics
4059 #ifdef HAVE_FREETYPE_FTWINFNT_H
4060 if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
4061 {
4062 TM.tmHeight = winfnt_header.pixel_height;
4063 TM.tmAscent = winfnt_header.ascent;
4064 TM.tmDescent = TM.tmHeight - TM.tmAscent;
4065 TM.tmInternalLeading = winfnt_header.internal_leading;
4066 TM.tmExternalLeading = winfnt_header.external_leading;
4067 TM.tmAveCharWidth = winfnt_header.avg_width;
4068 TM.tmMaxCharWidth = winfnt_header.max_width;
4069 TM.tmWeight = winfnt_header.weight;
4070 TM.tmOverhang = 0;
4071 TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
4072 TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
4073 TM.tmFirstChar = winfnt_header.first_char;
4074 TM.tmLastChar = winfnt_header.last_char;
4075 TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
4076 TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
4077 TM.tmItalic = winfnt_header.italic;
4078 TM.tmUnderlined = font->underline;
4079 TM.tmStruckOut = font->strikeout;
4080 TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
4081 TM.tmCharSet = winfnt_header.charset;
4082 }
4083 else
4084 #endif
4085 {
4086 TM.tmAscent = ft_face->size->metrics.ascender >> 6;
4087 TM.tmDescent = -ft_face->size->metrics.descender >> 6;
4088 TM.tmHeight = TM.tmAscent + TM.tmDescent;
4089 TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
4090 TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
4091 TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
4092 TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
4093 TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
4094 TM.tmOverhang = 0;
4095 TM.tmDigitizedAspectX = 96; /* FIXME */
4096 TM.tmDigitizedAspectY = 96; /* FIXME */
4097 TM.tmFirstChar = 1;
4098 TM.tmLastChar = 255;
4099 TM.tmDefaultChar = 32;
4100 TM.tmBreakChar = 32;
4101 TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
4102 TM.tmUnderlined = font->underline;
4103 TM.tmStruckOut = font->strikeout;
4104 /* NB inverted meaning of TMPF_FIXED_PITCH */
4105 TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
4106 TM.tmCharSet = font->charset;
4107 }
4108 #undef TM
4109
4110 return TRUE;
4111 }
4112
4113 /*************************************************************
4114 * WineEngGetTextMetrics
4115 *
4116 */
4117 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
4118 {
4119 if(!font->potm) {
4120 if(!WineEngGetOutlineTextMetrics(font, 0, NULL))
4121 if(!get_bitmap_text_metrics(font))
4122 return FALSE;
4123 }
4124 if(!font->potm) return FALSE;
4125 memcpy(ptm, &font->potm->otmTextMetrics, sizeof(*ptm));
4126
4127 if (font->aveWidth) {
4128 ptm->tmAveCharWidth = font->aveWidth * font->font_desc.matrix.eM11;
4129 }
4130 return TRUE;
4131 }
4132
4133
4134 /*************************************************************
4135 * WineEngGetOutlineTextMetrics
4136 *
4137 */
4138 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
4139 OUTLINETEXTMETRICW *potm)
4140 {
4141 FT_Face ft_face = font->ft_face;
4142 UINT needed, lenfam, lensty, ret;
4143 TT_OS2 *pOS2;
4144 TT_HoriHeader *pHori;
4145 TT_Postscript *pPost;
4146 FT_Fixed x_scale, y_scale;
4147 WCHAR *family_nameW, *style_nameW;
4148 static const WCHAR spaceW[] = {' ', '\0'};
4149 char *cp;
4150 INT ascent, descent;
4151
4152 TRACE("font=%p\n", font);
4153
4154 if(!FT_IS_SCALABLE(ft_face))
4155 return 0;
4156
4157 if(font->potm) {
4158 if(cbSize >= font->potm->otmSize)
4159 memcpy(potm, font->potm, font->potm->otmSize);
4160 return font->potm->otmSize;
4161 }
4162
4163
4164 needed = sizeof(*potm);
4165
4166 lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
4167 family_nameW = strdupW(font->name);
4168
4169 lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
4170 * sizeof(WCHAR);
4171 style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
4172 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
4173 style_nameW, lensty/sizeof(WCHAR));
4174
4175 /* These names should be read from the TT name table */
4176
4177 /* length of otmpFamilyName */
4178 needed += lenfam;
4179
4180 /* length of otmpFaceName */
4181 if(!strcasecmp(ft_face->style_name, "regular")) {
4182 needed += lenfam; /* just the family name */
4183 } else {
4184 needed += lenfam + lensty; /* family + " " + style */
4185 }
4186
4187 /* length of otmpStyleName */
4188 needed += lensty;
4189
4190 /* length of otmpFullName */
4191 needed += lenfam + lensty;
4192
4193
4194 x_scale = ft_face->size->metrics.x_scale;
4195 y_scale = ft_face->size->metrics.y_scale;
4196
4197 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
4198 if(!pOS2) {
4199 FIXME("Can't find OS/2 table - not TT font?\n");
4200 ret = 0;
4201 goto end;
4202 }
4203
4204 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
4205 if(!pHori) {
4206 FIXME("Can't find HHEA table - not TT font?\n");
4207 ret = 0;
4208 goto end;
4209 }
4210
4211 pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
4212
4213 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",
4214 pOS2->usWinAscent, pOS2->usWinDescent,
4215 pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
4216 ft_face->ascender, ft_face->descender, ft_face->height,
4217 pHori->Ascender, pHori->Descender, pHori->Line_Gap,
4218 ft_face->bbox.yMax, ft_face->bbox.yMin);
4219
4220 font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
4221 font->potm->otmSize = needed;
4222
4223 #define TM font->potm->otmTextMetrics
4224
4225 if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
4226 ascent = pHori->Ascender;
4227 descent = -pHori->Descender;
4228 } else {
4229 ascent = pOS2->usWinAscent;
4230 descent = pOS2->usWinDescent;
4231 }
4232
4233 if(font->yMax) {
4234 TM.tmAscent = font->yMax;
4235 TM.tmDescent = -font->yMin;
4236 TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
4237 } else {
4238 TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
4239 TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
4240 TM.tmInternalLeading = (pFT_MulFix(ascent + descent
4241 - ft_face->units_per_EM, y_scale) + 32) >> 6;
4242 }
4243
4244 TM.tmHeight = TM.tmAscent + TM.tmDescent;
4245
4246 /* MSDN says:
4247 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
4248 */
4249 TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
4250 ((ascent + descent) -
4251 (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
4252
4253 TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
4254 if (TM.tmAveCharWidth == 0) {
4255 TM.tmAveCharWidth = 1;
4256 }
4257 TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
4258 TM.tmWeight = font->fake_bold ? FW_BOLD : pOS2->usWeightClass;
4259 TM.tmOverhang = 0;
4260 TM.tmDigitizedAspectX = 300;
4261 TM.tmDigitizedAspectY = 300;
4262 /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
4263 * symbol range to 0 - f0ff
4264 */
4265 if (font->charset == SYMBOL_CHARSET)
4266 TM.tmFirstChar = 0;
4267 else
4268 TM.tmFirstChar = pOS2->usFirstCharIndex;
4269 TM.tmLastChar = pOS2->usLastCharIndex;
4270 TM.tmDefaultChar = pOS2->usDefaultChar ? pOS2->usDefaultChar : 0x1f;
4271 TM.tmBreakChar = pOS2->usBreakChar ? pOS2->usBreakChar : ' ';
4272 TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
4273 TM.tmUnderlined = font->underline;
4274 TM.tmStruckOut = font->strikeout;
4275
4276 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
4277 if(!FT_IS_FIXED_WIDTH(ft_face) &&
4278 (pOS2->version == 0xFFFFU ||
4279 pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
4280 TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
4281 else
4282 TM.tmPitchAndFamily = 0;
4283
4284 switch(pOS2->panose[PAN_FAMILYTYPE_INDEX]) {
4285 case PAN_FAMILY_SCRIPT:
4286 TM.tmPitchAndFamily |= FF_SCRIPT;
4287 break;
4288 case PAN_FAMILY_DECORATIVE:
4289 case PAN_FAMILY_PICTORIAL:
4290 TM.tmPitchAndFamily |= FF_DECORATIVE;
4291 break;
4292 case PAN_FAMILY_TEXT_DISPLAY:
4293 if(TM.tmPitchAndFamily == 0) /* fixed */
4294 TM.tmPitchAndFamily = FF_MODERN;
4295 else {
4296 switch(pOS2->panose[PAN_SERIFSTYLE_INDEX]) {
4297 case PAN_SERIF_NORMAL_SANS:
4298 case PAN_SERIF_OBTUSE_SANS:
4299 case PAN_SERIF_PERP_SANS:
4300 TM.tmPitchAndFamily |= FF_SWISS;
4301 break;
4302 default:
4303 TM.tmPitchAndFamily |= FF_ROMAN;
4304 }
4305 }
4306 break;
4307 default:
4308 TM.tmPitchAndFamily |= FF_DONTCARE;
4309 }
4310
4311 if(FT_IS_SCALABLE(ft_face))
4312 TM.tmPitchAndFamily |= TMPF_VECTOR;
4313
4314 if(FT_IS_SFNT(ft_face))
4315 {
4316 if (font->ntmFlags & NTM_PS_OPENTYPE)
4317 TM.tmPitchAndFamily |= TMPF_DEVICE;
4318 else
4319 TM.tmPitchAndFamily |= TMPF_TRUETYPE;
4320 }
4321
4322 TM.tmCharSet = font->charset;
4323 #undef TM
4324
4325 font->potm->otmFiller = 0;
4326 memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
4327 font->potm->otmfsSelection = pOS2->fsSelection;
4328 font->potm->otmfsType = pOS2->fsType;
4329 font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
4330 font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
4331 font->potm->otmItalicAngle = 0; /* POST table */
4332 font->potm->otmEMSquare = ft_face->units_per_EM;
4333 font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
4334 font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
4335 font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
4336 font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
4337 font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
4338 font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
4339 font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
4340 font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
4341 font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
4342 font->potm->otmMacAscent = 0; /* where do these come from ? */
4343 font->potm->otmMacDescent = 0;
4344 font->potm->otmMacLineGap = 0;
4345 font->potm->otmusMinimumPPEM = 0; /* TT Header */
4346 font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
4347 font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
4348 font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
4349 font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
4350 font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
4351 font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
4352 font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
4353 font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
4354 font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
4355 font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
4356 if(!pPost) {
4357 font->potm->otmsUnderscoreSize = 0;
4358 font->potm->otmsUnderscorePosition = 0;
4359 } else {
4360 font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
4361 font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
4362 }
4363
4364 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
4365 cp = (char*)font->potm + sizeof(*font->potm);
4366 font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
4367 strcpyW((WCHAR*)cp, family_nameW);
4368 cp += lenfam;
4369 font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
4370 strcpyW((WCHAR*)cp, style_nameW);
4371 cp += lensty;
4372 font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
4373 strcpyW((WCHAR*)cp, family_nameW);
4374 if(strcasecmp(ft_face->style_name, "regular")) {
4375 strcatW((WCHAR*)cp, spaceW);
4376 strcatW((WCHAR*)cp, style_nameW);
4377 cp += lenfam + lensty;
4378 } else
4379 cp += lenfam;
4380 font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
4381 strcpyW((WCHAR*)cp, family_nameW);
4382 strcatW((WCHAR*)cp, spaceW);
4383 strcatW((WCHAR*)cp, style_nameW);
4384 ret = needed;
4385
4386 if(potm && needed <= cbSize)
4387 memcpy(potm, font->potm, font->potm->otmSize);
4388
4389 end:
4390 HeapFree(GetProcessHeap(), 0, style_nameW);
4391 HeapFree(GetProcessHeap(), 0, family_nameW);
4392
4393 return ret;
4394 }
4395
4396 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
4397 {
4398 HFONTLIST *hfontlist;
4399 child->font = alloc_font();
4400 child->font->ft_face = OpenFontFace(child->font, child->face, 0, -font->ppem);
4401 if(!child->font->ft_face)
4402 {
4403 free_font(child->font);
4404 child->font = NULL;
4405 return FALSE;
4406 }
4407
4408 child->font->ntmFlags = child->face->ntmFlags;
4409 child->font->orientation = font->orientation;
4410 hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
4411 hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
4412 list_add_head(&child->font->hfontlist, &hfontlist->entry);
4413 child->font->base_font = font;
4414 list_add_head(&child_font_list, &child->font->entry);
4415 TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
4416 return TRUE;
4417 }
4418
4419 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
4420 {
4421 FT_UInt g;
4422 CHILD_FONT *child_font;
4423
4424 if(font->base_font)
4425 font = font->base_font;
4426
4427 *linked_font = font;
4428
4429 if((*glyph = get_glyph_index(font, c)))
4430 return TRUE;
4431
4432 LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
4433 {
4434 if(!child_font->font)
4435 if(!load_child_font(font, child_font))
4436 continue;
4437
4438 if(!child_font->font->ft_face)
4439 continue;
4440 g = get_glyph_index(child_font->font, c);
4441 if(g)
4442 {
4443 *glyph = g;
4444 *linked_font = child_font->font;
4445 return TRUE;
4446 }
4447 }
4448 return FALSE;
4449 }
4450
4451 /*************************************************************
4452 * WineEngGetCharWidth
4453 *
4454 */
4455 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
4456 LPINT buffer)
4457 {
4458 UINT c;
4459 GLYPHMETRICS gm;
4460 FT_UInt glyph_index;
4461 GdiFont *linked_font;
4462
4463 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
4464
4465 for(c = firstChar; c <= lastChar; c++) {
4466 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
4467 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
4468 &gm, 0, NULL, NULL);
4469 buffer[c - firstChar] = FONT_GM(linked_font,glyph_index)->adv;
4470 }
4471 return TRUE;
4472 }
4473
4474 /*************************************************************
4475 * WineEngGetCharABCWidths
4476 *
4477 */
4478 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
4479 LPABC buffer)
4480 {
4481 UINT c;
4482 GLYPHMETRICS gm;
4483 FT_UInt glyph_index;
4484 GdiFont *linked_font;
4485
4486 TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
4487
4488 if(!FT_IS_SCALABLE(font->ft_face))
4489 return FALSE;
4490
4491 for(c = firstChar; c <= lastChar; c++) {
4492 get_glyph_index_linked(font, c, &linked_font, &glyph_index);
4493 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
4494 &gm, 0, NULL, NULL);
4495 buffer[c - firstChar].abcA = FONT_GM(linked_font,glyph_index)->lsb;
4496 buffer[c - firstChar].abcB = FONT_GM(linked_font,glyph_index)->bbx;
4497 buffer[c - firstChar].abcC = FONT_GM(linked_font,glyph_index)->adv - FONT_GM(linked_font,glyph_index)->lsb -
4498 FONT_GM(linked_font,glyph_index)->bbx;
4499 }
4500 return TRUE;
4501 }
4502
4503 /*************************************************************
4504 * WineEngGetCharABCWidthsI
4505 *
4506 */
4507 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
4508 LPABC buffer)
4509 {
4510 UINT c;
4511 GLYPHMETRICS gm;
4512 FT_UInt glyph_index;
4513 GdiFont *linked_font;
4514
4515 if(!FT_IS_SCALABLE(font->ft_face))
4516 return FALSE;
4517
4518 get_glyph_index_linked(font, 'a', &linked_font, &glyph_index);
4519 if (!pgi)
4520 for(c = firstChar; c < firstChar+count; c++) {
4521 WineEngGetGlyphOutline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
4522 &gm, 0, NULL, NULL);
4523 buffer[c - firstChar].abcA = FONT_GM(linked_font,c)->lsb;
4524 buffer[c - firstChar].abcB = FONT_GM(linked_font,c)->bbx;
4525 buffer[c - firstChar].abcC = FONT_GM(linked_font,c)->adv - FONT_GM(linked_font,c)->lsb
4526 - FONT_GM(linked_font,c)->bbx;
4527 }
4528 else
4529 for(c = 0; c < count; c++) {
4530 WineEngGetGlyphOutline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
4531 &gm, 0, NULL, NULL);
4532 buffer[c].abcA = FONT_GM(linked_font,pgi[c])->lsb;
4533 buffer[c].abcB = FONT_GM(linked_font,pgi[c])->bbx;
4534 buffer[c].abcC = FONT_GM(linked_font,pgi[c])->adv
4535 - FONT_GM(linked_font,pgi[c])->lsb - FONT_GM(linked_font,pgi[c])->bbx;
4536 }
4537
4538 return TRUE;
4539 }
4540
4541 /*************************************************************
4542 * WineEngGetTextExtentExPoint
4543 *
4544 */
4545 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
4546 INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
4547 {
4548 INT idx;
4549 INT nfit = 0, ext;
4550 GLYPHMETRICS gm;
4551 TEXTMETRICW tm;
4552 FT_UInt glyph_index;
4553 GdiFont *linked_font;
4554
4555 TRACE("%p, %s, %d, %d, %p\n", font, debugstr_wn(wstr, count), count,
4556 max_ext, size);
4557
4558 size->cx = 0;
4559 WineEngGetTextMetrics(font, &tm);
4560 size->cy = tm.tmHeight;
4561
4562 for(idx = 0; idx < count; idx++) {
4563 get_glyph_index_linked(font, wstr[idx], &linked_font, &glyph_index);
4564 WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
4565 &gm, 0, NULL, NULL);
4566 size->cx += FONT_GM(linked_font,glyph_index)->adv;
4567 ext = size->cx;
4568 if (! pnfit || ext <= max_ext) {
4569 ++nfit;
4570 if (dxs)
4571 dxs[idx] = ext;
4572 }
4573 }
4574
4575 if (pnfit)
4576 *pnfit = nfit;
4577
4578 TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
4579 return TRUE;
4580 }
4581
4582 /*************************************************************
4583 * WineEngGetTextExtentPointI
4584 *
4585 */
4586 BOOL WineEngGetTextExtentPointI(GdiFont *font, const WORD *indices, INT count,
4587 LPSIZE size)
4588 {
4589 INT idx;
4590 GLYPHMETRICS gm;
4591 TEXTMETRICW tm;
4592
4593 TRACE("%p, %p, %d, %p\n", font, indices, count, size);
4594
4595 size->cx = 0;
4596 WineEngGetTextMetrics(font, &tm);
4597 size->cy = tm.tmHeight;
4598
4599 for(idx = 0; idx < count; idx++) {
4600 WineEngGetGlyphOutline(font, indices[idx],
4601 GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL,
4602 NULL);
4603 size->cx += FONT_GM(font,indices[idx])->adv;
4604 }
4605 TRACE("return %d,%d\n", size->cx, size->cy);
4606 return TRUE;
4607 }
4608
4609 /*************************************************************
4610 * WineEngGetFontData
4611 *
4612 */
4613 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
4614 DWORD cbData)
4615 {
4616 FT_Face ft_face = font->ft_face;
4617 FT_ULong len;
4618 FT_Error err;
4619
4620 TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
4621 font, LOBYTE(LOWORD(table)), HIBYTE(LOWORD(table)),
4622 LOBYTE(HIWORD(table)), HIBYTE(HIWORD(table)), offset, buf, cbData);
4623
4624 if(!FT_IS_SFNT(ft_face))
4625 return GDI_ERROR;
4626
4627 if(!buf || !cbData)
4628 len = 0;
4629 else
4630 len = cbData;
4631
4632 if(table) { /* MS tags differ in endidness from FT ones */
4633 table = table >> 24 | table << 24 |
4634 (table >> 8 & 0xff00) | (table << 8 & 0xff0000);
4635 }
4636
4637 /* make sure value of len is the value freetype says it needs */
4638 if(buf && len)
4639 {
4640 FT_ULong needed = 0;
4641 err = load_sfnt_table(ft_face, table, offset, NULL, &needed);
4642 if( !err && needed < len) len = needed;
4643 }
4644 err = load_sfnt_table(ft_face, table, offset, buf, &len);
4645
4646 if(err) {
4647 TRACE("Can't find table %c%c%c%c\n",
4648 /* bytes were reversed */
4649 HIBYTE(HIWORD(table)), LOBYTE(HIWORD(table)),
4650 HIBYTE(LOWORD(table)), LOBYTE(LOWORD(table)));
4651 return GDI_ERROR;
4652 }
4653 return len;
4654 }
4655
4656 /*************************************************************
4657 * WineEngGetTextFace
4658 *
4659 */
4660 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
4661 {
4662 if(str) {
4663 lstrcpynW(str, font->name, count);
4664 return strlenW(font->name);
4665 } else
4666 return strlenW(font->name) + 1;
4667 }
4668
4669 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
4670 {
4671 if (fs) memcpy(fs, &font->fs, sizeof(FONTSIGNATURE));
4672 return font->charset;
4673 }
4674
4675 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
4676 {
4677 GdiFont *font = dc->gdiFont, *linked_font;
4678 struct list *first_hfont;
4679 BOOL ret;
4680
4681 ret = get_glyph_index_linked(font, c, &linked_font, glyph);
4682 TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
4683 if(font == linked_font)
4684 *new_hfont = dc->hFont;
4685 else
4686 {
4687 first_hfont = list_head(&linked_font->hfontlist);
4688 *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
4689 }
4690
4691 return ret;
4692 }
4693
4694 /* Retrieve a list of supported Unicode ranges for a given font.
4695 * Can be called with NULL gs to calculate the buffer size. Returns
4696 * the number of ranges found.
4697 */
4698 static DWORD get_font_unicode_ranges(FT_Face face, GLYPHSET *gs)
4699 {
4700 DWORD num_ranges = 0;
4701
4702 if (face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
4703 {
4704 FT_UInt glyph_code;
4705 FT_ULong char_code, char_code_prev;
4706
4707 glyph_code = 0;
4708 char_code_prev = char_code = pFT_Get_First_Char(face, &glyph_code);
4709
4710 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
4711 face->num_glyphs, glyph_code, char_code);
4712
4713 if (!glyph_code) return 0;
4714
4715 if (gs)
4716 {
4717 gs->ranges[0].wcLow = (USHORT)char_code;
4718 gs->ranges[0].cGlyphs = 0;
4719 gs->cGlyphsSupported = 0;
4720 }
4721
4722 num_ranges = 1;
4723 while (glyph_code)
4724 {
4725 if (char_code < char_code_prev)
4726 {
4727 ERR("expected increasing char code from FT_Get_Next_Char\n");
4728 return 0;
4729 }
4730 if (char_code - char_code_prev > 1)
4731 {
4732 num_ranges++;
4733 if (gs)
4734 {
4735 gs->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
4736 gs->ranges[num_ranges - 1].cGlyphs = 1;
4737 gs->cGlyphsSupported++;
4738 }
4739 }
4740 else if (gs)
4741 {
4742 gs->ranges[num_ranges - 1].cGlyphs++;
4743 gs->cGlyphsSupported++;
4744 }
4745 char_code_prev = char_code;
4746 char_code = pFT_Get_Next_Char(face, char_code, &glyph_code);
4747 }
4748 }
4749 else
4750 FIXME("encoding %u not supported\n", face->charmap->encoding);
4751
4752 return num_ranges;
4753 }
4754
4755 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
4756 {
4757 DWORD size = 0;
4758 DWORD num_ranges = get_font_unicode_ranges(font->ft_face, glyphset);
4759
4760 size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
4761 if (glyphset)
4762 {
4763 glyphset->cbThis = size;
4764 glyphset->cRanges = num_ranges;
4765 }
4766 return size;
4767 }
4768
4769 /*************************************************************
4770 * FontIsLinked
4771 */
4772 BOOL WineEngFontIsLinked(GdiFont *font)
4773 {
4774 return !list_empty(&font->child_fonts);
4775 }
4776
4777 static BOOL is_hinting_enabled(void)
4778 {
4779 /* Use the >= 2.2.0 function if available */
4780 if(pFT_Get_TrueType_Engine_Type)
4781 {
4782 FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
4783 return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
4784 }
4785 #ifdef FT_DRIVER_HAS_HINTER
4786 else
4787 {
4788 FT_Module mod;
4789
4790 /* otherwise if we've been compiled with < 2.2.0 headers
4791 use the internal macro */
4792 mod = pFT_Get_Module(library, "truetype");
4793 if(mod && FT_DRIVER_HAS_HINTER(mod))
4794 return TRUE;
4795 }
4796 #endif
4797
4798 return FALSE;
4799 }
4800
4801 /*************************************************************************
4802 * GetRasterizerCaps (GDI32.@)
4803 */
4804 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
4805 {
4806 static int hinting = -1;
4807
4808 if(hinting == -1)
4809 {
4810 hinting = is_hinting_enabled();
4811 TRACE("hinting is %senabled\n", hinting ? "" : "NOT ");
4812 }
4813
4814 lprs->nSize = sizeof(RASTERIZER_STATUS);
4815 lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
4816 lprs->nLanguageID = 0;
4817 return TRUE;
4818 }
4819
4820 /*************************************************************************
4821 * Kerning support for TrueType fonts
4822 */
4823 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
4824
4825 struct TT_kern_table
4826 {
4827 USHORT version;
4828 USHORT nTables;
4829 };
4830
4831 struct TT_kern_subtable
4832 {
4833 USHORT version;
4834 USHORT length;
4835 union
4836 {
4837 USHORT word;
4838 struct
4839 {
4840 USHORT horizontal : 1;
4841 USHORT minimum : 1;
4842 USHORT cross_stream: 1;
4843 USHORT override : 1;
4844 USHORT reserved1 : 4;
4845 USHORT format : 8;
4846 } bits;
4847 } coverage;
4848 };
4849
4850 struct TT_format0_kern_subtable
4851 {
4852 USHORT nPairs;
4853 USHORT searchRange;
4854 USHORT entrySelector;
4855 USHORT rangeShift;
4856 };
4857
4858 struct TT_kern_pair
4859 {
4860 USHORT left;
4861 USHORT right;
4862 short value;
4863 };
4864
4865 static DWORD parse_format0_kern_subtable(GdiFont *font,
4866 const struct TT_format0_kern_subtable *tt_f0_ks,
4867 const USHORT *glyph_to_char,
4868 KERNINGPAIR *kern_pair, DWORD cPairs)
4869 {
4870 USHORT i, nPairs;
4871 const struct TT_kern_pair *tt_kern_pair;
4872
4873 TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
4874
4875 nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
4876
4877 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
4878 nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
4879 GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
4880
4881 if (!kern_pair || !cPairs)
4882 return nPairs;
4883
4884 tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
4885
4886 nPairs = min(nPairs, cPairs);
4887
4888 for (i = 0; i < nPairs; i++)
4889 {
4890 kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
4891 kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
4892 /* this algorithm appears to better match what Windows does */
4893 kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
4894 if (kern_pair->iKernAmount < 0)
4895 {
4896 kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
4897 kern_pair->iKernAmount -= font->ppem;
4898 }
4899 else if (kern_pair->iKernAmount > 0)
4900 {
4901 kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
4902 kern_pair->iKernAmount += font->ppem;
4903 }
4904 kern_pair->iKernAmount /= font->ft_face->units_per_EM;
4905
4906 TRACE("left %u right %u value %d\n",
4907 kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
4908
4909 kern_pair++;
4910 }
4911 TRACE("copied %u entries\n", nPairs);
4912 return nPairs;
4913 }
4914
4915 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
4916 {
4917 DWORD length;
4918 void *buf;
4919 const struct TT_kern_table *tt_kern_table;
4920 const struct TT_kern_subtable *tt_kern_subtable;
4921 USHORT i, nTables;
4922 USHORT *glyph_to_char;
4923
4924 if (font->total_kern_pairs != (DWORD)-1)
4925 {
4926 if (cPairs && kern_pair)
4927 {
4928 cPairs = min(cPairs, font->total_kern_pairs);
4929 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
4930 return cPairs;
4931 }
4932 return font->total_kern_pairs;
4933 }
4934
4935 font->total_kern_pairs = 0;
4936
4937 length = WineEngGetFontData(font, MS_KERN_TAG, 0, NULL, 0);
4938
4939 if (length == GDI_ERROR)
4940 {
4941 TRACE("no kerning data in the font\n");
4942 return 0;
4943 }
4944
4945 buf = HeapAlloc(GetProcessHeap(), 0, length);
4946 if (!buf)
4947 {
4948 WARN("Out of memory\n");
4949 return 0;
4950 }
4951
4952 WineEngGetFontData(font, MS_KERN_TAG, 0, buf, length);
4953
4954 /* build a glyph index to char code map */
4955 glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
4956 if (!glyph_to_char)
4957 {
4958 WARN("Out of memory allocating a glyph index to char code map\n");
4959 HeapFree(GetProcessHeap(), 0, buf);
4960 return 0;
4961 }
4962
4963 if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
4964 {
4965 FT_UInt glyph_code;
4966 FT_ULong char_code;
4967
4968 glyph_code = 0;
4969 char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
4970
4971 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
4972 font->ft_face->num_glyphs, glyph_code, char_code);
4973
4974 while (glyph_code)
4975 {
4976 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
4977
4978 /* FIXME: This doesn't match what Windows does: it does some fancy
4979 * things with duplicate glyph index to char code mappings, while
4980 * we just avoid overriding existing entries.
4981 */
4982 if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
4983 glyph_to_char[glyph_code] = (USHORT)char_code;
4984
4985 char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
4986 }
4987 }
4988 else
4989 {
4990 ULONG n;
4991
4992 FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
4993 for (n = 0; n <= 65535; n++)
4994 glyph_to_char[n] = (USHORT)n;
4995 }
4996
4997 tt_kern_table = buf;
4998 nTables = GET_BE_WORD(tt_kern_table->nTables);
4999 TRACE("version %u, nTables %u\n",
5000 GET_BE_WORD(tt_kern_table->version), nTables);
5001
5002 tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
5003
5004 for (i = 0; i < nTables; i++)
5005 {
5006 struct TT_kern_subtable tt_kern_subtable_copy;
5007
5008 tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
5009 tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
5010 tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
5011
5012 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
5013 tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
5014 tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
5015
5016 /* According to the TrueType specification this is the only format
5017 * that will be properly interpreted by Windows and OS/2
5018 */
5019 if (tt_kern_subtable_copy.coverage.bits.format == 0)
5020 {
5021 DWORD new_chunk, old_total = font->total_kern_pairs;
5022
5023 new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
5024 glyph_to_char, NULL, 0);
5025 font->total_kern_pairs += new_chunk;
5026
5027 if (!font->kern_pairs)
5028 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
5029 font->total_kern_pairs * sizeof(*font->kern_pairs));
5030 else
5031 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
5032 font->total_kern_pairs * sizeof(*font->kern_pairs));
5033
5034 parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
5035 glyph_to_char, font->kern_pairs + old_total, new_chunk);
5036 }
5037 else
5038 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
5039
5040 tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
5041 }
5042
5043 HeapFree(GetProcessHeap(), 0, glyph_to_char);
5044 HeapFree(GetProcessHeap(), 0, buf);
5045
5046 if (cPairs && kern_pair)
5047 {
5048 cPairs = min(cPairs, font->total_kern_pairs);
5049 memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
5050 return cPairs;
5051 }
5052 return font->total_kern_pairs;
5053 }
5054
5055 #else /* HAVE_FREETYPE */
5056
5057 /*************************************************************************/
5058
5059 BOOL WineEngInit(void)
5060 {
5061 return FALSE;
5062 }
5063 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
5064 {
5065 return NULL;
5066 }
5067 BOOL WineEngDestroyFontInstance(HFONT hfont)
5068 {
5069 return FALSE;
5070 }
5071
5072 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
5073 {
5074 return 1;
5075 }
5076
5077 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
5078 LPWORD pgi, DWORD flags)
5079 {
5080 return GDI_ERROR;
5081 }
5082
5083 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
5084 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
5085 const MAT2* lpmat)
5086 {
5087 ERR("called but we don't have FreeType\n");
5088 return GDI_ERROR;
5089 }
5090
5091 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
5092 {
5093 ERR("called but we don't have FreeType\n");
5094 return FALSE;
5095 }
5096
5097 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
5098 OUTLINETEXTMETRICW *potm)
5099 {
5100 ERR("called but we don't have FreeType\n");
5101 return 0;
5102 }
5103
5104 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
5105 LPINT buffer)
5106 {
5107 ERR("called but we don't have FreeType\n");
5108 return FALSE;
5109 }
5110
5111 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
5112 LPABC buffer)
5113 {
5114 ERR("called but we don't have FreeType\n");
5115 return FALSE;
5116 }
5117
5118 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
5119 LPABC buffer)
5120 {
5121 ERR("called but we don't have FreeType\n");
5122 return FALSE;
5123 }
5124
5125 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
5126 INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
5127 {
5128 ERR("called but we don't have FreeType\n");
5129 return FALSE;
5130 }
5131
5132 BOOL WineEngGetTextExtentPointI(GdiFont *font, const WORD *indices, INT count,
5133 LPSIZE size)
5134 {
5135 ERR("called but we don't have FreeType\n");
5136 return FALSE;
5137 }
5138
5139 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
5140 DWORD cbData)
5141 {
5142 ERR("called but we don't have FreeType\n");
5143 return GDI_ERROR;
5144 }
5145
5146 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
5147 {
5148 ERR("called but we don't have FreeType\n");
5149 return 0;
5150 }
5151
5152 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
5153 {
5154 FIXME(":stub\n");
5155 return 1;
5156 }
5157
5158 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
5159 {
5160 FIXME(":stub\n");
5161 return TRUE;
5162 }
5163
5164 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
5165 {
5166 FIXME(":stub\n");
5167 return NULL;
5168 }
5169
5170 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
5171 {
5172 FIXME(":stub\n");
5173 return DEFAULT_CHARSET;
5174 }
5175
5176 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
5177 {
5178 return FALSE;
5179 }
5180
5181 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
5182 {
5183 FIXME("(%p, %p): stub\n", font, glyphset);
5184 return 0;
5185 }
5186
5187 BOOL WineEngFontIsLinked(GdiFont *font)
5188 {
5189 return FALSE;
5190 }
5191
5192 /*************************************************************************
5193 * GetRasterizerCaps (GDI32.@)
5194 */
5195 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
5196 {
5197 lprs->nSize = sizeof(RASTERIZER_STATUS);
5198 lprs->wFlags = 0;
5199 lprs->nLanguageID = 0;
5200 return TRUE;
5201 }
5202
5203 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
5204 {
5205 ERR("called but we don't have FreeType\n");
5206 return 0;
5207 }
5208
5209 #endif /* HAVE_FREETYPE */
Maarten's multimedia branch