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