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