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