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