?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus/tests: Added pen dash array tests.
[wine.git] / dlls / gdi32 / freetype.c
blobcdd23ef68d09c431d0f2b832fd54864ed7ad9dad
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 HAVE_FT_TRUETYPEENGINETYPE
132 typedef enum
133 {
134 FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
135 FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
136 FT_TRUETYPE_ENGINE_TYPE_PATENTED
137 } FT_TrueTypeEngineType;
138 #endif
139
140 static FT_Library library = 0;
141 typedef struct
142 {
143 FT_Int major;
144 FT_Int minor;
145 FT_Int patch;
146 } FT_Version_t;
147 static FT_Version_t FT_Version;
148 static DWORD FT_SimpleVersion;
149
150 static void *ft_handle = NULL;
151
152 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
153 MAKE_FUNCPTR(FT_Vector_Unit);
154 MAKE_FUNCPTR(FT_Done_Face);
155 MAKE_FUNCPTR(FT_Get_Char_Index);
156 MAKE_FUNCPTR(FT_Get_Module);
157 MAKE_FUNCPTR(FT_Get_Sfnt_Name);
158 MAKE_FUNCPTR(FT_Get_Sfnt_Name_Count);
159 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
160 MAKE_FUNCPTR(FT_Init_FreeType);
161 MAKE_FUNCPTR(FT_Load_Glyph);
162 MAKE_FUNCPTR(FT_Matrix_Multiply);
163 MAKE_FUNCPTR(FT_MulFix);
164 MAKE_FUNCPTR(FT_New_Face);
165 MAKE_FUNCPTR(FT_New_Memory_Face);
166 MAKE_FUNCPTR(FT_Outline_Get_Bitmap);
167 MAKE_FUNCPTR(FT_Outline_Transform);
168 MAKE_FUNCPTR(FT_Outline_Translate);
169 MAKE_FUNCPTR(FT_Select_Charmap);
170 MAKE_FUNCPTR(FT_Set_Pixel_Sizes);
171 MAKE_FUNCPTR(FT_Vector_Transform);
172 static void (*pFT_Library_Version)(FT_Library,FT_Int*,FT_Int*,FT_Int*);
173 static FT_Error (*pFT_Load_Sfnt_Table)(FT_Face,FT_ULong,FT_Long,FT_Byte*,FT_ULong*);
174 static FT_ULong (*pFT_Get_First_Char)(FT_Face,FT_UInt*);
175 static FT_ULong (*pFT_Get_Next_Char)(FT_Face,FT_ULong,FT_UInt*);
176 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type)(FT_Library);
177 #ifdef HAVE_FREETYPE_FTWINFNT_H
178 MAKE_FUNCPTR(FT_Get_WinFNT_Header);
179 #endif
180
181 #ifdef SONAME_LIBFONTCONFIG
182 #include <fontconfig/fontconfig.h>
183 MAKE_FUNCPTR(FcConfigGetCurrent);
184 MAKE_FUNCPTR(FcFontList);
185 MAKE_FUNCPTR(FcFontSetDestroy);
186 MAKE_FUNCPTR(FcInit);
187 MAKE_FUNCPTR(FcObjectSetAdd);
188 MAKE_FUNCPTR(FcObjectSetCreate);
189 MAKE_FUNCPTR(FcObjectSetDestroy);
190 MAKE_FUNCPTR(FcPatternCreate);
191 MAKE_FUNCPTR(FcPatternDestroy);
192 MAKE_FUNCPTR(FcPatternGetBool);
193 MAKE_FUNCPTR(FcPatternGetString);
194 #endif
195
196 #undef MAKE_FUNCPTR
197
198 #ifndef ft_encoding_none
199 #define FT_ENCODING_NONE ft_encoding_none
200 #endif
201 #ifndef ft_encoding_ms_symbol
202 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
203 #endif
204 #ifndef ft_encoding_unicode
205 #define FT_ENCODING_UNICODE ft_encoding_unicode
206 #endif
207 #ifndef ft_encoding_apple_roman
208 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
209 #endif
210
211 #ifdef WORDS_BIGENDIAN
212 #define GET_BE_WORD(x) (x)
213 #else
214 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
215 #endif
216
217 /* This is bascially a copy of FT_Bitmap_Size with an extra element added */
218 typedef struct {
219 FT_Short height;
220 FT_Short width;
221 FT_Pos size;
222 FT_Pos x_ppem;
223 FT_Pos y_ppem;
224 FT_Short internal_leading;
225 } Bitmap_Size;
226
227 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
228 So to let this compile on older versions of FreeType we'll define the
229 new structure here. */
230 typedef struct {
231 FT_Short height, width;
232 FT_Pos size, x_ppem, y_ppem;
233 } My_FT_Bitmap_Size;
234
235 typedef struct tagFace {
236 struct list entry;
237 WCHAR *StyleName;
238 char *file;
239 FT_Long face_index;
240 BOOL Italic;
241 BOOL Bold;
242 FONTSIGNATURE fs;
243 FONTSIGNATURE fs_links;
244 FT_Fixed font_version;
245 BOOL scalable;
246 Bitmap_Size size; /* set if face is a bitmap */
247 BOOL external; /* TRUE if we should manually add this font to the registry */
248 struct tagFamily *family;
249 } Face;
250
251 typedef struct tagFamily {
252 struct list entry;
253 const WCHAR *FamilyName;
254 struct list faces;
255 } Family;
256
257 typedef struct {
258 GLYPHMETRICS gm;
259 INT adv; /* These three hold to widths of the unrotated chars */
260 INT lsb;
261 INT bbx;
262 BOOL init;
263 } GM;
264
265 typedef struct {
266 FLOAT eM11, eM12;
267 FLOAT eM21, eM22;
268 } FMAT2;
269
270 typedef struct {
271 DWORD hash;
272 LOGFONTW lf;
273 FMAT2 matrix;
274 BOOL can_use_bitmap;
275 } FONT_DESC;
276
277 typedef struct tagHFONTLIST {
278 struct list entry;
279 HFONT hfont;
280 } HFONTLIST;
281
282 typedef struct {
283 struct list entry;
284 char *file_name;
285 INT index;
286 GdiFont *font;
287 } CHILD_FONT;
288
289 struct tagGdiFont {
290 struct list entry;
291 FT_Face ft_face;
292 struct font_mapping *mapping;
293 LPWSTR name;
294 int charset;
295 int codepage;
296 BOOL fake_italic;
297 BOOL fake_bold;
298 BYTE underline;
299 BYTE strikeout;
300 INT orientation;
301 GM *gm;
302 DWORD gmsize;
303 struct list hfontlist;
304 FONT_DESC font_desc;
305 LONG aveWidth;
306 SHORT yMax;
307 SHORT yMin;
308 OUTLINETEXTMETRICW *potm;
309 DWORD total_kern_pairs;
310 KERNINGPAIR *kern_pairs;
311 FONTSIGNATURE fs;
312 GdiFont *base_font;
313 struct list child_fonts;
314 LONG ppem;
315 };
316
317 typedef struct {
318 struct list entry;
319 const WCHAR *font_name;
320 struct list links;
321 } SYSTEM_LINKS;
322
323 #define INIT_GM_SIZE 128
324
325 static struct list gdi_font_list = LIST_INIT(gdi_font_list);
326 static struct list unused_gdi_font_list = LIST_INIT(unused_gdi_font_list);
327 #define UNUSED_CACHE_SIZE 10
328 static struct list child_font_list = LIST_INIT(child_font_list);
329 static struct list system_links = LIST_INIT(system_links);
330
331 static struct list font_subst_list = LIST_INIT(font_subst_list);
332
333 static struct list font_list = LIST_INIT(font_list);
334
335 static const WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
336 static const WCHAR defSans[] = {'A','r','i','a','l','\0'};
337 static const WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
338
339 static const WCHAR RegularW[] = {'R','e','g','u','l','a','r','\0'};
340
341 static const WCHAR fontsW[] = {'\\','F','o','n','t','s','\0'};
342 static const WCHAR win9x_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
343 'W','i','n','d','o','w','s','\\',
344 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
345 'F','o','n','t','s','\0'};
346
347 static const WCHAR winnt_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
348 'W','i','n','d','o','w','s',' ','N','T','\\',
349 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
350 'F','o','n','t','s','\0'};
351
352 static const WCHAR system_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
353 static const WCHAR FixedSys_Value[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
354 static const WCHAR System_Value[] = {'F','O','N','T','S','.','F','O','N','\0'};
355 static const WCHAR OEMFont_Value[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
356
357 static const WCHAR * const SystemFontValues[4] = {
358 System_Value,
359 OEMFont_Value,
360 FixedSys_Value,
361 NULL
362 };
363
364 static const WCHAR external_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
365 'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
366
367 static const WCHAR ArabicW[] = {'A','r','a','b','i','c','\0'};
368 static const WCHAR BalticW[] = {'B','a','l','t','i','c','\0'};
369 static const WCHAR CHINESE_BIG5W[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
370 static const WCHAR CHINESE_GB2312W[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
371 static const WCHAR Central_EuropeanW[] = {'C','e','n','t','r','a','l',' ',
372 'E','u','r','o','p','e','a','n','\0'};
373 static const WCHAR CyrillicW[] = {'C','y','r','i','l','l','i','c','\0'};
374 static const WCHAR GreekW[] = {'G','r','e','e','k','\0'};
375 static const WCHAR HangulW[] = {'H','a','n','g','u','l','\0'};
376 static const WCHAR Hangul_Johab_W[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
377 static const WCHAR HebrewW[] = {'H','e','b','r','e','w','\0'};
378 static const WCHAR JapaneseW[] = {'J','a','p','a','n','e','s','e','\0'};
379 static const WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
380 static const WCHAR ThaiW[] = {'T','h','a','i','\0'};
381 static const WCHAR TurkishW[] = {'T','u','r','k','i','s','h','\0'};
382 static const WCHAR VietnameseW[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
383 static const WCHAR WesternW[] = {'W','e','s','t','e','r','n','\0'};
384 static const WCHAR OEM_DOSW[] = {'O','E','M','/','D','O','S','\0'};
385
386 static const WCHAR * const ElfScriptsW[32] = { /* these are in the order of the fsCsb[0] bits */
387 WesternW, /*00*/
388 Central_EuropeanW,
389 CyrillicW,
390 GreekW,
391 TurkishW,
392 HebrewW,
393 ArabicW,
394 BalticW,
395 VietnameseW, /*08*/
396 NULL, NULL, NULL, NULL, NULL, NULL, NULL, /*15*/
397 ThaiW,
398 JapaneseW,
399 CHINESE_GB2312W,
400 HangulW,
401 CHINESE_BIG5W,
402 Hangul_Johab_W,
403 NULL, NULL, /*23*/
404 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
405 SymbolW /*31*/
406 };
407
408 typedef struct {
409 WCHAR *name;
410 INT charset;
411 } NameCs;
412
413 typedef struct tagFontSubst {
414 struct list entry;
415 NameCs from;
416 NameCs to;
417 } FontSubst;
418
419 struct font_mapping
420 {
421 struct list entry;
422 int refcount;
423 dev_t dev;
424 ino_t ino;
425 void *data;
426 size_t size;
427 };
428
429 static struct list mappings_list = LIST_INIT( mappings_list );
430
431 static BOOL have_installed_roman_font = FALSE; /* CreateFontInstance will fail if this is still FALSE */
432
433 static const WCHAR font_mutex_nameW[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
434
435 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph);
436
437 /****************************************
438 * Notes on .fon files
439 *
440 * The fonts System, FixedSys and Terminal are special. There are typically multiple
441 * versions installed for different resolutions and codepages. Windows stores which one to use
442 * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
443 * Key Meaning
444 * FIXEDFON.FON FixedSys
445 * FONTS.FON System
446 * OEMFONT.FON Terminal
447 * LogPixels Current dpi set by the display control panel applet
448 * (HKLM\\Software\\Microsft\\Windows NT\\CurrentVersion\\FontDPI
449 * also has a LogPixels value that appears to mirror this)
450 *
451 * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
452 * (vgaoem.fon would be your oemfont.fon if you have a US setup).
453 * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
454 * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
455 * so that makes sense.
456 *
457 * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
458 * to be mapped into the registry on Windows 2000 at least).
459 * I have
460 * woafont=app850.fon
461 * ega80woa.fon=ega80850.fon
462 * ega40woa.fon=ega40850.fon
463 * cga80woa.fon=cga80850.fon
464 * cga40woa.fon=cga40850.fon
465 */
466
467 #ifdef HAVE_CARBON_CARBON_H
468 static char *find_cache_dir(void)
469 {
470 FSRef ref;
471 OSErr err;
472 static char cached_path[MAX_PATH];
473 static const char *wine = "/Wine", *fonts = "/Fonts";
474
475 if(*cached_path) return cached_path;
476
477 err = FSFindFolder(kUserDomain, kCachedDataFolderType, kCreateFolder, &ref);
478 if(err != noErr)
479 {
480 WARN("can't create cached data folder\n");
481 return NULL;
482 }
483 err = FSRefMakePath(&ref, (unsigned char*)cached_path, sizeof(cached_path));
484 if(err != noErr)
485 {
486 WARN("can't create cached data path\n");
487 *cached_path = '\0';
488 return NULL;
489 }
490 if(strlen(cached_path) + strlen(wine) + strlen(fonts) + 1 > sizeof(cached_path))
491 {
492 ERR("Could not create full path\n");
493 *cached_path = '\0';
494 return NULL;
495 }
496 strcat(cached_path, wine);
497
498 if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
499 {
500 WARN("Couldn't mkdir %s\n", cached_path);
501 *cached_path = '\0';
502 return NULL;
503 }
504 strcat(cached_path, fonts);
505 if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
506 {
507 WARN("Couldn't mkdir %s\n", cached_path);
508 *cached_path = '\0';
509 return NULL;
510 }
511 return cached_path;
512 }
513
514 /******************************************************************
515 * expand_mac_font
516 *
517 * Extracts individual TrueType font files from a Mac suitcase font
518 * and saves them into the user's caches directory (see
519 * find_cache_dir()).
520 * Returns a NULL terminated array of filenames.
521 *
522 * We do this because they are apps that try to read ttf files
523 * themselves and they don't like Mac suitcase files.
524 */
525 static char **expand_mac_font(const char *path)
526 {
527 FSRef ref;
528 SInt16 res_ref;
529 OSStatus s;
530 unsigned int idx;
531 const char *out_dir;
532 const char *filename;
533 int output_len;
534 struct {
535 char **array;
536 unsigned int size, max_size;
537 } ret;
538
539 TRACE("path %s\n", path);
540
541 s = FSPathMakeRef((unsigned char*)path, &ref, FALSE);
542 if(s != noErr)
543 {
544 WARN("failed to get ref\n");
545 return NULL;
546 }
547
548 s = FSOpenResourceFile(&ref, 0, NULL, fsRdPerm, &res_ref);
549 if(s != noErr)
550 {
551 TRACE("no data fork, so trying resource fork\n");
552 res_ref = FSOpenResFile(&ref, fsRdPerm);
553 if(res_ref == -1)
554 {
555 TRACE("unable to open resource fork\n");
556 return NULL;
557 }
558 }
559
560 ret.size = 0;
561 ret.max_size = 10;
562 ret.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.max_size * sizeof(*ret.array));
563 if(!ret.array)
564 {
565 CloseResFile(res_ref);
566 return NULL;
567 }
568
569 out_dir = find_cache_dir();
570
571 filename = strrchr(path, '/');
572 if(!filename) filename = path;
573 else filename++;
574
575 /* output filename has the form out_dir/filename_%04x.ttf */
576 output_len = strlen(out_dir) + 1 + strlen(filename) + 5 + 5;
577
578 UseResFile(res_ref);
579 idx = 1;
580 while(1)
581 {
582 FamRec *fam_rec;
583 unsigned short *num_faces_ptr, num_faces, face;
584 AsscEntry *assoc;
585 Handle fond;
586 ResType fond_res = 0x464f4e44; /* 'FOND' */
587
588 fond = Get1IndResource(fond_res, idx);
589 if(!fond) break;
590 TRACE("got fond resource %d\n", idx);
591 HLock(fond);
592
593 fam_rec = *(FamRec**)fond;
594 num_faces_ptr = (unsigned short *)(fam_rec + 1);
595 num_faces = GET_BE_WORD(*num_faces_ptr);
596 num_faces++;
597 assoc = (AsscEntry*)(num_faces_ptr + 1);
598 TRACE("num faces %04x\n", num_faces);
599 for(face = 0; face < num_faces; face++, assoc++)
600 {
601 Handle sfnt;
602 ResType sfnt_res = 0x73666e74; /* 'sfnt' */
603 unsigned short size, font_id;
604 char *output;
605
606 size = GET_BE_WORD(assoc->fontSize);
607 font_id = GET_BE_WORD(assoc->fontID);
608 if(size != 0)
609 {
610 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id, size);
611 continue;
612 }
613
614 TRACE("trying to load sfnt id %04x\n", font_id);
615 sfnt = GetResource(sfnt_res, font_id);
616 if(!sfnt)
617 {
618 TRACE("can't get sfnt resource %04x\n", font_id);
619 continue;
620 }
621
622 output = HeapAlloc(GetProcessHeap(), 0, output_len);
623 if(output)
624 {
625 int fd;
626
627 sprintf(output, "%s/%s_%04x.ttf", out_dir, filename, font_id);
628
629 fd = open(output, O_CREAT | O_EXCL | O_WRONLY, 0600);
630 if(fd != -1 || errno == EEXIST)
631 {
632 if(fd != -1)
633 {
634 unsigned char *sfnt_data;
635
636 HLock(sfnt);
637 sfnt_data = *(unsigned char**)sfnt;
638 write(fd, sfnt_data, GetHandleSize(sfnt));
639 HUnlock(sfnt);
640 close(fd);
641 }
642 if(ret.size >= ret.max_size - 1) /* Always want the last element to be NULL */
643 {
644 ret.max_size *= 2;
645 ret.array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.array, ret.max_size * sizeof(*ret.array));
646 }
647 ret.array[ret.size++] = output;
648 }
649 else
650 {
651 WARN("unable to create %s\n", output);
652 HeapFree(GetProcessHeap(), 0, output);
653 }
654 }
655 ReleaseResource(sfnt);
656 }
657 HUnlock(fond);
658 ReleaseResource(fond);
659 idx++;
660 }
661 CloseResFile(res_ref);
662
663 return ret.array;
664 }
665
666 #endif /* HAVE_CARBON_CARBON_H */
667
668 static inline BOOL is_win9x(void)
669 {
670 return GetVersion() & 0x80000000;
671 }
672 /*
673 This function builds an FT_Fixed from a float. It puts the integer part
674 in the highest 16 bits and the decimal part in the lowest 16 bits of the FT_Fixed.
675 It fails if the integer part of the float number is greater than SHORT_MAX.
676 */
677 static inline FT_Fixed FT_FixedFromFloat(float f)
678 {
679 short value = f;
680 unsigned short fract = (f - value) * 0xFFFF;
681 return (FT_Fixed)((long)value << 16 | (unsigned long)fract);
682 }
683
684 /*
685 This function builds an FT_Fixed from a FIXED. It simply put f.value
686 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
687 */
688 static inline FT_Fixed FT_FixedFromFIXED(FIXED f)
689 {
690 return (FT_Fixed)((long)f.value << 16 | (unsigned long)f.fract);
691 }
692
693
694 static Face *find_face_from_filename(const WCHAR *file_name, const WCHAR *face_name)
695 {
696 Family *family;
697 Face *face;
698 const char *file;
699 DWORD len = WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, NULL, 0, NULL, NULL);
700 char *file_nameA = HeapAlloc(GetProcessHeap(), 0, len);
701
702 WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, file_nameA, len, NULL, NULL);
703 TRACE("looking for file %s name %s\n", debugstr_a(file_nameA), debugstr_w(face_name));
704
705 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
706 {
707 if(face_name && strcmpiW(face_name, family->FamilyName))
708 continue;
709 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
710 {
711 file = strrchr(face->file, '/');
712 if(!file)
713 file = face->file;
714 else
715 file++;
716 if(!strcasecmp(file, file_nameA))
717 {
718 HeapFree(GetProcessHeap(), 0, file_nameA);
719 return face;
720 }
721 }
722 }
723 HeapFree(GetProcessHeap(), 0, file_nameA);
724 return NULL;
725 }
726
727 static Family *find_family_from_name(const WCHAR *name)
728 {
729 Family *family;
730
731 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
732 {
733 if(!strcmpiW(family->FamilyName, name))
734 return family;
735 }
736
737 return NULL;
738 }
739
740 static Face *find_face_from_path_index(const CHAR *file_name, const INT index)
741 {
742 Family *family;
743 Face *face;
744
745 TRACE("looking for file %s index %i\n", debugstr_a(file_name), index);
746
747 LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
748 {
749 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
750 {
751 if(!strcasecmp(face->file, file_name) && face->face_index == index)
752 return face;
753 }
754 }
755 return NULL;
756 }
757
758 static void DumpSubstList(void)
759 {
760 FontSubst *psub;
761
762 LIST_FOR_EACH_ENTRY(psub, &font_subst_list, FontSubst, entry)
763 {
764 if(psub->from.charset != -1 || psub->to.charset != -1)
765 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
766 psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
767 else
768 TRACE("%s -> %s\n", debugstr_w(psub->from.name),
769 debugstr_w(psub->to.name));
770 }
771 return;
772 }
773
774 static LPWSTR strdupW(LPCWSTR p)
775 {
776 LPWSTR ret;
777 DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
778 ret = HeapAlloc(GetProcessHeap(), 0, len);
779 memcpy(ret, p, len);
780 return ret;
781 }
782
783 static LPSTR strdupA(LPCSTR p)
784 {
785 LPSTR ret;
786 DWORD len = (strlen(p) + 1);
787 ret = HeapAlloc(GetProcessHeap(), 0, len);
788 memcpy(ret, p, len);
789 return ret;
790 }
791
792 static FontSubst *get_font_subst(const struct list *subst_list, const WCHAR *from_name,
793 INT from_charset)
794 {
795 FontSubst *element;
796
797 LIST_FOR_EACH_ENTRY(element, subst_list, FontSubst, entry)
798 {
799 if(!strcmpiW(element->from.name, from_name) &&
800 (element->from.charset == from_charset ||
801 element->from.charset == -1))
802 return element;
803 }
804
805 return NULL;
806 }
807
808 #define ADD_FONT_SUBST_FORCE 1
809
810 static BOOL add_font_subst(struct list *subst_list, FontSubst *subst, INT flags)
811 {
812 FontSubst *from_exist, *to_exist;
813
814 from_exist = get_font_subst(subst_list, subst->from.name, subst->from.charset);
815
816 if(from_exist && (flags & ADD_FONT_SUBST_FORCE))
817 {
818 list_remove(&from_exist->entry);
819 HeapFree(GetProcessHeap(), 0, &from_exist->from.name);
820 HeapFree(GetProcessHeap(), 0, &from_exist->to.name);
821 HeapFree(GetProcessHeap(), 0, from_exist);
822 from_exist = NULL;
823 }
824
825 if(!from_exist)
826 {
827 to_exist = get_font_subst(subst_list, subst->to.name, subst->to.charset);
828
829 if(to_exist)
830 {
831 HeapFree(GetProcessHeap(), 0, subst->to.name);
832 subst->to.name = strdupW(to_exist->to.name);
833 }
834
835 list_add_tail(subst_list, &subst->entry);
836
837 return TRUE;
838 }
839
840 HeapFree(GetProcessHeap(), 0, subst->from.name);
841 HeapFree(GetProcessHeap(), 0, subst->to.name);
842 HeapFree(GetProcessHeap(), 0, subst);
843 return FALSE;
844 }
845
846 static void split_subst_info(NameCs *nc, LPSTR str)
847 {
848 CHAR *p = strrchr(str, ',');
849 DWORD len;
850
851 nc->charset = -1;
852 if(p && *(p+1)) {
853 nc->charset = strtol(p+1, NULL, 10);
854 *p = '\0';
855 }
856 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
857 nc->name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
858 MultiByteToWideChar(CP_ACP, 0, str, -1, nc->name, len);
859 }
860
861 static void LoadSubstList(void)
862 {
863 FontSubst *psub;
864 HKEY hkey;
865 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
866 LPSTR value;
867 LPVOID data;
868
869 if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
870 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
871 &hkey) == ERROR_SUCCESS) {
872
873 RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
874 &valuelen, &datalen, NULL, NULL);
875
876 valuelen++; /* returned value doesn't include room for '\0' */
877 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
878 data = HeapAlloc(GetProcessHeap(), 0, datalen);
879
880 dlen = datalen;
881 vlen = valuelen;
882 while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
883 &dlen) == ERROR_SUCCESS) {
884 TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
885
886 psub = HeapAlloc(GetProcessHeap(), 0, sizeof(*psub));
887 split_subst_info(&psub->from, value);
888 split_subst_info(&psub->to, data);
889
890 /* Win 2000 doesn't allow mapping between different charsets
891 or mapping of DEFAULT_CHARSET */
892 if((psub->to.charset != psub->from.charset) ||
893 psub->to.charset == DEFAULT_CHARSET) {
894 HeapFree(GetProcessHeap(), 0, psub->to.name);
895 HeapFree(GetProcessHeap(), 0, psub->from.name);
896 HeapFree(GetProcessHeap(), 0, psub);
897 } else {
898 add_font_subst(&font_subst_list, psub, 0);
899 }
900 /* reset dlen and vlen */
901 dlen = datalen;
902 vlen = valuelen;
903 }
904 HeapFree(GetProcessHeap(), 0, data);
905 HeapFree(GetProcessHeap(), 0, value);
906 RegCloseKey(hkey);
907 }
908 }
909
910 static WCHAR *get_familyname(FT_Face ft_face)
911 {
912 WCHAR *family = NULL;
913 FT_SfntName name;
914 FT_UInt num_names, name_index, i;
915
916 if(FT_IS_SFNT(ft_face))
917 {
918 num_names = pFT_Get_Sfnt_Name_Count(ft_face);
919
920 for(name_index = 0; name_index < num_names; name_index++)
921 {
922 if(!pFT_Get_Sfnt_Name(ft_face, name_index, &name))
923 {
924 if((name.name_id == TT_NAME_ID_FONT_FAMILY) &&
925 (name.language_id == GetUserDefaultLCID()) &&
926 (name.platform_id == TT_PLATFORM_MICROSOFT) &&
927 (name.encoding_id == TT_MS_ID_UNICODE_CS))
928 {
929 /* String is not nul terminated and string_len is a byte length. */
930 family = HeapAlloc(GetProcessHeap(), 0, name.string_len + 2);
931 for(i = 0; i < name.string_len / 2; i++)
932 {
933 WORD *tmp = (WORD *)&name.string[i * 2];
934 family[i] = GET_BE_WORD(*tmp);
935 }
936 family[i] = 0;
937
938 TRACE("Got localised name %s\n", debugstr_w(family));
939 return family;
940 }
941 }
942 }
943 }
944
945 return NULL;
946 }
947
948
949 #define ADDFONT_EXTERNAL_FONT 0x01
950 #define ADDFONT_FORCE_BITMAP 0x02
951 static INT AddFontFileToList(const char *file, char *fake_family, const WCHAR *target_family, DWORD flags)
952 {
953 FT_Face ft_face;
954 TT_OS2 *pOS2;
955 TT_Header *pHeader = NULL;
956 WCHAR *english_family, *localised_family, *StyleW;
957 DWORD len;
958 Family *family;
959 Face *face;
960 struct list *family_elem_ptr, *face_elem_ptr;
961 FT_Error err;
962 FT_Long face_index = 0, num_faces;
963 #ifdef HAVE_FREETYPE_FTWINFNT_H
964 FT_WinFNT_HeaderRec winfnt_header;
965 #endif
966 int i, bitmap_num, internal_leading;
967 FONTSIGNATURE fs;
968
969 #ifdef HAVE_CARBON_CARBON_H
970 if(!fake_family)
971 {
972 char **mac_list = expand_mac_font(file);
973 if(mac_list)
974 {
975 BOOL had_one = FALSE;
976 char **cursor;
977 for(cursor = mac_list; *cursor; cursor++)
978 {
979 had_one = TRUE;
980 AddFontFileToList(*cursor, NULL, NULL, flags);
981 HeapFree(GetProcessHeap(), 0, *cursor);
982 }
983 HeapFree(GetProcessHeap(), 0, mac_list);
984 if(had_one)
985 return 1;
986 }
987 }
988 #endif /* HAVE_CARBON_CARBON_H */
989
990 do {
991 char *family_name = fake_family;
992
993 TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
994 if((err = pFT_New_Face(library, file, face_index, &ft_face)) != 0) {
995 WARN("Unable to load font file %s err = %x\n", debugstr_a(file), err);
996 return 0;
997 }
998
999 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*/
1000 WARN("Ignoring font %s\n", debugstr_a(file));
1001 pFT_Done_Face(ft_face);
1002 return 0;
1003 }
1004
1005 /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1006 if(!FT_IS_SCALABLE(ft_face) && FT_SimpleVersion < ((2 << 16) | (1 << 8) | (9 << 0))) {
1007 WARN("FreeType version < 2.1.9, skipping bitmap font %s\n", debugstr_a(file));
1008 pFT_Done_Face(ft_face);
1009 return 0;
1010 }
1011
1012 if(FT_IS_SFNT(ft_face) && (!pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2) ||
1013 !pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea) ||
1014 !(pHeader = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_head)))) {
1015 TRACE("Font file %s lacks either an OS2, HHEA or HEAD table.\n"
1016 "Skipping this font.\n", debugstr_a(file));
1017 pFT_Done_Face(ft_face);
1018 return 0;
1019 }
1020
1021 if(!ft_face->family_name || !ft_face->style_name) {
1022 TRACE("Font file %s lacks either a family or style name\n", debugstr_a(file));
1023 pFT_Done_Face(ft_face);
1024 return 0;
1025 }
1026
1027 if (target_family)
1028 {
1029 localised_family = get_familyname(ft_face);
1030 if (localised_family && strcmpiW(localised_family,target_family)!=0)
1031 {
1032 TRACE("Skipping Index %i: Incorrect Family name for replacement\n",(INT)face_index);
1033 HeapFree(GetProcessHeap(), 0, localised_family);
1034 num_faces = ft_face->num_faces;
1035 pFT_Done_Face(ft_face);
1036 continue;
1037 }
1038 HeapFree(GetProcessHeap(), 0, localised_family);
1039 }
1040
1041 if(!family_name)
1042 family_name = ft_face->family_name;
1043
1044 bitmap_num = 0;
1045 do {
1046 My_FT_Bitmap_Size *size = NULL;
1047
1048 if(!FT_IS_SCALABLE(ft_face))
1049 size = (My_FT_Bitmap_Size *)ft_face->available_sizes + bitmap_num;
1050
1051 len = MultiByteToWideChar(CP_ACP, 0, family_name, -1, NULL, 0);
1052 english_family = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1053 MultiByteToWideChar(CP_ACP, 0, family_name, -1, english_family, len);
1054
1055 localised_family = NULL;
1056 if(!fake_family) {
1057 localised_family = get_familyname(ft_face);
1058 if(localised_family && !strcmpW(localised_family, english_family)) {
1059 HeapFree(GetProcessHeap(), 0, localised_family);
1060 localised_family = NULL;
1061 }
1062 }
1063
1064 family = NULL;
1065 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1066 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1067 if(!strcmpW(family->FamilyName, localised_family ? localised_family : english_family))
1068 break;
1069 family = NULL;
1070 }
1071 if(!family) {
1072 family = HeapAlloc(GetProcessHeap(), 0, sizeof(*family));
1073 family->FamilyName = strdupW(localised_family ? localised_family : english_family);
1074 list_init(&family->faces);
1075 list_add_tail(&font_list, &family->entry);
1076
1077 if(localised_family) {
1078 FontSubst *subst = HeapAlloc(GetProcessHeap(), 0, sizeof(*subst));
1079 subst->from.name = strdupW(english_family);
1080 subst->from.charset = -1;
1081 subst->to.name = strdupW(localised_family);
1082 subst->to.charset = -1;
1083 add_font_subst(&font_subst_list, subst, 0);
1084 }
1085 }
1086 HeapFree(GetProcessHeap(), 0, localised_family);
1087 HeapFree(GetProcessHeap(), 0, english_family);
1088
1089 len = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0);
1090 StyleW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1091 MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, StyleW, len);
1092
1093 internal_leading = 0;
1094 memset(&fs, 0, sizeof(fs));
1095
1096 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
1097 if(pOS2) {
1098 fs.fsCsb[0] = pOS2->ulCodePageRange1;
1099 fs.fsCsb[1] = pOS2->ulCodePageRange2;
1100 fs.fsUsb[0] = pOS2->ulUnicodeRange1;
1101 fs.fsUsb[1] = pOS2->ulUnicodeRange2;
1102 fs.fsUsb[2] = pOS2->ulUnicodeRange3;
1103 fs.fsUsb[3] = pOS2->ulUnicodeRange4;
1104 if(pOS2->version == 0) {
1105 FT_UInt dummy;
1106
1107 if(!pFT_Get_First_Char || (pFT_Get_First_Char( ft_face, &dummy ) < 0x100))
1108 fs.fsCsb[0] |= 1;
1109 else
1110 fs.fsCsb[0] |= 1L << 31;
1111 }
1112 }
1113 #ifdef HAVE_FREETYPE_FTWINFNT_H
1114 else if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header)) {
1115 CHARSETINFO csi;
1116 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header.pixel_height, winfnt_header.charset,
1117 winfnt_header.vertical_resolution,winfnt_header.horizontal_resolution, winfnt_header.nominal_point_size);
1118 if(TranslateCharsetInfo((DWORD*)(UINT_PTR)winfnt_header.charset, &csi, TCI_SRCCHARSET))
1119 memcpy(&fs, &csi.fs, sizeof(csi.fs));
1120 internal_leading = winfnt_header.internal_leading;
1121 }
1122 #endif
1123
1124 face_elem_ptr = list_head(&family->faces);
1125 while(face_elem_ptr) {
1126 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1127 face_elem_ptr = list_next(&family->faces, face_elem_ptr);
1128 if(!strcmpW(face->StyleName, StyleW) &&
1129 (FT_IS_SCALABLE(ft_face) || ((size->y_ppem == face->size.y_ppem) && !memcmp(&fs, &face->fs, sizeof(fs)) ))) {
1130 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1131 debugstr_w(family->FamilyName), debugstr_w(StyleW),
1132 face->font_version, pHeader ? pHeader->Font_Revision : 0);
1133
1134 if(fake_family) {
1135 TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
1136 HeapFree(GetProcessHeap(), 0, StyleW);
1137 pFT_Done_Face(ft_face);
1138 return 1;
1139 }
1140 if(!pHeader || pHeader->Font_Revision <= face->font_version) {
1141 TRACE("Original font is newer so skipping this one\n");
1142 HeapFree(GetProcessHeap(), 0, StyleW);
1143 pFT_Done_Face(ft_face);
1144 return 1;
1145 } else {
1146 TRACE("Replacing original with this one\n");
1147 list_remove(&face->entry);
1148 HeapFree(GetProcessHeap(), 0, face->file);
1149 HeapFree(GetProcessHeap(), 0, face->StyleName);
1150 HeapFree(GetProcessHeap(), 0, face);
1151 break;
1152 }
1153 }
1154 }
1155 face = HeapAlloc(GetProcessHeap(), 0, sizeof(*face));
1156 list_add_tail(&family->faces, &face->entry);
1157 face->StyleName = StyleW;
1158 face->file = HeapAlloc(GetProcessHeap(),0,strlen(file)+1);
1159 strcpy(face->file, file);
1160 face->face_index = face_index;
1161 face->Italic = (ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 1 : 0;
1162 face->Bold = (ft_face->style_flags & FT_STYLE_FLAG_BOLD) ? 1 : 0;
1163 face->font_version = pHeader ? pHeader->Font_Revision : 0;
1164 face->family = family;
1165 face->external = (flags & ADDFONT_EXTERNAL_FONT) ? TRUE : FALSE;
1166 memcpy(&face->fs, &fs, sizeof(face->fs));
1167 memset(&face->fs_links, 0, sizeof(face->fs_links));
1168
1169 if(FT_IS_SCALABLE(ft_face)) {
1170 memset(&face->size, 0, sizeof(face->size));
1171 face->scalable = TRUE;
1172 } else {
1173 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1174 size->height, size->width, size->size >> 6,
1175 size->x_ppem >> 6, size->y_ppem >> 6);
1176 face->size.height = size->height;
1177 face->size.width = size->width;
1178 face->size.size = size->size;
1179 face->size.x_ppem = size->x_ppem;
1180 face->size.y_ppem = size->y_ppem;
1181 face->size.internal_leading = internal_leading;
1182 face->scalable = FALSE;
1183 }
1184
1185 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1186 face->fs.fsCsb[0], face->fs.fsCsb[1],
1187 face->fs.fsUsb[0], face->fs.fsUsb[1],
1188 face->fs.fsUsb[2], face->fs.fsUsb[3]);
1189
1190
1191 if(face->fs.fsCsb[0] == 0) { /* let's see if we can find any interesting cmaps */
1192 for(i = 0; i < ft_face->num_charmaps; i++) {
1193 switch(ft_face->charmaps[i]->encoding) {
1194 case FT_ENCODING_UNICODE:
1195 case FT_ENCODING_APPLE_ROMAN:
1196 face->fs.fsCsb[0] |= 1;
1197 break;
1198 case FT_ENCODING_MS_SYMBOL:
1199 face->fs.fsCsb[0] |= 1L << 31;
1200 break;
1201 default:
1202 break;
1203 }
1204 }
1205 }
1206
1207 if(face->fs.fsCsb[0] & ~(1L << 31))
1208 have_installed_roman_font = TRUE;
1209 } while(!FT_IS_SCALABLE(ft_face) && ++bitmap_num < ft_face->num_fixed_sizes);
1210
1211 num_faces = ft_face->num_faces;
1212 pFT_Done_Face(ft_face);
1213 TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
1214 debugstr_w(StyleW));
1215 } while(num_faces > ++face_index);
1216 return num_faces;
1217 }
1218
1219 static void DumpFontList(void)
1220 {
1221 Family *family;
1222 Face *face;
1223 struct list *family_elem_ptr, *face_elem_ptr;
1224
1225 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1226 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1227 TRACE("Family: %s\n", debugstr_w(family->FamilyName));
1228 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1229 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1230 TRACE("\t%s\t%08x", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
1231 if(!face->scalable)
1232 TRACE(" %d", face->size.height);
1233 TRACE("\n");
1234 }
1235 }
1236 return;
1237 }
1238
1239 /***********************************************************
1240 * The replacement list is a way to map an entire font
1241 * family onto another family. For example adding
1242 *
1243 * [HKCU\Software\Wine\Fonts\Replacements]
1244 * "Wingdings"="Winedings"
1245 *
1246 * would enumerate the Winedings font both as Winedings and
1247 * Wingdings. However if a real Wingdings font is present the
1248 * replacement does not take place.
1249 *
1250 */
1251 static void LoadReplaceList(void)
1252 {
1253 HKEY hkey;
1254 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1255 LPWSTR value;
1256 LPVOID data;
1257 Family *family;
1258 Face *face;
1259 struct list *family_elem_ptr, *face_elem_ptr;
1260 CHAR familyA[400];
1261
1262 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1263 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
1264 {
1265 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1266 &valuelen, &datalen, NULL, NULL);
1267
1268 valuelen++; /* returned value doesn't include room for '\0' */
1269 value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1270 data = HeapAlloc(GetProcessHeap(), 0, datalen);
1271
1272 dlen = datalen;
1273 vlen = valuelen;
1274 while(RegEnumValueW(hkey, i++, value, &vlen, NULL, &type, data,
1275 &dlen) == ERROR_SUCCESS) {
1276 TRACE("Got %s=%s\n", debugstr_w(value), debugstr_w(data));
1277 /* "NewName"="Oldname" */
1278 WideCharToMultiByte(CP_ACP, 0, value, -1, familyA, sizeof(familyA), NULL, NULL);
1279
1280 /* Find the old family and hence all of the font files
1281 in that family */
1282 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1283 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1284 if(!strcmpiW(family->FamilyName, data)) {
1285 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1286 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1287 TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
1288 debugstr_w(face->StyleName), familyA);
1289 /* Now add a new entry with the new family name */
1290 AddFontFileToList(face->file, familyA, family->FamilyName, ADDFONT_FORCE_BITMAP | (face->external ? ADDFONT_EXTERNAL_FONT : 0));
1291 }
1292 break;
1293 }
1294 }
1295 /* reset dlen and vlen */
1296 dlen = datalen;
1297 vlen = valuelen;
1298 }
1299 HeapFree(GetProcessHeap(), 0, data);
1300 HeapFree(GetProcessHeap(), 0, value);
1301 RegCloseKey(hkey);
1302 }
1303 }
1304
1305 /*************************************************************
1306 * init_system_links
1307 */
1308 static BOOL init_system_links(void)
1309 {
1310 static const WCHAR system_link[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1311 'W','i','n','d','o','w','s',' ','N','T','\\',
1312 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
1313 'S','y','s','t','e','m','L','i','n','k',0};
1314 HKEY hkey;
1315 BOOL ret = FALSE;
1316 DWORD type, max_val, max_data, val_len, data_len, index;
1317 WCHAR *value, *data;
1318 WCHAR *entry, *next;
1319 SYSTEM_LINKS *font_link, *system_font_link;
1320 CHILD_FONT *child_font;
1321 static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
1322 static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
1323 static const WCHAR System[] = {'S','y','s','t','e','m',0};
1324 FONTSIGNATURE fs;
1325 Family *family;
1326 Face *face;
1327 FontSubst *psub;
1328
1329 if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
1330 {
1331 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
1332 value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
1333 data = HeapAlloc(GetProcessHeap(), 0, max_data);
1334 val_len = max_val + 1;
1335 data_len = max_data;
1336 index = 0;
1337 while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
1338 {
1339 TRACE("%s:\n", debugstr_w(value));
1340
1341 memset(&fs, 0, sizeof(fs));
1342 font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
1343 psub = get_font_subst(&font_subst_list, value, -1);
1344 font_link->font_name = (psub)? strdupW(psub->to.name) : strdupW(value);
1345 list_init(&font_link->links);
1346 for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
1347 {
1348 WCHAR *face_name;
1349 CHILD_FONT *child_font;
1350
1351 TRACE("\t%s\n", debugstr_w(entry));
1352
1353 next = entry + strlenW(entry) + 1;
1354
1355 face_name = strchrW(entry, ',');
1356 if(face_name)
1357 {
1358 *face_name++ = 0;
1359 while(isspaceW(*face_name))
1360 face_name++;
1361
1362 psub = get_font_subst(&font_subst_list, face_name, -1);
1363 if(psub)
1364 face_name = psub->to.name;
1365 }
1366 face = find_face_from_filename(entry, face_name);
1367 if(!face)
1368 {
1369 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
1370 continue;
1371 }
1372
1373 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1374 child_font->file_name = strdupA(face->file);
1375 child_font->index = face->face_index;
1376 child_font->font = NULL;
1377 fs.fsCsb[0] |= face->fs.fsCsb[0];
1378 fs.fsCsb[1] |= face->fs.fsCsb[1];
1379 TRACE("Adding file %s index %d\n", child_font->file_name, child_font->index);
1380 list_add_tail(&font_link->links, &child_font->entry);
1381 }
1382 family = find_family_from_name(font_link->font_name);
1383 if(family)
1384 {
1385 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
1386 {
1387 memcpy(&face->fs_links, &fs, sizeof(fs));
1388 }
1389 }
1390 list_add_tail(&system_links, &font_link->entry);
1391 val_len = max_val + 1;
1392 data_len = max_data;
1393 }
1394
1395 HeapFree(GetProcessHeap(), 0, value);
1396 HeapFree(GetProcessHeap(), 0, data);
1397 RegCloseKey(hkey);
1398 }
1399
1400 /* Explicitly add an entry for the system font, this links to Tahoma and any links
1401 that Tahoma has */
1402
1403 system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
1404 system_font_link->font_name = strdupW(System);
1405 list_init(&system_font_link->links);
1406
1407 face = find_face_from_filename(tahoma_ttf, Tahoma);
1408 if(face)
1409 {
1410 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1411 child_font->file_name = strdupA(face->file);
1412 child_font->index = face->face_index;
1413 child_font->font = NULL;
1414 TRACE("Found Tahoma in %s index %d\n", child_font->file_name, child_font->index);
1415 list_add_tail(&system_font_link->links, &child_font->entry);
1416 }
1417 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
1418 {
1419 if(!strcmpiW(font_link->font_name, Tahoma))
1420 {
1421 CHILD_FONT *font_link_entry;
1422 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
1423 {
1424 CHILD_FONT *new_child;
1425 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
1426 new_child->file_name = strdupA(font_link_entry->file_name);
1427 new_child->index = font_link_entry->index;
1428 new_child->font = NULL;
1429 list_add_tail(&system_font_link->links, &new_child->entry);
1430 }
1431 break;
1432 }
1433 }
1434 list_add_tail(&system_links, &system_font_link->entry);
1435 return ret;
1436 }
1437
1438 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
1439 {
1440 DIR *dir;
1441 struct dirent *dent;
1442 char path[MAX_PATH];
1443
1444 TRACE("Loading fonts from %s\n", debugstr_a(dirname));
1445
1446 dir = opendir(dirname);
1447 if(!dir) {
1448 WARN("Can't open directory %s\n", debugstr_a(dirname));
1449 return FALSE;
1450 }
1451 while((dent = readdir(dir)) != NULL) {
1452 struct stat statbuf;
1453
1454 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
1455 continue;
1456
1457 TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
1458
1459 sprintf(path, "%s/%s", dirname, dent->d_name);
1460
1461 if(stat(path, &statbuf) == -1)
1462 {
1463 WARN("Can't stat %s\n", debugstr_a(path));
1464 continue;
1465 }
1466 if(S_ISDIR(statbuf.st_mode))
1467 ReadFontDir(path, external_fonts);
1468 else
1469 AddFontFileToList(path, NULL, NULL, external_fonts ? ADDFONT_EXTERNAL_FONT : 0);
1470 }
1471 closedir(dir);
1472 return TRUE;
1473 }
1474
1475 static void load_fontconfig_fonts(void)
1476 {
1477 #ifdef SONAME_LIBFONTCONFIG
1478 void *fc_handle = NULL;
1479 FcConfig *config;
1480 FcPattern *pat;
1481 FcObjectSet *os;
1482 FcFontSet *fontset;
1483 int i, len;
1484 char *file;
1485 const char *ext;
1486
1487 fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
1488 if(!fc_handle) {
1489 TRACE("Wine cannot find the fontconfig library (%s).\n",
1490 SONAME_LIBFONTCONFIG);
1491 return;
1492 }
1493 #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;}
1494 LOAD_FUNCPTR(FcConfigGetCurrent);
1495 LOAD_FUNCPTR(FcFontList);
1496 LOAD_FUNCPTR(FcFontSetDestroy);
1497 LOAD_FUNCPTR(FcInit);
1498 LOAD_FUNCPTR(FcObjectSetAdd);
1499 LOAD_FUNCPTR(FcObjectSetCreate);
1500 LOAD_FUNCPTR(FcObjectSetDestroy);
1501 LOAD_FUNCPTR(FcPatternCreate);
1502 LOAD_FUNCPTR(FcPatternDestroy);
1503 LOAD_FUNCPTR(FcPatternGetBool);
1504 LOAD_FUNCPTR(FcPatternGetString);
1505 #undef LOAD_FUNCPTR
1506
1507 if(!pFcInit()) return;
1508
1509 config = pFcConfigGetCurrent();
1510 pat = pFcPatternCreate();
1511 os = pFcObjectSetCreate();
1512 pFcObjectSetAdd(os, FC_FILE);
1513 pFcObjectSetAdd(os, FC_SCALABLE);
1514 fontset = pFcFontList(config, pat, os);
1515 if(!fontset) return;
1516 for(i = 0; i < fontset->nfont; i++) {
1517 FcBool scalable;
1518
1519 if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
1520 continue;
1521 TRACE("fontconfig: %s\n", file);
1522
1523 /* We're just interested in OT/TT fonts for now, so this hack just
1524 picks up the scalable fonts without extensions .pf[ab] to save time
1525 loading every other font */
1526
1527 if(pFcPatternGetBool(fontset->fonts[i], FC_SCALABLE, 0, &scalable) == FcResultMatch && !scalable)
1528 {
1529 TRACE("not scalable\n");
1530 continue;
1531 }
1532
1533 len = strlen( file );
1534 if(len < 4) continue;
1535 ext = &file[ len - 3 ];
1536 if(strcasecmp(ext, "pfa") && strcasecmp(ext, "pfb"))
1537 AddFontFileToList(file, NULL, NULL, ADDFONT_EXTERNAL_FONT);
1538 }
1539 pFcFontSetDestroy(fontset);
1540 pFcObjectSetDestroy(os);
1541 pFcPatternDestroy(pat);
1542 sym_not_found:
1543 #endif
1544 return;
1545 }
1546
1547 static BOOL load_font_from_data_dir(LPCWSTR file)
1548 {
1549 BOOL ret = FALSE;
1550 const char *data_dir = wine_get_data_dir();
1551
1552 if (!data_dir) data_dir = wine_get_build_dir();
1553
1554 if (data_dir)
1555 {
1556 INT len;
1557 char *unix_name;
1558
1559 len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
1560
1561 unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
1562
1563 strcpy(unix_name, data_dir);
1564 strcat(unix_name, "/fonts/");
1565
1566 WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
1567
1568 ret = AddFontFileToList(unix_name, NULL, NULL, ADDFONT_FORCE_BITMAP);
1569 HeapFree(GetProcessHeap(), 0, unix_name);
1570 }
1571 return ret;
1572 }
1573
1574 static void load_system_fonts(void)
1575 {
1576 HKEY hkey;
1577 WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
1578 const WCHAR * const *value;
1579 DWORD dlen, type;
1580 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
1581 char *unixname;
1582
1583 if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
1584 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1585 strcatW(windowsdir, fontsW);
1586 for(value = SystemFontValues; *value; value++) {
1587 dlen = sizeof(data);
1588 if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
1589 type == REG_SZ) {
1590 BOOL added = FALSE;
1591
1592 sprintfW(pathW, fmtW, windowsdir, data);
1593 if((unixname = wine_get_unix_file_name(pathW))) {
1594 added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
1595 HeapFree(GetProcessHeap(), 0, unixname);
1596 }
1597 if (!added)
1598 load_font_from_data_dir(data);
1599 }
1600 }
1601 RegCloseKey(hkey);
1602 }
1603 }
1604
1605 /*************************************************************
1606 *
1607 * This adds registry entries for any externally loaded fonts
1608 * (fonts from fontconfig or FontDirs). It also deletes entries
1609 * of no longer existing fonts.
1610 *
1611 */
1612 static void update_reg_entries(void)
1613 {
1614 HKEY winkey = 0, externalkey = 0;
1615 LPWSTR valueW;
1616 LPVOID data;
1617 DWORD dlen, vlen, datalen, valuelen, i, type, len, len_fam;
1618 Family *family;
1619 Face *face;
1620 struct list *family_elem_ptr, *face_elem_ptr;
1621 WCHAR *file;
1622 static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
1623 static const WCHAR spaceW[] = {' ', '\0'};
1624 char *path;
1625
1626 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
1627 0, NULL, 0, KEY_ALL_ACCESS, NULL, &winkey, NULL) != ERROR_SUCCESS) {
1628 ERR("Can't create Windows font reg key\n");
1629 goto end;
1630 }
1631 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\ExternalFonts */
1632 if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &externalkey) != ERROR_SUCCESS) {
1633 ERR("Can't create external font reg key\n");
1634 goto end;
1635 }
1636
1637 /* Delete all external fonts added last time */
1638
1639 RegQueryInfoKeyW(externalkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1640 &valuelen, &datalen, NULL, NULL);
1641 valuelen++; /* returned value doesn't include room for '\0' */
1642 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1643 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
1644
1645 dlen = datalen * sizeof(WCHAR);
1646 vlen = valuelen;
1647 i = 0;
1648 while(RegEnumValueW(externalkey, i++, valueW, &vlen, NULL, &type, data,
1649 &dlen) == ERROR_SUCCESS) {
1650
1651 RegDeleteValueW(winkey, valueW);
1652 /* reset dlen and vlen */
1653 dlen = datalen;
1654 vlen = valuelen;
1655 }
1656 HeapFree(GetProcessHeap(), 0, data);
1657 HeapFree(GetProcessHeap(), 0, valueW);
1658
1659 /* Delete the old external fonts key */
1660 RegCloseKey(externalkey);
1661 externalkey = 0;
1662 RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
1663
1664 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\ExternalFonts */
1665 if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
1666 0, NULL, 0, KEY_ALL_ACCESS, NULL, &externalkey, NULL) != ERROR_SUCCESS) {
1667 ERR("Can't create external font reg key\n");
1668 goto end;
1669 }
1670
1671 /* enumerate the fonts and add external ones to the two keys */
1672
1673 LIST_FOR_EACH(family_elem_ptr, &font_list) {
1674 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1675 len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
1676 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1677 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1678 if(!face->external) continue;
1679 len = len_fam;
1680 if(strcmpiW(face->StyleName, RegularW))
1681 len = len_fam + strlenW(face->StyleName) + 1;
1682 valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1683 strcpyW(valueW, family->FamilyName);
1684 if(len != len_fam) {
1685 strcatW(valueW, spaceW);
1686 strcatW(valueW, face->StyleName);
1687 }
1688 strcatW(valueW, TrueType);
1689 if((path = strrchr(face->file, '/')) == NULL)
1690 path = face->file;
1691 else
1692 path++;
1693 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
1694
1695 file = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1696 MultiByteToWideChar(CP_ACP, 0, path, -1, file, len);
1697 RegSetValueExW(winkey, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1698 RegSetValueExW(externalkey, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1699
1700 HeapFree(GetProcessHeap(), 0, file);
1701 HeapFree(GetProcessHeap(), 0, valueW);
1702 }
1703 }
1704 end:
1705 if(externalkey)
1706 RegCloseKey(externalkey);
1707 if(winkey)
1708 RegCloseKey(winkey);
1709 return;
1710 }
1711
1712
1713 /*************************************************************
1714 * WineEngAddFontResourceEx
1715 *
1716 */
1717 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
1718 {
1719 if (ft_handle) /* do it only if we have freetype up and running */
1720 {
1721 char *unixname;
1722
1723 if(flags)
1724 FIXME("Ignoring flags %x\n", flags);
1725
1726 if((unixname = wine_get_unix_file_name(file)))
1727 {
1728 INT ret = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
1729 HeapFree(GetProcessHeap(), 0, unixname);
1730 return ret;
1731 }
1732 }
1733 return 0;
1734 }
1735
1736 /*************************************************************
1737 * WineEngRemoveFontResourceEx
1738 *
1739 */
1740 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
1741 {
1742 FIXME(":stub\n");
1743 return TRUE;
1744 }
1745
1746 static const struct nls_update_font_list
1747 {
1748 UINT ansi_cp, oem_cp;
1749 const char *oem, *fixed, *system;
1750 const char *courier, *serif, *small, *sserif;
1751 /* these are for font substitute */
1752 const char *shelldlg, *tmsrmn;
1753 } nls_update_font_list[] =
1754 {
1755 /* Latin 1 (United States) */
1756 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
1757 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1758 "Tahoma","Times New Roman",
1759 },
1760 /* Latin 1 (Multilingual) */
1761 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
1762 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1763 "Tahoma","Times New Roman", /* FIXME unverified */
1764 },
1765 /* Eastern Europe */
1766 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
1767 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
1768 "Tahoma","Times New Roman", /* FIXME unverified */
1769 },
1770 /* Cyrillic */
1771 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
1772 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
1773 "Tahoma","Times New Roman", /* FIXME unverified */
1774 },
1775 /* Greek */
1776 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
1777 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
1778 "Tahoma","Times New Roman", /* FIXME unverified */
1779 },
1780 /* Turkish */
1781 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
1782 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
1783 "Tahoma","Times New Roman", /* FIXME unverified */
1784 },
1785 /* Hebrew */
1786 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
1787 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
1788 "Tahoma","Times New Roman", /* FIXME unverified */
1789 },
1790 /* Arabic */
1791 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
1792 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
1793 "Tahoma","Times New Roman", /* FIXME unverified */
1794 },
1795 /* Baltic */
1796 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
1797 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
1798 "Tahoma","Times New Roman", /* FIXME unverified */
1799 },
1800 /* Vietnamese */
1801 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
1802 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1803 "Tahoma","Times New Roman", /* FIXME unverified */
1804 },
1805 /* Thai */
1806 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
1807 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
1808 "Tahoma","Times New Roman", /* FIXME unverified */
1809 },
1810 /* Japanese */
1811 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
1812 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
1813 "MS UI Gothic","MS Serif",
1814 },
1815 /* Chinese Simplified */
1816 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
1817 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1818 "Tahoma", "Times New Roman", /* FIXME unverified */
1819 },
1820 /* Korean */
1821 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
1822 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1823 "Gulim", "Batang",
1824 },
1825 /* Chinese Traditional */
1826 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
1827 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1828 "Tahoma", "Times New Roman", /* FIXME unverified */
1829 }
1830 };
1831
1832 static inline HKEY create_fonts_NT_registry_key(void)
1833 {
1834 HKEY hkey = 0;
1835
1836 RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
1837 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1838 return hkey;
1839 }
1840
1841 static inline HKEY create_fonts_9x_registry_key(void)
1842 {
1843 HKEY hkey = 0;
1844
1845 RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
1846 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1847 return hkey;
1848 }
1849
1850 static inline HKEY create_config_fonts_registry_key(void)
1851 {
1852 HKEY hkey = 0;
1853
1854 RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
1855 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1856 return hkey;
1857 }
1858
1859 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl)
1860 {
1861 RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
1862 RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
1863 RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)fl->sserif, strlen(fl->sserif)+1);
1864 RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
1865 }
1866
1867 static void update_font_info(void)
1868 {
1869 char buf[40], cpbuf[40];
1870 DWORD len, type;
1871 HKEY hkey = 0;
1872 UINT i, ansi_cp = 0, oem_cp = 0;
1873
1874 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL) != ERROR_SUCCESS)
1875 return;
1876
1877 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
1878 (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
1879 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
1880 (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
1881 sprintf( cpbuf, "%u,%u", ansi_cp, oem_cp );
1882
1883 len = sizeof(buf);
1884 if (RegQueryValueExA(hkey, "Codepages", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
1885 {
1886 if (!strcmp( buf, cpbuf )) /* already set correctly */
1887 {
1888 RegCloseKey(hkey);
1889 return;
1890 }
1891 TRACE("updating registry, codepages changed %s -> %u,%u\n", buf, ansi_cp, oem_cp);
1892 }
1893 else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp, oem_cp);
1894
1895 RegSetValueExA(hkey, "Codepages", 0, REG_SZ, (const BYTE *)cpbuf, strlen(cpbuf)+1);
1896 RegCloseKey(hkey);
1897
1898 for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
1899 {
1900 if (nls_update_font_list[i].ansi_cp == ansi_cp &&
1901 nls_update_font_list[i].oem_cp == oem_cp)
1902 {
1903 HKEY hkey;
1904
1905 hkey = create_config_fonts_registry_key();
1906 RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
1907 RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
1908 RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
1909 RegCloseKey(hkey);
1910
1911 hkey = create_fonts_NT_registry_key();
1912 add_font_list(hkey, &nls_update_font_list[i]);
1913 RegCloseKey(hkey);
1914
1915 hkey = create_fonts_9x_registry_key();
1916 add_font_list(hkey, &nls_update_font_list[i]);
1917 RegCloseKey(hkey);
1918
1919 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
1920 {
1921 RegSetValueExA(hkey, "MS Shell Dlg", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].shelldlg,
1922 strlen(nls_update_font_list[i].shelldlg)+1);
1923 RegSetValueExA(hkey, "Tms Rmn", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].tmsrmn,
1924 strlen(nls_update_font_list[i].tmsrmn)+1);
1925 RegCloseKey(hkey);
1926 }
1927 return;
1928 }
1929 }
1930 FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp, oem_cp);
1931 }
1932
1933 /*************************************************************
1934 * WineEngInit
1935 *
1936 * Initialize FreeType library and create a list of available faces
1937 */
1938 BOOL WineEngInit(void)
1939 {
1940 static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
1941 static const WCHAR pathW[] = {'P','a','t','h',0};
1942 HKEY hkey;
1943 DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1944 LPVOID data;
1945 WCHAR windowsdir[MAX_PATH];
1946 char *unixname;
1947 HANDLE font_mutex;
1948 const char *data_dir;
1949
1950 TRACE("\n");
1951
1952 /* update locale dependent font info in registry */
1953 update_font_info();
1954
1955 ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
1956 if(!ft_handle) {
1957 WINE_MESSAGE(
1958 "Wine cannot find the FreeType font library. To enable Wine to\n"
1959 "use TrueType fonts please install a version of FreeType greater than\n"
1960 "or equal to 2.0.5.\n"
1961 "http://www.freetype.org\n");
1962 return FALSE;
1963 }
1964
1965 #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;}
1966
1967 LOAD_FUNCPTR(FT_Vector_Unit)
1968 LOAD_FUNCPTR(FT_Done_Face)
1969 LOAD_FUNCPTR(FT_Get_Char_Index)
1970 LOAD_FUNCPTR(FT_Get_Module)
1971 LOAD_FUNCPTR(FT_Get_Sfnt_Name)
1972 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
1973 LOAD_FUNCPTR(FT_Get_Sfnt_Table)
1974 LOAD_FUNCPTR(FT_Init_FreeType)
1975 LOAD_FUNCPTR(FT_Load_Glyph)
1976 LOAD_FUNCPTR(FT_Matrix_Multiply)
1977 LOAD_FUNCPTR(FT_MulFix)
1978 LOAD_FUNCPTR(FT_New_Face)
1979 LOAD_FUNCPTR(FT_New_Memory_Face)
1980 LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
1981 LOAD_FUNCPTR(FT_Outline_Transform)
1982 LOAD_FUNCPTR(FT_Outline_Translate)
1983 LOAD_FUNCPTR(FT_Select_Charmap)
1984 LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
1985 LOAD_FUNCPTR(FT_Vector_Transform)
1986
1987 #undef LOAD_FUNCPTR
1988 /* Don't warn if this one is missing */
1989 pFT_Library_Version = wine_dlsym(ft_handle, "FT_Library_Version", NULL, 0);
1990 pFT_Load_Sfnt_Table = wine_dlsym(ft_handle, "FT_Load_Sfnt_Table", NULL, 0);
1991 pFT_Get_First_Char = wine_dlsym(ft_handle, "FT_Get_First_Char", NULL, 0);
1992 pFT_Get_Next_Char = wine_dlsym(ft_handle, "FT_Get_Next_Char", NULL, 0);
1993 pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
1994 #ifdef HAVE_FREETYPE_FTWINFNT_H
1995 pFT_Get_WinFNT_Header = wine_dlsym(ft_handle, "FT_Get_WinFNT_Header", NULL, 0);
1996 #endif
1997 if(!wine_dlsym(ft_handle, "FT_Get_Postscript_Name", NULL, 0) &&
1998 !wine_dlsym(ft_handle, "FT_Sqrt64", NULL, 0)) {
1999 /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
2000 <= 2.0.3 has FT_Sqrt64 */
2001 goto sym_not_found;
2002 }
2003
2004 if(pFT_Init_FreeType(&library) != 0) {
2005 ERR("Can't init FreeType library\n");
2006 wine_dlclose(ft_handle, NULL, 0);
2007 ft_handle = NULL;
2008 return FALSE;
2009 }
2010 FT_Version.major=FT_Version.minor=FT_Version.patch=-1;
2011 if (pFT_Library_Version)
2012 {
2013 pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
2014 }
2015 if (FT_Version.major<=0)
2016 {
2017 FT_Version.major=2;
2018 FT_Version.minor=0;
2019 FT_Version.patch=5;
2020 }
2021 TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
2022 FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
2023 ((FT_Version.minor << 8) & 0x00ff00) |
2024 ((FT_Version.patch ) & 0x0000ff);
2025
2026 if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL) {
2027 ERR("Failed to create font mutex\n");
2028 return FALSE;
2029 }
2030 WaitForSingleObject(font_mutex, INFINITE);
2031
2032 /* load the system bitmap fonts */
2033 load_system_fonts();
2034
2035 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
2036 GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2037 strcatW(windowsdir, fontsW);
2038 if((unixname = wine_get_unix_file_name(windowsdir)))
2039 {
2040 ReadFontDir(unixname, FALSE);
2041 HeapFree(GetProcessHeap(), 0, unixname);
2042 }
2043
2044 /* load the system truetype fonts */
2045 data_dir = wine_get_data_dir();
2046 if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/")))) {
2047 strcpy(unixname, data_dir);
2048 strcat(unixname, "/fonts/");
2049 ReadFontDir(unixname, FALSE);
2050 HeapFree(GetProcessHeap(), 0, unixname);
2051 }
2052
2053 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
2054 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
2055 full path as the entry. Also look for any .fon fonts, since ReadFontDir
2056 will skip these. */
2057 if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
2058 is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
2059 &hkey) == ERROR_SUCCESS) {
2060 LPWSTR valueW;
2061 RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2062 &valuelen, &datalen, NULL, NULL);
2063
2064 valuelen++; /* returned value doesn't include room for '\0' */
2065 valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2066 data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
2067 if (valueW && data)
2068 {
2069 dlen = datalen * sizeof(WCHAR);
2070 vlen = valuelen;
2071 while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, data,
2072 &dlen) == ERROR_SUCCESS) {
2073 if(((LPWSTR)data)[0] && ((LPWSTR)data)[1] == ':')
2074 {
2075 if((unixname = wine_get_unix_file_name((LPWSTR)data)))
2076 {
2077 AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2078 HeapFree(GetProcessHeap(), 0, unixname);
2079 }
2080 }
2081 else if(dlen / 2 >= 6 && !strcmpiW(((LPWSTR)data) + dlen / 2 - 5, dot_fonW))
2082 {
2083 WCHAR pathW[MAX_PATH];
2084 static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
2085 BOOL added = FALSE;
2086
2087 sprintfW(pathW, fmtW, windowsdir, data);
2088 if((unixname = wine_get_unix_file_name(pathW)))
2089 {
2090 added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2091 HeapFree(GetProcessHeap(), 0, unixname);
2092 }
2093 if (!added)
2094 load_font_from_data_dir(data);
2095 }
2096 /* reset dlen and vlen */
2097 dlen = datalen;
2098 vlen = valuelen;
2099 }
2100 }
2101 HeapFree(GetProcessHeap(), 0, data);
2102 HeapFree(GetProcessHeap(), 0, valueW);
2103 RegCloseKey(hkey);
2104 }
2105
2106 load_fontconfig_fonts();
2107
2108 /* then look in any directories that we've specified in the config file */
2109 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
2110 if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
2111 {
2112 DWORD len;
2113 LPWSTR valueW;
2114 LPSTR valueA, ptr;
2115
2116 if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
2117 {
2118 len += sizeof(WCHAR);
2119 valueW = HeapAlloc( GetProcessHeap(), 0, len );
2120 if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
2121 {
2122 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
2123 valueA = HeapAlloc( GetProcessHeap(), 0, len );
2124 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
2125 TRACE( "got font path %s\n", debugstr_a(valueA) );
2126 ptr = valueA;
2127 while (ptr)
2128 {
2129 LPSTR next = strchr( ptr, ':' );
2130 if (next) *next++ = 0;
2131 ReadFontDir( ptr, TRUE );
2132 ptr = next;
2133 }
2134 HeapFree( GetProcessHeap(), 0, valueA );
2135 }
2136 HeapFree( GetProcessHeap(), 0, valueW );
2137 }
2138 RegCloseKey(hkey);
2139 }
2140
2141 DumpFontList();
2142 LoadSubstList();
2143 DumpSubstList();
2144 LoadReplaceList();
2145 update_reg_entries();
2146
2147 init_system_links();
2148
2149 ReleaseMutex(font_mutex);
2150 return TRUE;
2151 sym_not_found:
2152 WINE_MESSAGE(
2153 "Wine cannot find certain functions that it needs inside the FreeType\n"
2154 "font library. To enable Wine to use TrueType fonts please upgrade\n"
2155 "FreeType to at least version 2.0.5.\n"
2156 "http://www.freetype.org\n");
2157 wine_dlclose(ft_handle, NULL, 0);
2158 ft_handle = NULL;
2159 return FALSE;
2160 }
2161
2162
2163 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
2164 {
2165 TT_OS2 *pOS2;
2166 TT_HoriHeader *pHori;
2167
2168 LONG ppem;
2169
2170 pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
2171 pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
2172
2173 if(height == 0) height = 16;
2174
2175 /* Calc. height of EM square:
2176 *
2177 * For +ve lfHeight we have
2178 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
2179 * Re-arranging gives:
2180 * ppem = units_per_em * lfheight / (winAscent + winDescent)
2181 *
2182 * For -ve lfHeight we have
2183 * |lfHeight| = ppem
2184 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
2185 * with il = winAscent + winDescent - units_per_em]
2186 *
2187 */
2188
2189 if(height > 0) {
2190 if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
2191 ppem = ft_face->units_per_EM * height /
2192 (pHori->Ascender - pHori->Descender);
2193 else
2194 ppem = ft_face->units_per_EM * height /
2195 (pOS2->usWinAscent + pOS2->usWinDescent);
2196 }
2197 else
2198 ppem = -height;
2199
2200 return ppem;
2201 }
2202
2203 static struct font_mapping *map_font( const char *name )
2204 {
2205 struct font_mapping *mapping;
2206 struct stat st;
2207 int fd;
2208
2209 if ((fd = open( name, O_RDONLY )) == -1) return NULL;
2210 if (fstat( fd, &st ) == -1) goto error;
2211
2212 LIST_FOR_EACH_ENTRY( mapping, &mappings_list, struct font_mapping, entry )
2213 {
2214 if (mapping->dev == st.st_dev && mapping->ino == st.st_ino)
2215 {
2216 mapping->refcount++;
2217 close( fd );
2218 return mapping;
2219 }
2220 }
2221 if (!(mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping) )))
2222 goto error;
2223
2224 mapping->data = mmap( NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );
2225 close( fd );
2226
2227 if (mapping->data == MAP_FAILED)
2228 {
2229 HeapFree( GetProcessHeap(), 0, mapping );
2230 return NULL;
2231 }
2232 mapping->refcount = 1;
2233 mapping->dev = st.st_dev;
2234 mapping->ino = st.st_ino;
2235 mapping->size = st.st_size;
2236 list_add_tail( &mappings_list, &mapping->entry );
2237 return mapping;
2238
2239 error:
2240 close( fd );
2241 return NULL;
2242 }
2243
2244 static void unmap_font( struct font_mapping *mapping )
2245 {
2246 if (!--mapping->refcount)
2247 {
2248 list_remove( &mapping->entry );
2249 munmap( mapping->data, mapping->size );
2250 HeapFree( GetProcessHeap(), 0, mapping );
2251 }
2252 }
2253
2254 static LONG load_VDMX(GdiFont*, LONG);
2255
2256 static FT_Face OpenFontFile(GdiFont *font, char *file, FT_Long face_index, LONG width, LONG height)
2257 {
2258 FT_Error err;
2259 FT_Face ft_face;
2260
2261 TRACE("%s, %ld, %d x %d\n", debugstr_a(file), face_index, width, height);
2262
2263 if (!(font->mapping = map_font( file )))
2264 {
2265 WARN("failed to map %s\n", debugstr_a(file));
2266 return 0;
2267 }
2268
2269 err = pFT_New_Memory_Face(library, font->mapping->data, font->mapping->size, face_index, &ft_face);
2270 if(err) {
2271 ERR("FT_New_Face rets %d\n", err);
2272 return 0;
2273 }
2274
2275 /* set it here, as load_VDMX needs it */
2276 font->ft_face = ft_face;
2277
2278 if(FT_IS_SCALABLE(ft_face)) {
2279 /* load the VDMX table if we have one */
2280 font->ppem = load_VDMX(font, height);
2281 if(font->ppem == 0)
2282 font->ppem = calc_ppem_for_height(ft_face, height);
2283
2284 if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
2285 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font->ppem, err);
2286 } else {
2287 font->ppem = height;
2288 if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
2289 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width, height, err);
2290 }
2291 return ft_face;
2292 }
2293
2294
2295 static int get_nearest_charset(Face *face, int *cp)
2296 {
2297 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
2298 a single face with the requested charset. The idea is to check if
2299 the selected font supports the current ANSI codepage, if it does
2300 return the corresponding charset, else return the first charset */
2301
2302 CHARSETINFO csi;
2303 int acp = GetACP(), i;
2304 DWORD fs0;
2305
2306 *cp = acp;
2307 if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
2308 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
2309 return csi.ciCharset;
2310
2311 for(i = 0; i < 32; i++) {
2312 fs0 = 1L << i;
2313 if(face->fs.fsCsb[0] & fs0) {
2314 if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
2315 *cp = csi.ciACP;
2316 return csi.ciCharset;
2317 }
2318 else
2319 FIXME("TCI failing on %x\n", fs0);
2320 }
2321 }
2322
2323 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
2324 face->fs.fsCsb[0], face->file);
2325 *cp = acp;
2326 return DEFAULT_CHARSET;
2327 }
2328
2329 static GdiFont *alloc_font(void)
2330 {
2331 GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
2332 ret->gmsize = INIT_GM_SIZE;
2333 ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2334 ret->gmsize * sizeof(*ret->gm));
2335 ret->potm = NULL;
2336 ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
2337 ret->total_kern_pairs = (DWORD)-1;
2338 ret->kern_pairs = NULL;
2339 list_init(&ret->hfontlist);
2340 list_init(&ret->child_fonts);
2341 return ret;
2342 }
2343
2344 static void free_font(GdiFont *font)
2345 {
2346 struct list *cursor, *cursor2;
2347
2348 LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
2349 {
2350 CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
2351 struct list *first_hfont;
2352 HFONTLIST *hfontlist;
2353 list_remove(cursor);
2354 if(child->font)
2355 {
2356 first_hfont = list_head(&child->font->hfontlist);
2357 hfontlist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2358 DeleteObject(hfontlist->hfont);
2359 HeapFree(GetProcessHeap(), 0, hfontlist);
2360 free_font(child->font);
2361 }
2362 HeapFree(GetProcessHeap(), 0, child->file_name);
2363 HeapFree(GetProcessHeap(), 0, child);
2364 }
2365
2366 if (font->ft_face) pFT_Done_Face(font->ft_face);
2367 if (font->mapping) unmap_font( font->mapping );
2368 HeapFree(GetProcessHeap(), 0, font->kern_pairs);
2369 HeapFree(GetProcessHeap(), 0, font->potm);
2370 HeapFree(GetProcessHeap(), 0, font->name);
2371 HeapFree(GetProcessHeap(), 0, font->gm);
2372 HeapFree(GetProcessHeap(), 0, font);
2373 }
2374
2375
2376 /*************************************************************
2377 * load_VDMX
2378 *
2379 * load the vdmx entry for the specified height
2380 */
2381
2382 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
2383 ( ( (FT_ULong)_x4 << 24 ) | \
2384 ( (FT_ULong)_x3 << 16 ) | \
2385 ( (FT_ULong)_x2 << 8 ) | \
2386 (FT_ULong)_x1 )
2387
2388 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
2389
2390 typedef struct {
2391 BYTE bCharSet;
2392 BYTE xRatio;
2393 BYTE yStartRatio;
2394 BYTE yEndRatio;
2395 } Ratios;
2396
2397 typedef struct {
2398 WORD recs;
2399 BYTE startsz;
2400 BYTE endsz;
2401 } VDMX_group;
2402
2403 static LONG load_VDMX(GdiFont *font, LONG height)
2404 {
2405 WORD hdr[3], tmp;
2406 VDMX_group group;
2407 BYTE devXRatio, devYRatio;
2408 USHORT numRecs, numRatios;
2409 DWORD result, offset = -1;
2410 LONG ppem = 0;
2411 int i;
2412
2413 /* For documentation on VDMX records, see
2414 * http://www.microsoft.com/OpenType/OTSpec/vdmx.htm
2415 */
2416
2417 result = WineEngGetFontData(font, MS_VDMX_TAG, 0, hdr, 6);
2418
2419 if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
2420 return ppem;
2421
2422 /* FIXME: need the real device aspect ratio */
2423 devXRatio = 1;
2424 devYRatio = 1;
2425
2426 numRecs = GET_BE_WORD(hdr[1]);
2427 numRatios = GET_BE_WORD(hdr[2]);
2428
2429 TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
2430 for(i = 0; i < numRatios; i++) {
2431 Ratios ratio;
2432
2433 offset = (3 * 2) + (i * sizeof(Ratios));
2434 WineEngGetFontData(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
2435 offset = -1;
2436
2437 TRACE("Ratios[%d] %d %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
2438
2439 if((ratio.xRatio == 0 &&
2440 ratio.yStartRatio == 0 &&
2441 ratio.yEndRatio == 0) ||
2442 (devXRatio == ratio.xRatio &&
2443 devYRatio >= ratio.yStartRatio &&
2444 devYRatio <= ratio.yEndRatio))
2445 {
2446 offset = (3 * 2) + (numRatios * 4) + (i * 2);
2447 WineEngGetFontData(font, MS_VDMX_TAG, offset, &tmp, 2);
2448 offset = GET_BE_WORD(tmp);
2449 break;
2450 }
2451 }
2452
2453 if(offset == -1) {
2454 FIXME("No suitable ratio found\n");
2455 return ppem;
2456 }
2457
2458 if(WineEngGetFontData(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
2459 USHORT recs;
2460 BYTE startsz, endsz;
2461 WORD *vTable;
2462
2463 recs = GET_BE_WORD(group.recs);
2464 startsz = group.startsz;
2465 endsz = group.endsz;
2466
2467 TRACE("recs=%d startsz=%d endsz=%d\n", recs, startsz, endsz);
2468
2469 vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
2470 result = WineEngGetFontData(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
2471 if(result == GDI_ERROR) {
2472 FIXME("Failed to retrieve vTable\n");
2473 goto end;
2474 }
2475
2476 if(height > 0) {
2477 for(i = 0; i < recs; i++) {
2478 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2479 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2480 ppem = GET_BE_WORD(vTable[i * 3]);
2481
2482 if(yMax + -yMin == height) {
2483 font->yMax = yMax;
2484 font->yMin = yMin;
2485 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
2486 break;
2487 }
2488 if(yMax + -yMin > height) {
2489 if(--i < 0) {
2490 ppem = 0;
2491 goto end; /* failed */
2492 }
2493 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2494 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2495 ppem = GET_BE_WORD(vTable[i * 3]);
2496 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem, height, font->yMax, font->yMin);
2497 break;
2498 }
2499 }
2500 if(!font->yMax) {
2501 ppem = 0;
2502 TRACE("ppem not found for height %d\n", height);
2503 }
2504 } else {
2505 ppem = -height;
2506 if(ppem < startsz || ppem > endsz)
2507 goto end;
2508
2509 for(i = 0; i < recs; i++) {
2510 USHORT yPelHeight;
2511 yPelHeight = GET_BE_WORD(vTable[i * 3]);
2512
2513 if(yPelHeight > ppem)
2514 break; /* failed */
2515
2516 if(yPelHeight == ppem) {
2517 font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2518 font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2519 TRACE("ppem %d found; yMax=%d yMin=%d\n", ppem, font->yMax, font->yMin);
2520 break;
2521 }
2522 }
2523 }
2524 end:
2525 HeapFree(GetProcessHeap(), 0, vTable);
2526 }
2527
2528 return ppem;
2529 }
2530
2531 static BOOL fontcmp(GdiFont *font, FONT_DESC *fd)
2532 {
2533 if(font->font_desc.hash != fd->hash) return TRUE;
2534 if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
2535 if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
2536 if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
2537 return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
2538 }
2539
2540 static void calc_hash(FONT_DESC *pfd)
2541 {
2542 DWORD hash = 0, *ptr, two_chars;
2543 WORD *pwc;
2544 unsigned int i;
2545
2546 for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
2547 hash ^= *ptr;
2548 for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
2549 hash ^= *ptr;
2550 for(i = 0, ptr = (DWORD*)&pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
2551 two_chars = *ptr;
2552 pwc = (WCHAR *)&two_chars;
2553 if(!*pwc) break;
2554 *pwc = toupperW(*pwc);
2555 pwc++;
2556 *pwc = toupperW(*pwc);
2557 hash ^= two_chars;
2558 if(!*pwc) break;
2559 }
2560 hash ^= !pfd->can_use_bitmap;
2561 pfd->hash = hash;
2562 return;
2563 }
2564
2565 static GdiFont *find_in_cache(HFONT hfont, LOGFONTW *plf, XFORM *pxf, BOOL can_use_bitmap)
2566 {
2567 GdiFont *ret;
2568 FONT_DESC fd;
2569 HFONTLIST *hflist;
2570 struct list *font_elem_ptr, *hfontlist_elem_ptr;
2571
2572 memcpy(&fd.lf, plf, sizeof(LOGFONTW));
2573 memcpy(&fd.matrix, pxf, sizeof(FMAT2));
2574 fd.can_use_bitmap = can_use_bitmap;
2575 calc_hash(&fd);
2576
2577 /* try the in-use list */
2578 LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
2579 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2580 if(!fontcmp(ret, &fd)) {
2581 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2582 LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
2583 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
2584 if(hflist->hfont == hfont)
2585 return ret;
2586 }
2587 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2588 hflist->hfont = hfont;
2589 list_add_head(&ret->hfontlist, &hflist->entry);
2590 return ret;
2591 }
2592 }
2593
2594 /* then the unused list */
2595 font_elem_ptr = list_head(&unused_gdi_font_list);
2596 while(font_elem_ptr) {
2597 ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2598 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2599 if(!fontcmp(ret, &fd)) {
2600 if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2601 assert(list_empty(&ret->hfontlist));
2602 TRACE("Found %p in unused list\n", ret);
2603 list_remove(&ret->entry);
2604 list_add_head(&gdi_font_list, &ret->entry);
2605 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2606 hflist->hfont = hfont;
2607 list_add_head(&ret->hfontlist, &hflist->entry);
2608 return ret;
2609 }
2610 }
2611 return NULL;
2612 }
2613
2614
2615 /*************************************************************
2616 * create_child_font_list
2617 */
2618 static BOOL create_child_font_list(GdiFont *font)
2619 {
2620 BOOL ret = FALSE;
2621 SYSTEM_LINKS *font_link;
2622 CHILD_FONT *font_link_entry, *new_child;
2623
2624 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2625 {
2626 if(!strcmpW(font_link->font_name, font->name))
2627 {
2628 TRACE("found entry in system list\n");
2629 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2630 {
2631 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
2632 new_child->file_name = strdupA(font_link_entry->file_name);
2633 new_child->index = font_link_entry->index;
2634 new_child->font = NULL;
2635 list_add_tail(&font->child_fonts, &new_child->entry);
2636 TRACE("font %s %d\n", debugstr_a(new_child->file_name), new_child->index);
2637 }
2638 ret = TRUE;
2639 break;
2640 }
2641 }
2642
2643 return ret;
2644 }
2645
2646 /*************************************************************
2647 * WineEngCreateFontInstance
2648 *
2649 */
2650 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
2651 {
2652 GdiFont *ret;
2653 Face *face, *best, *best_bitmap;
2654 Family *family, *last_resort_family;
2655 struct list *family_elem_ptr, *face_elem_ptr;
2656 INT height, width = 0;
2657 unsigned int score = 0, new_score;
2658 signed int diff = 0, newdiff;
2659 BOOL bd, it, can_use_bitmap;
2660 LOGFONTW lf;
2661 CHARSETINFO csi;
2662 HFONTLIST *hflist;
2663
2664 LIST_FOR_EACH_ENTRY(ret, &child_font_list, struct tagGdiFont, entry)
2665 {
2666 struct list *first_hfont = list_head(&ret->hfontlist);
2667 hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2668 if(hflist->hfont == hfont)
2669 return ret;
2670 }
2671
2672 if (!GetObjectW( hfont, sizeof(lf), &lf )) return NULL;
2673 can_use_bitmap = GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_RA_ABLE;
2674
2675 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
2676 debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
2677 lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
2678 lf.lfEscapement);
2679
2680 /* check the cache first */
2681 if((ret = find_in_cache(hfont, &lf, &dc->xformWorld2Vport, can_use_bitmap)) != NULL) {
2682 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
2683 return ret;
2684 }
2685
2686 TRACE("not in cache\n");
2687 if(list_empty(&font_list)) /* No fonts installed */
2688 {
2689 TRACE("No fonts installed\n");
2690 return NULL;
2691 }
2692 if(!have_installed_roman_font)
2693 {
2694 TRACE("No roman font installed\n");
2695 return NULL;
2696 }
2697
2698 ret = alloc_font();
2699
2700 memcpy(&ret->font_desc.matrix, &dc->xformWorld2Vport, sizeof(FMAT2));
2701 memcpy(&ret->font_desc.lf, &lf, sizeof(LOGFONTW));
2702 ret->font_desc.can_use_bitmap = can_use_bitmap;
2703 calc_hash(&ret->font_desc);
2704 hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2705 hflist->hfont = hfont;
2706 list_add_head(&ret->hfontlist, &hflist->entry);
2707
2708
2709 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
2710 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
2711 original value lfCharSet. Note this is a special case for
2712 Symbol and doesn't happen at least for "Wingdings*" */
2713
2714 if(!strcmpiW(lf.lfFaceName, SymbolW))
2715 lf.lfCharSet = SYMBOL_CHARSET;
2716
2717 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
2718 switch(lf.lfCharSet) {
2719 case DEFAULT_CHARSET:
2720 csi.fs.fsCsb[0] = 0;
2721 break;
2722 default:
2723 FIXME("Untranslated charset %d\n", lf.lfCharSet);
2724 csi.fs.fsCsb[0] = 0;
2725 break;
2726 }
2727 }
2728
2729 family = NULL;
2730 if(lf.lfFaceName[0] != '\0') {
2731 FontSubst *psub;
2732 SYSTEM_LINKS *font_link;
2733 CHILD_FONT *font_link_entry;
2734
2735 psub = get_font_subst(&font_subst_list, lf.lfFaceName, lf.lfCharSet);
2736
2737 if(psub) {
2738 TRACE("substituting %s -> %s\n", debugstr_w(lf.lfFaceName),
2739 debugstr_w(psub->to.name));
2740 strcpyW(lf.lfFaceName, psub->to.name);
2741 }
2742
2743 /* We want a match on name and charset or just name if
2744 charset was DEFAULT_CHARSET. If the latter then
2745 we fixup the returned charset later in get_nearest_charset
2746 where we'll either use the charset of the current ansi codepage
2747 or if that's unavailable the first charset that the font supports.
2748 */
2749 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2750 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2751 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
2752 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2753 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2754 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
2755 if(face->scalable || can_use_bitmap)
2756 goto found;
2757 }
2758 }
2759 }
2760
2761 /*
2762 * Try check the SystemLink list first for a replacement font.
2763 * We may find good replacements there.
2764 */
2765 LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2766 {
2767 if(!strcmpiW(font_link->font_name, lf.lfFaceName))
2768 {
2769 TRACE("found entry in system list\n");
2770 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2771 {
2772 face = find_face_from_path_index(font_link_entry->file_name,
2773 font_link_entry->index);
2774 if (face)
2775 {
2776 family = face->family;
2777 if(csi.fs.fsCsb[0] &
2778 (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]) || !csi.fs.fsCsb[0])
2779 {
2780 if(face->scalable || can_use_bitmap)
2781 goto found;
2782 }
2783 }
2784 }
2785 }
2786 }
2787 }
2788
2789 /* If requested charset was DEFAULT_CHARSET then try using charset
2790 corresponding to the current ansi codepage */
2791 if(!csi.fs.fsCsb[0]) {
2792 INT acp = GetACP();
2793 if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
2794 FIXME("TCI failed on codepage %d\n", acp);
2795 csi.fs.fsCsb[0] = 0;
2796 } else
2797 lf.lfCharSet = csi.ciCharset;
2798 }
2799
2800 /* Face families are in the top 4 bits of lfPitchAndFamily,
2801 so mask with 0xF0 before testing */
2802
2803 if((lf.lfPitchAndFamily & FIXED_PITCH) ||
2804 (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
2805 strcpyW(lf.lfFaceName, defFixed);
2806 else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
2807 strcpyW(lf.lfFaceName, defSerif);
2808 else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
2809 strcpyW(lf.lfFaceName, defSans);
2810 else
2811 strcpyW(lf.lfFaceName, defSans);
2812 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2813 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2814 if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
2815 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2816 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2817 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
2818 if(face->scalable || can_use_bitmap)
2819 goto found;
2820 }
2821 }
2822 }
2823
2824 last_resort_family = NULL;
2825 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2826 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2827 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2828 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2829 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) {
2830 if(face->scalable)
2831 goto found;
2832 if(can_use_bitmap && !last_resort_family)
2833 last_resort_family = family;
2834 }
2835 }
2836 }
2837
2838 if(last_resort_family) {
2839 family = last_resort_family;
2840 csi.fs.fsCsb[0] = 0;
2841 goto found;
2842 }
2843
2844 LIST_FOR_EACH(family_elem_ptr, &font_list) {
2845 family = LIST_ENTRY(family_elem_ptr, Family, entry);
2846 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2847 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2848 if(face->scalable) {
2849 csi.fs.fsCsb[0] = 0;
2850 WARN("just using first face for now\n");
2851 goto found;
2852 }
2853 if(can_use_bitmap && !last_resort_family)
2854 last_resort_family = family;
2855 }
2856 }
2857 if(!last_resort_family) {
2858 FIXME("can't find a single appropriate font - bailing\n");
2859 free_font(ret);
2860 return NULL;
2861 }
2862
2863 WARN("could only find a bitmap font - this will probably look awful!\n");
2864 family = last_resort_family;
2865 csi.fs.fsCsb[0] = 0;
2866
2867 found:
2868 it = lf.lfItalic ? 1 : 0;
2869 bd = lf.lfWeight > 550 ? 1 : 0;
2870
2871 height = GDI_ROUND( (FLOAT)lf.lfHeight * dc->xformWorld2Vport.eM22 );
2872 height = lf.lfHeight < 0 ? -abs(height) : abs(height);
2873
2874 face = best = best_bitmap = NULL;
2875 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
2876 {
2877 if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
2878 {
2879 new_score = (face->Italic ^ it) + (face->Bold ^ bd);
2880 if(!best || new_score <= score)
2881 {
2882 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
2883 face->Italic, face->Bold, it, bd);
2884 score = new_score;
2885 best = face;
2886 if(best->scalable && score == 0) break;
2887 if(!best->scalable)
2888 {
2889 if(height > 0)
2890 newdiff = height - (signed int)(best->size.height);
2891 else
2892 newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
2893 if(!best_bitmap || new_score < score ||
2894 (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
2895 {
2896 TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
2897 diff = newdiff;
2898 best_bitmap = best;
2899 if(score == 0 && diff == 0) break;
2900 }
2901 }
2902 }
2903 }
2904 }
2905 if(best)
2906 face = best->scalable ? best : best_bitmap;
2907 ret->fake_italic = (it && !face->Italic);
2908 ret->fake_bold = (bd && !face->Bold);
2909
2910 memcpy(&ret->fs, &face->fs, sizeof(FONTSIGNATURE));
2911
2912 if(csi.fs.fsCsb[0]) {
2913 ret->charset = lf.lfCharSet;
2914 ret->codepage = csi.ciACP;
2915 }
2916 else
2917 ret->charset = get_nearest_charset(face, &ret->codepage);
2918
2919 TRACE("Chosen: %s %s (%s:%ld)\n", debugstr_w(family->FamilyName),
2920 debugstr_w(face->StyleName), face->file, face->face_index);
2921
2922 if(!face->scalable) {
2923 width = face->size.x_ppem >> 6;
2924 height = face->size.y_ppem >> 6;
2925 }
2926 ret->ft_face = OpenFontFile(ret, face->file, face->face_index, width, height);
2927
2928 if (!ret->ft_face)
2929 {
2930 free_font( ret );
2931 return 0;
2932 }
2933
2934 if (ret->charset == SYMBOL_CHARSET &&
2935 !pFT_Select_Charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
2936 /* No ops */
2937 }
2938 else if (!pFT_Select_Charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
2939 /* No ops */
2940 }
2941 else {
2942 pFT_Select_Charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
2943 }
2944
2945 ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
2946 ret->name = strdupW(family->FamilyName);
2947 ret->underline = lf.lfUnderline ? 0xff : 0;
2948 ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
2949 create_child_font_list(ret);
2950
2951 TRACE("caching: gdiFont=%p hfont=%p\n", ret, hfont);
2952
2953 ret->aveWidth = FT_IS_SCALABLE(ret->ft_face) ? abs(lf.lfWidth) : 0;
2954 list_add_head(&gdi_font_list, &ret->entry);
2955 return ret;
2956 }
2957
2958 static void dump_gdi_font_list(void)
2959 {
2960 GdiFont *gdiFont;
2961 struct list *elem_ptr;
2962
2963 TRACE("---------- gdiFont Cache ----------\n");
2964 LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
2965 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
2966 TRACE("gdiFont=%p %s %d\n",
2967 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
2968 }
2969
2970 TRACE("---------- Unused gdiFont Cache ----------\n");
2971 LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
2972 gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
2973 TRACE("gdiFont=%p %s %d\n",
2974 gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
2975 }
2976 }
2977
2978 /*************************************************************
2979 * WineEngDestroyFontInstance
2980 *
2981 * free the gdiFont associated with this handle
2982 *
2983 */
2984 BOOL WineEngDestroyFontInstance(HFONT handle)
2985 {
2986 GdiFont *gdiFont;
2987 HFONTLIST *hflist;
2988 BOOL ret = FALSE;
2989 struct list *font_elem_ptr, *hfontlist_elem_ptr;
2990 int i = 0;
2991
2992 LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
2993 {
2994 struct list *first_hfont = list_head(&gdiFont->hfontlist);
2995 hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2996 if(hflist->hfont == handle)
2997 {
2998 TRACE("removing child font %p from child list\n", gdiFont);
2999 list_remove(&gdiFont->entry);
3000 return TRUE;
3001 }
3002 }
3003
3004 TRACE("destroying hfont=%p\n", handle);
3005 if(TRACE_ON(font))
3006 dump_gdi_font_list();
3007
3008 font_elem_ptr = list_head(&gdi_font_list);
3009 while(font_elem_ptr) {
3010 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3011 font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
3012
3013 hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
3014 while(hfontlist_elem_ptr) {
3015 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
3016 hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
3017 if(hflist->hfont == handle) {
3018 list_remove(&hflist->entry);
3019 HeapFree(GetProcessHeap(), 0, hflist);
3020 ret = TRUE;
3021 }
3022 }
3023 if(list_empty(&gdiFont->hfontlist)) {
3024 TRACE("Moving to Unused list\n");
3025 list_remove(&gdiFont->entry);
3026 list_add_head(&unused_gdi_font_list, &gdiFont->entry);
3027 }
3028 }
3029
3030
3031 font_elem_ptr = list_head(&unused_gdi_font_list);
3032 while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
3033 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3034 while(font_elem_ptr) {
3035 gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3036 font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3037 TRACE("freeing %p\n", gdiFont);
3038 list_remove(&gdiFont->entry);
3039 free_font(gdiFont);
3040 }
3041 return ret;
3042 }
3043
3044 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
3045 NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
3046 {
3047 OUTLINETEXTMETRICW *potm = NULL;
3048 UINT size;
3049 TEXTMETRICW tm, *ptm;
3050 GdiFont *font = alloc_font();
3051 LONG width, height;
3052
3053 if(face->scalable) {
3054 height = 100;
3055 width = 0;
3056 } else {
3057 height = face->size.y_ppem >> 6;
3058 width = face->size.x_ppem >> 6;
3059 }
3060
3061 if (!(font->ft_face = OpenFontFile(font, face->file, face->face_index, width, height)))
3062 {
3063 free_font(font);
3064 return;
3065 }
3066
3067 font->name = strdupW(face->family->FamilyName);
3068
3069 memset(&pelf->elfLogFont, 0, sizeof(LOGFONTW));
3070
3071 size = WineEngGetOutlineTextMetrics(font, 0, NULL);
3072 if(size) {
3073 potm = HeapAlloc(GetProcessHeap(), 0, size);
3074 WineEngGetOutlineTextMetrics(font, size, potm);
3075 ptm = (TEXTMETRICW*)&potm->otmTextMetrics;
3076 } else {
3077 WineEngGetTextMetrics(font, &tm);
3078 ptm = &tm;
3079 }
3080
3081 pntm->ntmTm.tmHeight = pelf->elfLogFont.lfHeight = ptm->tmHeight;
3082 pntm->ntmTm.tmAscent = ptm->tmAscent;
3083 pntm->ntmTm.tmDescent = ptm->tmDescent;
3084 pntm->ntmTm.tmInternalLeading = ptm->tmInternalLeading;
3085 pntm->ntmTm.tmExternalLeading = ptm->tmExternalLeading;
3086 pntm->ntmTm.tmAveCharWidth = pelf->elfLogFont.lfWidth = ptm->tmAveCharWidth;
3087 pntm->ntmTm.tmMaxCharWidth = ptm->tmMaxCharWidth;
3088 pntm->ntmTm.tmWeight = pelf->elfLogFont.lfWeight = ptm->tmWeight;
3089 pntm->ntmTm.tmOverhang = ptm->tmOverhang;
3090 pntm->ntmTm.tmDigitizedAspectX = ptm->tmDigitizedAspectX;
3091 pntm->ntmTm.tmDigitizedAspectY = ptm->tmDigitizedAspectY;
3092 pntm->ntmTm.tmFirstChar = ptm->tmFirstChar;
3093 pntm->ntmTm.tmLastChar = ptm->tmLastChar;
3094 pntm->ntmTm.tmDefaultChar = ptm->tmDefaultChar;
3095 pntm->ntmTm.tmBreakChar = ptm->tmBreakChar;
3096 pntm->ntmTm.tmItalic = pelf->elfLogFont.lfItalic = ptm->tmItalic;
3097 pntm->ntmTm.tmUnderlined = pelf->elfLogFont.lfUnderline = ptm->tmUnderlined;
3098 pntm->ntmTm.tmStruckOut = pelf->elfLogFont.lfStrikeOut = ptm->tmStruckOut;
3099 pntm->ntmTm.tmPitchAndFamily = ptm->tmPitchAndFamily;
3100 pelf->elfLogFont.lfPitchAndFamily = (ptm->tmPitchAndFamily & 0xf1) + 1;
3101 pntm->ntmTm.tmCharSet = pelf->elfLogFont.lfCharSet = ptm->tmCharSet;
3102 pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
3103 pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
3104 pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
3105
3106 *ptype = ptm->tmPitchAndFamily & TMPF_TRUETYPE ? TRUETYPE_FONTTYPE : 0;
3107 if(!(ptm->tmPitchAndFamily & TMPF_VECTOR))
3108 *ptype |= RASTER_FONTTYPE;
3109
3110 pntm->ntmTm.ntmFlags = ptm->tmItalic ? NTM_ITALIC : 0;
3111 if(ptm->tmWeight > 550) pntm->ntmTm.ntmFlags |= NTM_BOLD;
3112 if(pntm->ntmTm.ntmFlags == 0) pntm->ntmTm.ntmFlags = NTM_REGULAR;
3113
3114 pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
3115 pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
3116 memset(&pntm->ntmFontSig, 0, sizeof(FONTSIGNATURE));
3117
3118 if(potm) {
3119 pntm->ntmTm.ntmSizeEM = potm->otmEMSquare;
3120
3121 lstrcpynW(pelf->elfLogFont.lfFaceName,
3122 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFamilyName),
3123 LF_FACESIZE);
3124 lstrcpynW(pelf->elfFullName,
3125 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFaceName),
3126 LF_FULLFACESIZE);
3127 lstrcpynW(pelf->elfStyle,
3128 (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpStyleName),
3129 LF_FACESIZE);
3130
3131 HeapFree(GetProcessHeap(), 0, potm);
3132 } else {
3133 pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
3134
3135 lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
3136 lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FACESIZE);
3137 pelf->elfStyle[0] = '\0';
3138 }
3139
3140 pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
3141
3142 free_font(font);
3143 }
3144
3145 /*************************************************************
3146 * WineEngEnumFonts
3147 *
3148 */
3149 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
3150 {
3151 Family *family;
3152 Face *face;
3153 struct list *family_elem_ptr, *face_elem_ptr;
3154 ENUMLOGFONTEXW elf;
3155 NEWTEXTMETRICEXW ntm;
3156 DWORD type, ret = 1;
3157 FONTSIGNATURE fs;
3158 CHARSETINFO csi;
3159 LOGFONTW lf;
3160 int i;
3161
3162 TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
3163
3164 if(plf->lfFaceName[0]) {
3165 FontSubst *psub;
3166 psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
3167
3168 if(psub) {
3169 TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
3170 debugstr_w(psub->to.name));
3171 memcpy(&lf, plf, sizeof(lf));
3172 strcpyW(lf.lfFaceName, psub->to.name);
3173 plf = &lf;
3174 }
3175
3176 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3177 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3178 if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
3179 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3180 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3181 GetEnumStructs(face, &elf, &ntm, &type);
3182 for(i = 0; i < 32; i++) {
3183 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3184 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3185 strcpyW(elf.elfScript, OEM_DOSW);
3186 i = 32; /* break out of loop */
3187 } else if(!(face->fs.fsCsb[0] & (1L << i)))
3188 continue;
3189 else {
3190 fs.fsCsb[0] = 1L << i;
3191 fs.fsCsb[1] = 0;
3192 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3193 TCI_SRCFONTSIG))
3194 csi.ciCharset = DEFAULT_CHARSET;
3195 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3196 if(csi.ciCharset != DEFAULT_CHARSET) {
3197 elf.elfLogFont.lfCharSet =
3198 ntm.ntmTm.tmCharSet = csi.ciCharset;
3199 if(ElfScriptsW[i])
3200 strcpyW(elf.elfScript, ElfScriptsW[i]);
3201 else
3202 FIXME("Unknown elfscript for bit %d\n", i);
3203 }
3204 }
3205 TRACE("enuming face %s full %s style %s charset %d type %d script %s it %d weight %d ntmflags %08x\n",
3206 debugstr_w(elf.elfLogFont.lfFaceName),
3207 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3208 csi.ciCharset, type, debugstr_w(elf.elfScript),
3209 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3210 ntm.ntmTm.ntmFlags);
3211 ret = proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam);
3212 if(!ret) goto end;
3213 }
3214 }
3215 }
3216 }
3217 } else {
3218 LIST_FOR_EACH(family_elem_ptr, &font_list) {
3219 family = LIST_ENTRY(family_elem_ptr, Family, entry);
3220 face_elem_ptr = list_head(&family->faces);
3221 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3222 GetEnumStructs(face, &elf, &ntm, &type);
3223 for(i = 0; i < 32; i++) {
3224 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3225 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3226 strcpyW(elf.elfScript, OEM_DOSW);
3227 i = 32; /* break out of loop */
3228 } else if(!(face->fs.fsCsb[0] & (1L << i)))
3229 continue;
3230 else {
3231 fs.fsCsb[0] = 1L << i;
3232 fs.fsCsb[1] = 0;
3233 if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3234 TCI_SRCFONTSIG))
3235 csi.ciCharset = DEFAULT_CHARSET;
3236 if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3237 if(csi.ciCharset != DEFAULT_CHARSET) {
3238 elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet =
3239 csi.ciCharset;
3240 if(ElfScriptsW[i])
3241 strcpyW(elf.elfScript, ElfScriptsW[i]);
3242 else
3243 FIXME("Unknown elfscript for bit %d\n", i);
3244 }
3245 }
3246 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
3247 debugstr_w(elf.elfLogFont.lfFaceName),
3248 debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3249 csi.ciCharset, type, debugstr_w(elf.elfScript),
3250 elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3251 ntm.ntmTm.ntmFlags);
3252 ret = proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam);
3253 if(!ret) goto end;
3254 }
3255 }
3256 }
3257 end:
3258 return ret;
3259 }
3260
3261 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
3262 {
3263 pt->x.value = vec->x >> 6;
3264 pt->x.fract = (vec->x & 0x3f) << 10;
3265 pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
3266 pt->y.value = vec->y >> 6;
3267 pt->y.fract = (vec->y & 0x3f) << 10;
3268 pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
3269 return;
3270 }
3271
3272 /***************************************************
3273 * According to the MSDN documentation on WideCharToMultiByte,
3274 * certain codepages cannot set the default_used parameter.
3275 * This returns TRUE if the codepage can set that parameter, false else
3276 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
3277 */
3278 static BOOL codepage_sets_default_used(UINT codepage)
3279 {
3280 switch (codepage)
3281 {
3282 case CP_UTF7:
3283 case CP_UTF8:
3284 case CP_SYMBOL:
3285 return FALSE;
3286 default:
3287 return TRUE;
3288 }
3289 }
3290
3291 static FT_UInt get_glyph_index(GdiFont *font, UINT glyph)
3292 {
3293 if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
3294 WCHAR wc = (WCHAR)glyph;
3295 BOOL default_used;
3296 BOOL *default_used_pointer;
3297 FT_UInt ret;
3298 char buf;
3299 default_used_pointer = NULL;
3300 default_used = FALSE;
3301 if (codepage_sets_default_used(font->codepage))
3302 default_used_pointer = &default_used;
3303 if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
3304 ret = 0;
3305 else
3306 ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
3307 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
3308 return ret;
3309 }
3310
3311 if(font->charset == SYMBOL_CHARSET && glyph < 0x100)
3312 glyph = glyph + 0xf000;
3313 return pFT_Get_Char_Index(font->ft_face, glyph);
3314 }
3315
3316 /*************************************************************
3317 * WineEngGetGlyphIndices
3318 *
3319 * FIXME: add support for GGI_MARK_NONEXISTING_GLYPHS
3320 */
3321 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
3322 LPWORD pgi, DWORD flags)
3323 {
3324 int i;
3325 WCHAR default_char = 0;
3326 TEXTMETRICW textm;
3327
3328 if (flags & GGI_MARK_NONEXISTING_GLYPHS) default_char = 0x001f; /* Indicate non existence */
3329
3330 for(i = 0; i < count; i++)
3331 {
3332 pgi[i] = get_glyph_index(font, lpstr[i]);
3333 if (pgi[i] == 0)
3334 {
3335 if (!default_char)
3336 {
3337 WineEngGetTextMetrics(font, &textm);
3338 default_char = textm.tmDefaultChar;
3339 }
3340 pgi[i] = default_char;
3341 }
3342 }
3343 return count;
3344 }
3345
3346 /*************************************************************
3347 * WineEngGetGlyphOutline
3348 *
3349 * Behaves in exactly the same way as the win32 api GetGlyphOutline
3350 * except that the first parameter is the HWINEENGFONT of the font in
3351 * question rather than an HDC.
3352 *
3353 */
3354 DWORD WineEngGetGlyphOutline(GdiFont *incoming_font, UINT glyph, UINT format,
3355 LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
3356 const MAT2* lpmat)
3357 {
3358 static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
3359 FT_Face ft_face = incoming_font->ft_face;
3360 GdiFont *font = incoming_font;
3361 FT_UInt glyph_index;
3362 DWORD width, height, pitch, needed = 0;
3363 FT_Bitmap ft_bitmap;
3364 FT_Error err;
3365 INT left, right, top = 0, bottom = 0;
3366 FT_Angle angle = 0;
3367 FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
3368 float widthRatio = 1.0;
3369 FT_Matrix transMat = identityMat;
3370 BOOL needsTransform = FALSE;
3371
3372
3373 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
3374 buflen, buf, lpmat);
3375
3376 if(format & GGO_GLYPH_INDEX) {
3377 glyph_index = glyph;
3378 format &= ~GGO_GLYPH_INDEX;
3379 } else {
3380 get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
3381 ft_face = font->ft_face;
3382 }
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 */
Windows API implementation