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