2 * FreeType font engine interface
4 * Copyright 2001 Huw D M Davies for CodeWeavers.
5 * Copyright 2006 Dmitry Timoshkov for CodeWeavers.
7 * This file contains the WineEng* functions.
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/port.h"
29 #ifdef HAVE_SYS_STAT_H
30 # include <sys/stat.h>
32 #ifdef HAVE_SYS_MMAN_H
33 # include <sys/mman.h>
42 #ifdef HAVE_CARBON_CARBON_H
43 #define LoadResource __carbon_LoadResource
44 #define CompareString __carbon_CompareString
45 #define GetCurrentThread __carbon_GetCurrentThread
46 #define GetCurrentProcess __carbon_GetCurrentProcess
47 #define AnimatePalette __carbon_AnimatePalette
48 #define EqualRgn __carbon_EqualRgn
49 #define FillRgn __carbon_FillRgn
50 #define FrameRgn __carbon_FrameRgn
51 #define GetPixel __carbon_GetPixel
52 #define InvertRgn __carbon_InvertRgn
53 #define LineTo __carbon_LineTo
54 #define OffsetRgn __carbon_OffsetRgn
55 #define PaintRgn __carbon_PaintRgn
56 #define Polygon __carbon_Polygon
57 #define ResizePalette __carbon_ResizePalette
58 #define SetRectRgn __carbon_SetRectRgn
59 #include <Carbon/Carbon.h>
62 #undef GetCurrentThread
65 #undef GetCurrentProcess
78 #endif /* HAVE_CARBON_CARBON_H */
86 #include "gdi_private.h"
87 #include "wine/unicode.h"
88 #include "wine/debug.h"
89 #include "wine/list.h"
91 WINE_DEFAULT_DEBUG_CHANNEL(font
);
95 #ifdef HAVE_FT2BUILD_H
98 #ifdef HAVE_FREETYPE_FREETYPE_H
99 #include <freetype/freetype.h>
101 #ifdef HAVE_FREETYPE_FTGLYPH_H
102 #include <freetype/ftglyph.h>
104 #ifdef HAVE_FREETYPE_TTTABLES_H
105 #include <freetype/tttables.h>
107 #ifdef HAVE_FREETYPE_FTTYPES_H
108 #include <freetype/fttypes.h>
110 #ifdef HAVE_FREETYPE_FTSNAMES_H
111 #include <freetype/ftsnames.h>
113 # ifdef HAVE_FREETYPE_FTNAMES_H
114 # include <freetype/ftnames.h>
117 #ifdef HAVE_FREETYPE_TTNAMEID_H
118 #include <freetype/ttnameid.h>
120 #ifdef HAVE_FREETYPE_FTOUTLN_H
121 #include <freetype/ftoutln.h>
123 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
124 #include <freetype/internal/sfnt.h>
126 #ifdef HAVE_FREETYPE_FTTRIGON_H
127 #include <freetype/fttrigon.h>
129 #ifdef HAVE_FREETYPE_FTWINFNT_H
130 #include <freetype/ftwinfnt.h>
132 #ifdef HAVE_FREETYPE_FTMODAPI_H
133 #include <freetype/ftmodapi.h>
136 #ifndef HAVE_FT_TRUETYPEENGINETYPE
139 FT_TRUETYPE_ENGINE_TYPE_NONE
= 0,
140 FT_TRUETYPE_ENGINE_TYPE_UNPATENTED
,
141 FT_TRUETYPE_ENGINE_TYPE_PATENTED
142 } FT_TrueTypeEngineType
;
145 static FT_Library library
= 0;
152 static FT_Version_t FT_Version
;
153 static DWORD FT_SimpleVersion
;
155 static void *ft_handle
= NULL
;
157 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
158 MAKE_FUNCPTR(FT_Vector_Unit
);
159 MAKE_FUNCPTR(FT_Done_Face
);
160 MAKE_FUNCPTR(FT_Get_Char_Index
);
161 MAKE_FUNCPTR(FT_Get_Module
);
162 MAKE_FUNCPTR(FT_Get_Sfnt_Name
);
163 MAKE_FUNCPTR(FT_Get_Sfnt_Name_Count
);
164 MAKE_FUNCPTR(FT_Get_Sfnt_Table
);
165 MAKE_FUNCPTR(FT_Init_FreeType
);
166 MAKE_FUNCPTR(FT_Load_Glyph
);
167 MAKE_FUNCPTR(FT_Matrix_Multiply
);
168 #ifdef FT_MULFIX_INLINED
169 #define pFT_MulFix FT_MULFIX_INLINED
171 MAKE_FUNCPTR(FT_MulFix
);
173 MAKE_FUNCPTR(FT_New_Face
);
174 MAKE_FUNCPTR(FT_New_Memory_Face
);
175 MAKE_FUNCPTR(FT_Outline_Get_Bitmap
);
176 MAKE_FUNCPTR(FT_Outline_Transform
);
177 MAKE_FUNCPTR(FT_Outline_Translate
);
178 MAKE_FUNCPTR(FT_Select_Charmap
);
179 MAKE_FUNCPTR(FT_Set_Charmap
);
180 MAKE_FUNCPTR(FT_Set_Pixel_Sizes
);
181 MAKE_FUNCPTR(FT_Vector_Transform
);
182 static void (*pFT_Library_Version
)(FT_Library
,FT_Int
*,FT_Int
*,FT_Int
*);
183 static FT_Error (*pFT_Load_Sfnt_Table
)(FT_Face
,FT_ULong
,FT_Long
,FT_Byte
*,FT_ULong
*);
184 static FT_ULong (*pFT_Get_First_Char
)(FT_Face
,FT_UInt
*);
185 static FT_ULong (*pFT_Get_Next_Char
)(FT_Face
,FT_ULong
,FT_UInt
*);
186 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type
)(FT_Library
);
187 #ifdef HAVE_FREETYPE_FTWINFNT_H
188 MAKE_FUNCPTR(FT_Get_WinFNT_Header
);
191 #ifdef SONAME_LIBFONTCONFIG
192 #include <fontconfig/fontconfig.h>
193 MAKE_FUNCPTR(FcConfigGetCurrent
);
194 MAKE_FUNCPTR(FcFontList
);
195 MAKE_FUNCPTR(FcFontSetDestroy
);
196 MAKE_FUNCPTR(FcInit
);
197 MAKE_FUNCPTR(FcObjectSetAdd
);
198 MAKE_FUNCPTR(FcObjectSetCreate
);
199 MAKE_FUNCPTR(FcObjectSetDestroy
);
200 MAKE_FUNCPTR(FcPatternCreate
);
201 MAKE_FUNCPTR(FcPatternDestroy
);
202 MAKE_FUNCPTR(FcPatternGetBool
);
203 MAKE_FUNCPTR(FcPatternGetString
);
209 #define FT_MAKE_TAG( ch0, ch1, ch2, ch3 ) \
210 ( ((DWORD)(BYTE)(ch0) << 24) | ((DWORD)(BYTE)(ch1) << 16) | \
211 ((DWORD)(BYTE)(ch2) << 8) | (DWORD)(BYTE)(ch3) )
214 #ifndef ft_encoding_none
215 #define FT_ENCODING_NONE ft_encoding_none
217 #ifndef ft_encoding_ms_symbol
218 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
220 #ifndef ft_encoding_unicode
221 #define FT_ENCODING_UNICODE ft_encoding_unicode
223 #ifndef ft_encoding_apple_roman
224 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
227 #ifdef WORDS_BIGENDIAN
228 #define GET_BE_WORD(x) (x)
230 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
233 /* This is basically a copy of FT_Bitmap_Size with an extra element added */
240 FT_Short internal_leading
;
243 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
244 So to let this compile on older versions of FreeType we'll define the
245 new structure here. */
247 FT_Short height
, width
;
248 FT_Pos size
, x_ppem
, y_ppem
;
254 NEWTEXTMETRICEXW ntm
;
258 typedef struct tagFace
{
263 DWORD font_data_size
;
266 FONTSIGNATURE fs_links
;
268 FT_Fixed font_version
;
270 Bitmap_Size size
; /* set if face is a bitmap */
271 BOOL external
; /* TRUE if we should manually add this font to the registry */
272 struct tagFamily
*family
;
273 /* Cached data for Enum */
274 struct enum_data
*cached_enum_data
;
277 typedef struct tagFamily
{
279 const WCHAR
*FamilyName
;
285 INT adv
; /* These three hold to widths of the unrotated chars */
303 typedef struct tagHFONTLIST
{
318 struct list hfontlist
;
319 OUTLINETEXTMETRICW
*potm
;
320 DWORD total_kern_pairs
;
321 KERNINGPAIR
*kern_pairs
;
322 struct list child_fonts
;
324 /* the following members can be accessed without locking, they are never modified after creation */
326 struct font_mapping
*mapping
;
349 const WCHAR
*font_name
;
353 #define GM_BLOCK_SIZE 128
354 #define FONT_GM(font,idx) (&(font)->gm[(idx) / GM_BLOCK_SIZE][(idx) % GM_BLOCK_SIZE])
356 static struct list gdi_font_list
= LIST_INIT(gdi_font_list
);
357 static struct list unused_gdi_font_list
= LIST_INIT(unused_gdi_font_list
);
358 #define UNUSED_CACHE_SIZE 10
359 static struct list child_font_list
= LIST_INIT(child_font_list
);
360 static struct list system_links
= LIST_INIT(system_links
);
362 static struct list font_subst_list
= LIST_INIT(font_subst_list
);
364 static struct list font_list
= LIST_INIT(font_list
);
366 static const WCHAR defSerif
[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
367 static const WCHAR defSans
[] = {'A','r','i','a','l','\0'};
368 static const WCHAR defFixed
[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
370 static const WCHAR fontsW
[] = {'\\','f','o','n','t','s','\0'};
371 static const WCHAR win9x_font_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
372 'W','i','n','d','o','w','s','\\',
373 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
374 'F','o','n','t','s','\0'};
376 static const WCHAR winnt_font_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
377 'W','i','n','d','o','w','s',' ','N','T','\\',
378 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
379 'F','o','n','t','s','\0'};
381 static const WCHAR system_fonts_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
382 static const WCHAR FixedSys_Value
[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
383 static const WCHAR System_Value
[] = {'F','O','N','T','S','.','F','O','N','\0'};
384 static const WCHAR OEMFont_Value
[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
386 static const WCHAR
* const SystemFontValues
[4] = {
393 static const WCHAR external_fonts_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
394 'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
396 static const WCHAR ArabicW
[] = {'A','r','a','b','i','c','\0'};
397 static const WCHAR BalticW
[] = {'B','a','l','t','i','c','\0'};
398 static const WCHAR CHINESE_BIG5W
[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
399 static const WCHAR CHINESE_GB2312W
[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
400 static const WCHAR Central_EuropeanW
[] = {'C','e','n','t','r','a','l',' ',
401 'E','u','r','o','p','e','a','n','\0'};
402 static const WCHAR CyrillicW
[] = {'C','y','r','i','l','l','i','c','\0'};
403 static const WCHAR GreekW
[] = {'G','r','e','e','k','\0'};
404 static const WCHAR HangulW
[] = {'H','a','n','g','u','l','\0'};
405 static const WCHAR Hangul_Johab_W
[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
406 static const WCHAR HebrewW
[] = {'H','e','b','r','e','w','\0'};
407 static const WCHAR JapaneseW
[] = {'J','a','p','a','n','e','s','e','\0'};
408 static const WCHAR SymbolW
[] = {'S','y','m','b','o','l','\0'};
409 static const WCHAR ThaiW
[] = {'T','h','a','i','\0'};
410 static const WCHAR TurkishW
[] = {'T','u','r','k','i','s','h','\0'};
411 static const WCHAR VietnameseW
[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
412 static const WCHAR WesternW
[] = {'W','e','s','t','e','r','n','\0'};
413 static const WCHAR OEM_DOSW
[] = {'O','E','M','/','D','O','S','\0'};
415 static const WCHAR
* const ElfScriptsW
[32] = { /* these are in the order of the fsCsb[0] bits */
425 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /*15*/
433 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
442 typedef struct tagFontSubst
{
458 static struct list mappings_list
= LIST_INIT( mappings_list
);
460 static BOOL have_installed_roman_font
= FALSE
; /* CreateFontInstance will fail if this is still FALSE */
462 static CRITICAL_SECTION freetype_cs
;
463 static CRITICAL_SECTION_DEBUG critsect_debug
=
466 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
467 0, 0, { (DWORD_PTR
)(__FILE__
": freetype_cs") }
469 static CRITICAL_SECTION freetype_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
471 static const WCHAR font_mutex_nameW
[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
473 static const WCHAR szDefaultFallbackLink
[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0};
474 static BOOL use_default_fallback
= FALSE
;
476 static BOOL
get_glyph_index_linked(GdiFont
*font
, UINT c
, GdiFont
**linked_font
, FT_UInt
*glyph
);
478 /****************************************
479 * Notes on .fon files
481 * The fonts System, FixedSys and Terminal are special. There are typically multiple
482 * versions installed for different resolutions and codepages. Windows stores which one to use
483 * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
485 * FIXEDFON.FON FixedSys
487 * OEMFONT.FON Terminal
488 * LogPixels Current dpi set by the display control panel applet
489 * (HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontDPI
490 * also has a LogPixels value that appears to mirror this)
492 * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
493 * (vgaoem.fon would be your oemfont.fon if you have a US setup).
494 * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
495 * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
496 * so that makes sense.
498 * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
499 * to be mapped into the registry on Windows 2000 at least).
502 * ega80woa.fon=ega80850.fon
503 * ega40woa.fon=ega40850.fon
504 * cga80woa.fon=cga80850.fon
505 * cga40woa.fon=cga40850.fon
508 /* These are all structures needed for the GSUB table */
510 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
511 #define TATEGAKI_LOWER_BOUND 0x02F1
527 GSUB_ScriptRecord ScriptRecord
[1];
533 } GSUB_LangSysRecord
;
538 GSUB_LangSysRecord LangSysRecord
[1];
542 WORD LookupOrder
; /* Reserved */
543 WORD ReqFeatureIndex
;
545 WORD FeatureIndex
[1];
551 } GSUB_FeatureRecord
;
555 GSUB_FeatureRecord FeatureRecord
[1];
559 WORD FeatureParams
; /* Reserved */
561 WORD LookupListIndex
[1];
580 } GSUB_CoverageFormat1
;
585 WORD StartCoverageIndex
;
591 GSUB_RangeRecord RangeRecord
[1];
592 } GSUB_CoverageFormat2
;
595 WORD SubstFormat
; /* = 1 */
598 } GSUB_SingleSubstFormat1
;
601 WORD SubstFormat
; /* = 2 */
605 }GSUB_SingleSubstFormat2
;
607 #ifdef HAVE_CARBON_CARBON_H
608 static char *find_cache_dir(void)
612 static char cached_path
[MAX_PATH
];
613 static const char *wine
= "/Wine", *fonts
= "/Fonts";
615 if(*cached_path
) return cached_path
;
617 err
= FSFindFolder(kUserDomain
, kCachedDataFolderType
, kCreateFolder
, &ref
);
620 WARN("can't create cached data folder\n");
623 err
= FSRefMakePath(&ref
, (unsigned char*)cached_path
, sizeof(cached_path
));
626 WARN("can't create cached data path\n");
630 if(strlen(cached_path
) + strlen(wine
) + strlen(fonts
) + 1 > sizeof(cached_path
))
632 ERR("Could not create full path\n");
636 strcat(cached_path
, wine
);
638 if(mkdir(cached_path
, 0700) == -1 && errno
!= EEXIST
)
640 WARN("Couldn't mkdir %s\n", cached_path
);
644 strcat(cached_path
, fonts
);
645 if(mkdir(cached_path
, 0700) == -1 && errno
!= EEXIST
)
647 WARN("Couldn't mkdir %s\n", cached_path
);
654 /******************************************************************
657 * Extracts individual TrueType font files from a Mac suitcase font
658 * and saves them into the user's caches directory (see
660 * Returns a NULL terminated array of filenames.
662 * We do this because they are apps that try to read ttf files
663 * themselves and they don't like Mac suitcase files.
665 static char **expand_mac_font(const char *path
)
672 const char *filename
;
676 unsigned int size
, max_size
;
679 TRACE("path %s\n", path
);
681 s
= FSPathMakeRef((unsigned char*)path
, &ref
, FALSE
);
684 WARN("failed to get ref\n");
688 s
= FSOpenResourceFile(&ref
, 0, NULL
, fsRdPerm
, &res_ref
);
691 TRACE("no data fork, so trying resource fork\n");
692 res_ref
= FSOpenResFile(&ref
, fsRdPerm
);
695 TRACE("unable to open resource fork\n");
702 ret
.array
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, ret
.max_size
* sizeof(*ret
.array
));
705 CloseResFile(res_ref
);
709 out_dir
= find_cache_dir();
711 filename
= strrchr(path
, '/');
712 if(!filename
) filename
= path
;
715 /* output filename has the form out_dir/filename_%04x.ttf */
716 output_len
= strlen(out_dir
) + 1 + strlen(filename
) + 5 + 5;
723 unsigned short *num_faces_ptr
, num_faces
, face
;
726 ResType fond_res
= FT_MAKE_TAG('F','O','N','D');
728 fond
= Get1IndResource(fond_res
, idx
);
730 TRACE("got fond resource %d\n", idx
);
733 fam_rec
= *(FamRec
**)fond
;
734 num_faces_ptr
= (unsigned short *)(fam_rec
+ 1);
735 num_faces
= GET_BE_WORD(*num_faces_ptr
);
737 assoc
= (AsscEntry
*)(num_faces_ptr
+ 1);
738 TRACE("num faces %04x\n", num_faces
);
739 for(face
= 0; face
< num_faces
; face
++, assoc
++)
742 ResType sfnt_res
= FT_MAKE_TAG('s','f','n','t');
743 unsigned short size
, font_id
;
746 size
= GET_BE_WORD(assoc
->fontSize
);
747 font_id
= GET_BE_WORD(assoc
->fontID
);
750 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id
, size
);
754 TRACE("trying to load sfnt id %04x\n", font_id
);
755 sfnt
= GetResource(sfnt_res
, font_id
);
758 TRACE("can't get sfnt resource %04x\n", font_id
);
762 output
= HeapAlloc(GetProcessHeap(), 0, output_len
);
767 sprintf(output
, "%s/%s_%04x.ttf", out_dir
, filename
, font_id
);
769 fd
= open(output
, O_CREAT
| O_EXCL
| O_WRONLY
, 0600);
770 if(fd
!= -1 || errno
== EEXIST
)
774 unsigned char *sfnt_data
;
777 sfnt_data
= *(unsigned char**)sfnt
;
778 write(fd
, sfnt_data
, GetHandleSize(sfnt
));
782 if(ret
.size
>= ret
.max_size
- 1) /* Always want the last element to be NULL */
785 ret
.array
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, ret
.array
, ret
.max_size
* sizeof(*ret
.array
));
787 ret
.array
[ret
.size
++] = output
;
791 WARN("unable to create %s\n", output
);
792 HeapFree(GetProcessHeap(), 0, output
);
795 ReleaseResource(sfnt
);
798 ReleaseResource(fond
);
801 CloseResFile(res_ref
);
806 #endif /* HAVE_CARBON_CARBON_H */
808 static inline BOOL
is_win9x(void)
810 return GetVersion() & 0x80000000;
813 This function builds an FT_Fixed from a double. It fails if the absolute
814 value of the float number is greater than 32768.
816 static inline FT_Fixed
FT_FixedFromFloat(double f
)
822 This function builds an FT_Fixed from a FIXED. It simply put f.value
823 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
825 static inline FT_Fixed
FT_FixedFromFIXED(FIXED f
)
827 return (FT_Fixed
)((long)f
.value
<< 16 | (unsigned long)f
.fract
);
831 static Face
*find_face_from_filename(const WCHAR
*file_name
, const WCHAR
*face_name
)
836 DWORD len
= WideCharToMultiByte(CP_UNIXCP
, 0, file_name
, -1, NULL
, 0, NULL
, NULL
);
837 char *file_nameA
= HeapAlloc(GetProcessHeap(), 0, len
);
839 WideCharToMultiByte(CP_UNIXCP
, 0, file_name
, -1, file_nameA
, len
, NULL
, NULL
);
840 TRACE("looking for file %s name %s\n", debugstr_a(file_nameA
), debugstr_w(face_name
));
842 LIST_FOR_EACH_ENTRY(family
, &font_list
, Family
, entry
)
844 if(face_name
&& strcmpiW(face_name
, family
->FamilyName
))
846 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
850 file
= strrchr(face
->file
, '/');
855 if(!strcasecmp(file
, file_nameA
))
857 HeapFree(GetProcessHeap(), 0, file_nameA
);
862 HeapFree(GetProcessHeap(), 0, file_nameA
);
866 static Family
*find_family_from_name(const WCHAR
*name
)
870 LIST_FOR_EACH_ENTRY(family
, &font_list
, Family
, entry
)
872 if(!strcmpiW(family
->FamilyName
, name
))
879 static void DumpSubstList(void)
883 LIST_FOR_EACH_ENTRY(psub
, &font_subst_list
, FontSubst
, entry
)
885 if(psub
->from
.charset
!= -1 || psub
->to
.charset
!= -1)
886 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub
->from
.name
),
887 psub
->from
.charset
, debugstr_w(psub
->to
.name
), psub
->to
.charset
);
889 TRACE("%s -> %s\n", debugstr_w(psub
->from
.name
),
890 debugstr_w(psub
->to
.name
));
895 static LPWSTR
strdupW(LPCWSTR p
)
898 DWORD len
= (strlenW(p
) + 1) * sizeof(WCHAR
);
899 ret
= HeapAlloc(GetProcessHeap(), 0, len
);
904 static LPSTR
strdupA(LPCSTR p
)
907 DWORD len
= (strlen(p
) + 1);
908 ret
= HeapAlloc(GetProcessHeap(), 0, len
);
913 static FontSubst
*get_font_subst(const struct list
*subst_list
, const WCHAR
*from_name
,
918 LIST_FOR_EACH_ENTRY(element
, subst_list
, FontSubst
, entry
)
920 if(!strcmpiW(element
->from
.name
, from_name
) &&
921 (element
->from
.charset
== from_charset
||
922 element
->from
.charset
== -1))
929 #define ADD_FONT_SUBST_FORCE 1
931 static BOOL
add_font_subst(struct list
*subst_list
, FontSubst
*subst
, INT flags
)
933 FontSubst
*from_exist
, *to_exist
;
935 from_exist
= get_font_subst(subst_list
, subst
->from
.name
, subst
->from
.charset
);
937 if(from_exist
&& (flags
& ADD_FONT_SUBST_FORCE
))
939 list_remove(&from_exist
->entry
);
940 HeapFree(GetProcessHeap(), 0, &from_exist
->from
.name
);
941 HeapFree(GetProcessHeap(), 0, &from_exist
->to
.name
);
942 HeapFree(GetProcessHeap(), 0, from_exist
);
948 to_exist
= get_font_subst(subst_list
, subst
->to
.name
, subst
->to
.charset
);
952 HeapFree(GetProcessHeap(), 0, subst
->to
.name
);
953 subst
->to
.name
= strdupW(to_exist
->to
.name
);
956 list_add_tail(subst_list
, &subst
->entry
);
961 HeapFree(GetProcessHeap(), 0, subst
->from
.name
);
962 HeapFree(GetProcessHeap(), 0, subst
->to
.name
);
963 HeapFree(GetProcessHeap(), 0, subst
);
967 static void split_subst_info(NameCs
*nc
, LPSTR str
)
969 CHAR
*p
= strrchr(str
, ',');
974 nc
->charset
= strtol(p
+1, NULL
, 10);
977 len
= MultiByteToWideChar(CP_ACP
, 0, str
, -1, NULL
, 0);
978 nc
->name
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
979 MultiByteToWideChar(CP_ACP
, 0, str
, -1, nc
->name
, len
);
982 static void LoadSubstList(void)
986 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
990 if(RegOpenKeyA(HKEY_LOCAL_MACHINE
,
991 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
992 &hkey
) == ERROR_SUCCESS
) {
994 RegQueryInfoKeyA(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
995 &valuelen
, &datalen
, NULL
, NULL
);
997 valuelen
++; /* returned value doesn't include room for '\0' */
998 value
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(CHAR
));
999 data
= HeapAlloc(GetProcessHeap(), 0, datalen
);
1003 while(RegEnumValueA(hkey
, i
++, value
, &vlen
, NULL
, &type
, data
,
1004 &dlen
) == ERROR_SUCCESS
) {
1005 TRACE("Got %s=%s\n", debugstr_a(value
), debugstr_a(data
));
1007 psub
= HeapAlloc(GetProcessHeap(), 0, sizeof(*psub
));
1008 split_subst_info(&psub
->from
, value
);
1009 split_subst_info(&psub
->to
, data
);
1011 /* Win 2000 doesn't allow mapping between different charsets
1012 or mapping of DEFAULT_CHARSET */
1013 if ((psub
->from
.charset
&& psub
->to
.charset
!= psub
->from
.charset
) ||
1014 psub
->to
.charset
== DEFAULT_CHARSET
) {
1015 HeapFree(GetProcessHeap(), 0, psub
->to
.name
);
1016 HeapFree(GetProcessHeap(), 0, psub
->from
.name
);
1017 HeapFree(GetProcessHeap(), 0, psub
);
1019 add_font_subst(&font_subst_list
, psub
, 0);
1021 /* reset dlen and vlen */
1025 HeapFree(GetProcessHeap(), 0, data
);
1026 HeapFree(GetProcessHeap(), 0, value
);
1032 /*****************************************************************
1033 * get_name_table_entry
1035 * Supply the platform, encoding, language and name ids in req
1036 * and if the name exists the function will fill in the string
1037 * and string_len members. The string is owned by FreeType so
1038 * don't free it. Returns TRUE if the name is found else FALSE.
1040 static BOOL
get_name_table_entry(FT_Face ft_face
, FT_SfntName
*req
)
1043 FT_UInt num_names
, name_index
;
1045 if(FT_IS_SFNT(ft_face
))
1047 num_names
= pFT_Get_Sfnt_Name_Count(ft_face
);
1049 for(name_index
= 0; name_index
< num_names
; name_index
++)
1051 if(!pFT_Get_Sfnt_Name(ft_face
, name_index
, &name
))
1053 if((name
.platform_id
== req
->platform_id
) &&
1054 (name
.encoding_id
== req
->encoding_id
) &&
1055 (name
.language_id
== req
->language_id
) &&
1056 (name
.name_id
== req
->name_id
))
1058 req
->string
= name
.string
;
1059 req
->string_len
= name
.string_len
;
1066 req
->string_len
= 0;
1070 static WCHAR
*get_familyname(FT_Face ft_face
)
1072 WCHAR
*family
= NULL
;
1075 name
.platform_id
= TT_PLATFORM_MICROSOFT
;
1076 name
.encoding_id
= TT_MS_ID_UNICODE_CS
;
1077 name
.language_id
= GetUserDefaultLCID();
1078 name
.name_id
= TT_NAME_ID_FONT_FAMILY
;
1080 if(get_name_table_entry(ft_face
, &name
))
1084 /* String is not nul terminated and string_len is a byte length. */
1085 family
= HeapAlloc(GetProcessHeap(), 0, name
.string_len
+ 2);
1086 for(i
= 0; i
< name
.string_len
/ 2; i
++)
1088 WORD
*tmp
= (WORD
*)&name
.string
[i
* 2];
1089 family
[i
] = GET_BE_WORD(*tmp
);
1092 TRACE("Got localised name %s\n", debugstr_w(family
));
1099 /*****************************************************************
1102 * Wrapper around FT_Load_Sfnt_Table to cope with older versions
1103 * of FreeType that don't export this function.
1106 static FT_Error
load_sfnt_table(FT_Face ft_face
, FT_ULong table
, FT_Long offset
, FT_Byte
*buf
, FT_ULong
*len
)
1111 /* If the FT_Load_Sfnt_Table function is there we'll use it */
1112 if(pFT_Load_Sfnt_Table
)
1114 err
= pFT_Load_Sfnt_Table(ft_face
, table
, offset
, buf
, len
);
1116 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
1117 else /* Do it the hard way */
1119 TT_Face tt_face
= (TT_Face
) ft_face
;
1120 SFNT_Interface
*sfnt
;
1121 if (FT_Version
.major
==2 && FT_Version
.minor
==0)
1124 sfnt
= *(SFNT_Interface
**)((char*)tt_face
+ 528);
1128 /* A field was added in the middle of the structure in 2.1.x */
1129 sfnt
= *(SFNT_Interface
**)((char*)tt_face
+ 532);
1131 err
= sfnt
->load_any(tt_face
, table
, offset
, buf
, len
);
1139 MESSAGE("This version of Wine was compiled with freetype headers later than 2.2.0\n"
1140 "but is being run with a freetype library without the FT_Load_Sfnt_Table function.\n"
1141 "Please upgrade your freetype library.\n");
1144 err
= FT_Err_Unimplemented_Feature
;
1150 static inline int TestStyles(DWORD flags
, DWORD styles
)
1152 return (flags
& styles
) == styles
;
1155 static int StyleOrdering(Face
*face
)
1157 if (TestStyles(face
->ntmFlags
, NTM_BOLD
| NTM_ITALIC
))
1159 if (TestStyles(face
->ntmFlags
, NTM_ITALIC
))
1161 if (TestStyles(face
->ntmFlags
, NTM_BOLD
))
1163 if (TestStyles(face
->ntmFlags
, NTM_REGULAR
))
1166 WARN("Don't know how to order font %s %s with flags 0x%08x\n",
1167 debugstr_w(face
->family
->FamilyName
),
1168 debugstr_w(face
->StyleName
),
1174 /* Add a style of face to a font family using an ordering of the list such
1175 that regular fonts come before bold and italic, and single styles come
1176 before compound styles. */
1177 static void AddFaceToFamily(Face
*face
, Family
*family
)
1181 LIST_FOR_EACH( entry
, &family
->faces
)
1183 Face
*ent
= LIST_ENTRY(entry
, Face
, entry
);
1184 if (StyleOrdering(face
) < StyleOrdering(ent
)) break;
1186 list_add_before( entry
, &face
->entry
);
1189 #define ADDFONT_EXTERNAL_FONT 0x01
1190 #define ADDFONT_FORCE_BITMAP 0x02
1191 static INT
AddFontToList(const char *file
, void *font_data_ptr
, DWORD font_data_size
, char *fake_family
, const WCHAR
*target_family
, DWORD flags
)
1195 TT_Header
*pHeader
= NULL
;
1196 WCHAR
*english_family
, *localised_family
, *StyleW
;
1200 struct list
*family_elem_ptr
, *face_elem_ptr
;
1202 FT_Long face_index
= 0, num_faces
;
1203 #ifdef HAVE_FREETYPE_FTWINFNT_H
1204 FT_WinFNT_HeaderRec winfnt_header
;
1206 int i
, bitmap_num
, internal_leading
;
1209 /* we always load external fonts from files - otherwise we would get a crash in update_reg_entries */
1210 assert(file
|| !(flags
& ADDFONT_EXTERNAL_FONT
));
1212 #ifdef HAVE_CARBON_CARBON_H
1213 if(file
&& !fake_family
)
1215 char **mac_list
= expand_mac_font(file
);
1218 BOOL had_one
= FALSE
;
1220 for(cursor
= mac_list
; *cursor
; cursor
++)
1223 AddFontToList(*cursor
, NULL
, 0, NULL
, NULL
, flags
);
1224 HeapFree(GetProcessHeap(), 0, *cursor
);
1226 HeapFree(GetProcessHeap(), 0, mac_list
);
1231 #endif /* HAVE_CARBON_CARBON_H */
1234 char *family_name
= fake_family
;
1238 TRACE("Loading font file %s index %ld\n", debugstr_a(file
), face_index
);
1239 err
= pFT_New_Face(library
, file
, face_index
, &ft_face
);
1242 TRACE("Loading font from ptr %p size %d, index %ld\n", font_data_ptr
, font_data_size
, face_index
);
1243 err
= pFT_New_Memory_Face(library
, font_data_ptr
, font_data_size
, face_index
, &ft_face
);
1247 WARN("Unable to load font %s/%p err = %x\n", debugstr_a(file
), font_data_ptr
, err
);
1251 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*/
1252 WARN("Ignoring font %s/%p\n", debugstr_a(file
), font_data_ptr
);
1253 pFT_Done_Face(ft_face
);
1257 /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1258 if(!FT_IS_SCALABLE(ft_face
) && FT_SimpleVersion
< ((2 << 16) | (1 << 8) | (9 << 0))) {
1259 WARN("FreeType version < 2.1.9, skipping bitmap font %s/%p\n", debugstr_a(file
), font_data_ptr
);
1260 pFT_Done_Face(ft_face
);
1264 if(FT_IS_SFNT(ft_face
))
1266 if(!(pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
)) ||
1267 !pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
) ||
1268 !(pHeader
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_head
)))
1270 TRACE("Font %s/%p lacks either an OS2, HHEA or HEAD table.\n"
1271 "Skipping this font.\n", debugstr_a(file
), font_data_ptr
);
1272 pFT_Done_Face(ft_face
);
1276 /* Wine uses ttfs as an intermediate step in building its bitmap fonts;
1277 we don't want to load these. */
1278 if(!memcmp(pOS2
->achVendID
, "Wine", sizeof(pOS2
->achVendID
)))
1282 if(!load_sfnt_table(ft_face
, FT_MAKE_TAG('E','B','S','C'), 0, NULL
, &len
))
1284 TRACE("Skipping Wine bitmap-only TrueType font %s\n", debugstr_a(file
));
1285 pFT_Done_Face(ft_face
);
1291 if(!ft_face
->family_name
|| !ft_face
->style_name
) {
1292 TRACE("Font %s/%p lacks either a family or style name\n", debugstr_a(file
), font_data_ptr
);
1293 pFT_Done_Face(ft_face
);
1297 if(ft_face
->family_name
[0] == '.') /* Ignore fonts with names beginning with a dot */
1299 TRACE("Ignoring %s since its family name begins with a dot\n", debugstr_a(file
));
1300 pFT_Done_Face(ft_face
);
1306 localised_family
= get_familyname(ft_face
);
1307 if (localised_family
&& strcmpiW(localised_family
,target_family
)!=0)
1309 TRACE("Skipping Index %i: Incorrect Family name for replacement\n",(INT
)face_index
);
1310 HeapFree(GetProcessHeap(), 0, localised_family
);
1311 num_faces
= ft_face
->num_faces
;
1312 pFT_Done_Face(ft_face
);
1315 HeapFree(GetProcessHeap(), 0, localised_family
);
1319 family_name
= ft_face
->family_name
;
1323 My_FT_Bitmap_Size
*size
= NULL
;
1326 if(!FT_IS_SCALABLE(ft_face
))
1327 size
= (My_FT_Bitmap_Size
*)ft_face
->available_sizes
+ bitmap_num
;
1329 len
= MultiByteToWideChar(CP_ACP
, 0, family_name
, -1, NULL
, 0);
1330 english_family
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1331 MultiByteToWideChar(CP_ACP
, 0, family_name
, -1, english_family
, len
);
1333 localised_family
= NULL
;
1335 localised_family
= get_familyname(ft_face
);
1336 if(localised_family
&& !strcmpW(localised_family
, english_family
)) {
1337 HeapFree(GetProcessHeap(), 0, localised_family
);
1338 localised_family
= NULL
;
1343 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1344 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1345 if(!strcmpW(family
->FamilyName
, localised_family
? localised_family
: english_family
))
1350 family
= HeapAlloc(GetProcessHeap(), 0, sizeof(*family
));
1351 family
->FamilyName
= strdupW(localised_family
? localised_family
: english_family
);
1352 list_init(&family
->faces
);
1353 list_add_tail(&font_list
, &family
->entry
);
1355 if(localised_family
) {
1356 FontSubst
*subst
= HeapAlloc(GetProcessHeap(), 0, sizeof(*subst
));
1357 subst
->from
.name
= strdupW(english_family
);
1358 subst
->from
.charset
= -1;
1359 subst
->to
.name
= strdupW(localised_family
);
1360 subst
->to
.charset
= -1;
1361 add_font_subst(&font_subst_list
, subst
, 0);
1364 HeapFree(GetProcessHeap(), 0, localised_family
);
1365 HeapFree(GetProcessHeap(), 0, english_family
);
1367 len
= MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, NULL
, 0);
1368 StyleW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1369 MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, StyleW
, len
);
1371 internal_leading
= 0;
1372 memset(&fs
, 0, sizeof(fs
));
1374 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
1376 fs
.fsCsb
[0] = pOS2
->ulCodePageRange1
;
1377 fs
.fsCsb
[1] = pOS2
->ulCodePageRange2
;
1378 fs
.fsUsb
[0] = pOS2
->ulUnicodeRange1
;
1379 fs
.fsUsb
[1] = pOS2
->ulUnicodeRange2
;
1380 fs
.fsUsb
[2] = pOS2
->ulUnicodeRange3
;
1381 fs
.fsUsb
[3] = pOS2
->ulUnicodeRange4
;
1382 if(pOS2
->version
== 0) {
1385 if(!pFT_Get_First_Char
|| (pFT_Get_First_Char( ft_face
, &dummy
) < 0x100))
1386 fs
.fsCsb
[0] |= FS_LATIN1
;
1388 fs
.fsCsb
[0] |= FS_SYMBOL
;
1391 #ifdef HAVE_FREETYPE_FTWINFNT_H
1392 else if(pFT_Get_WinFNT_Header
&& !pFT_Get_WinFNT_Header(ft_face
, &winfnt_header
)) {
1394 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header
.pixel_height
, winfnt_header
.charset
,
1395 winfnt_header
.vertical_resolution
,winfnt_header
.horizontal_resolution
, winfnt_header
.nominal_point_size
);
1396 if(TranslateCharsetInfo((DWORD
*)(UINT_PTR
)winfnt_header
.charset
, &csi
, TCI_SRCCHARSET
))
1398 internal_leading
= winfnt_header
.internal_leading
;
1402 face_elem_ptr
= list_head(&family
->faces
);
1403 while(face_elem_ptr
) {
1404 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1405 face_elem_ptr
= list_next(&family
->faces
, face_elem_ptr
);
1406 if(!strcmpW(face
->StyleName
, StyleW
) &&
1407 (FT_IS_SCALABLE(ft_face
) || ((size
->y_ppem
== face
->size
.y_ppem
) && !memcmp(&fs
, &face
->fs
, sizeof(fs
)) ))) {
1408 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1409 debugstr_w(family
->FamilyName
), debugstr_w(StyleW
),
1410 face
->font_version
, pHeader
? pHeader
->Font_Revision
: 0);
1413 TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
1414 HeapFree(GetProcessHeap(), 0, StyleW
);
1415 pFT_Done_Face(ft_face
);
1418 if(!pHeader
|| pHeader
->Font_Revision
<= face
->font_version
) {
1419 TRACE("Original font is newer so skipping this one\n");
1420 HeapFree(GetProcessHeap(), 0, StyleW
);
1421 pFT_Done_Face(ft_face
);
1424 TRACE("Replacing original with this one\n");
1425 list_remove(&face
->entry
);
1426 HeapFree(GetProcessHeap(), 0, face
->file
);
1427 HeapFree(GetProcessHeap(), 0, face
->StyleName
);
1428 HeapFree(GetProcessHeap(), 0, face
);
1433 face
= HeapAlloc(GetProcessHeap(), 0, sizeof(*face
));
1434 face
->cached_enum_data
= NULL
;
1435 face
->StyleName
= StyleW
;
1438 face
->file
= strdupA(file
);
1439 face
->font_data_ptr
= NULL
;
1440 face
->font_data_size
= 0;
1445 face
->font_data_ptr
= font_data_ptr
;
1446 face
->font_data_size
= font_data_size
;
1448 face
->face_index
= face_index
;
1450 if (ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
)
1451 face
->ntmFlags
|= NTM_ITALIC
;
1452 if (ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
)
1453 face
->ntmFlags
|= NTM_BOLD
;
1454 if (face
->ntmFlags
== 0) face
->ntmFlags
= NTM_REGULAR
;
1455 face
->font_version
= pHeader
? pHeader
->Font_Revision
: 0;
1456 face
->family
= family
;
1457 face
->external
= (flags
& ADDFONT_EXTERNAL_FONT
) ? TRUE
: FALSE
;
1459 memset(&face
->fs_links
, 0, sizeof(face
->fs_links
));
1461 if(FT_IS_SCALABLE(ft_face
)) {
1462 memset(&face
->size
, 0, sizeof(face
->size
));
1463 face
->scalable
= TRUE
;
1465 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1466 size
->height
, size
->width
, size
->size
>> 6,
1467 size
->x_ppem
>> 6, size
->y_ppem
>> 6);
1468 face
->size
.height
= size
->height
;
1469 face
->size
.width
= size
->width
;
1470 face
->size
.size
= size
->size
;
1471 face
->size
.x_ppem
= size
->x_ppem
;
1472 face
->size
.y_ppem
= size
->y_ppem
;
1473 face
->size
.internal_leading
= internal_leading
;
1474 face
->scalable
= FALSE
;
1477 /* check for the presence of the 'CFF ' table to check if the font is Type1 */
1479 if (pFT_Load_Sfnt_Table
&& !pFT_Load_Sfnt_Table(ft_face
, FT_MAKE_TAG('C','F','F',' '), 0, NULL
, &tmp_size
))
1481 TRACE("Font %s/%p is OTF Type1\n", wine_dbgstr_a(file
), font_data_ptr
);
1482 face
->ntmFlags
|= NTM_PS_OPENTYPE
;
1485 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1486 face
->fs
.fsCsb
[0], face
->fs
.fsCsb
[1],
1487 face
->fs
.fsUsb
[0], face
->fs
.fsUsb
[1],
1488 face
->fs
.fsUsb
[2], face
->fs
.fsUsb
[3]);
1491 if(face
->fs
.fsCsb
[0] == 0) { /* let's see if we can find any interesting cmaps */
1492 for(i
= 0; i
< ft_face
->num_charmaps
; i
++) {
1493 switch(ft_face
->charmaps
[i
]->encoding
) {
1494 case FT_ENCODING_UNICODE
:
1495 case FT_ENCODING_APPLE_ROMAN
:
1496 face
->fs
.fsCsb
[0] |= FS_LATIN1
;
1498 case FT_ENCODING_MS_SYMBOL
:
1499 face
->fs
.fsCsb
[0] |= FS_SYMBOL
;
1507 if (!(face
->fs
.fsCsb
[0] & FS_SYMBOL
))
1508 have_installed_roman_font
= TRUE
;
1510 AddFaceToFamily(face
, family
);
1512 } while(!FT_IS_SCALABLE(ft_face
) && ++bitmap_num
< ft_face
->num_fixed_sizes
);
1514 num_faces
= ft_face
->num_faces
;
1515 pFT_Done_Face(ft_face
);
1516 TRACE("Added font %s %s\n", debugstr_w(family
->FamilyName
),
1517 debugstr_w(StyleW
));
1518 } while(num_faces
> ++face_index
);
1522 static INT
AddFontFileToList(const char *file
, char *fake_family
, const WCHAR
*target_family
, DWORD flags
)
1524 return AddFontToList(file
, NULL
, 0, fake_family
, target_family
, flags
);
1527 static void DumpFontList(void)
1531 struct list
*family_elem_ptr
, *face_elem_ptr
;
1533 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1534 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1535 TRACE("Family: %s\n", debugstr_w(family
->FamilyName
));
1536 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
1537 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1538 TRACE("\t%s\t%08x", debugstr_w(face
->StyleName
), face
->fs
.fsCsb
[0]);
1540 TRACE(" %d", face
->size
.height
);
1547 /***********************************************************
1548 * The replacement list is a way to map an entire font
1549 * family onto another family. For example adding
1551 * [HKCU\Software\Wine\Fonts\Replacements]
1552 * "Wingdings"="Winedings"
1554 * would enumerate the Winedings font both as Winedings and
1555 * Wingdings. However if a real Wingdings font is present the
1556 * replacement does not take place.
1559 static void LoadReplaceList(void)
1562 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
1567 struct list
*family_elem_ptr
, *face_elem_ptr
;
1570 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1571 if(RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts\\Replacements", &hkey
) == ERROR_SUCCESS
)
1573 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
1574 &valuelen
, &datalen
, NULL
, NULL
);
1576 valuelen
++; /* returned value doesn't include room for '\0' */
1577 value
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
1578 data
= HeapAlloc(GetProcessHeap(), 0, datalen
);
1582 while(RegEnumValueW(hkey
, i
++, value
, &vlen
, NULL
, &type
, data
,
1583 &dlen
) == ERROR_SUCCESS
) {
1584 TRACE("Got %s=%s\n", debugstr_w(value
), debugstr_w(data
));
1585 /* "NewName"="Oldname" */
1586 WideCharToMultiByte(CP_ACP
, 0, value
, -1, familyA
, sizeof(familyA
), NULL
, NULL
);
1588 /* Find the old family and hence all of the font files
1590 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1591 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1592 if(!strcmpiW(family
->FamilyName
, data
)) {
1593 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
1594 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1595 TRACE("mapping %s %s to %s\n", debugstr_w(family
->FamilyName
),
1596 debugstr_w(face
->StyleName
), familyA
);
1597 /* Now add a new entry with the new family name */
1598 AddFontToList(face
->file
, face
->font_data_ptr
, face
->font_data_size
, familyA
, family
->FamilyName
, ADDFONT_FORCE_BITMAP
| (face
->external
? ADDFONT_EXTERNAL_FONT
: 0));
1603 /* reset dlen and vlen */
1607 HeapFree(GetProcessHeap(), 0, data
);
1608 HeapFree(GetProcessHeap(), 0, value
);
1613 /*************************************************************
1616 static BOOL
init_system_links(void)
1618 static const WCHAR system_link
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1619 'W','i','n','d','o','w','s',' ','N','T','\\',
1620 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
1621 'S','y','s','t','e','m','L','i','n','k',0};
1624 DWORD type
, max_val
, max_data
, val_len
, data_len
, index
;
1625 WCHAR
*value
, *data
;
1626 WCHAR
*entry
, *next
;
1627 SYSTEM_LINKS
*font_link
, *system_font_link
;
1628 CHILD_FONT
*child_font
;
1629 static const WCHAR Tahoma
[] = {'T','a','h','o','m','a',0};
1630 static const WCHAR tahoma_ttf
[] = {'t','a','h','o','m','a','.','t','t','f',0};
1631 static const WCHAR System
[] = {'S','y','s','t','e','m',0};
1637 if(RegOpenKeyW(HKEY_LOCAL_MACHINE
, system_link
, &hkey
) == ERROR_SUCCESS
)
1639 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, &max_val
, &max_data
, NULL
, NULL
);
1640 value
= HeapAlloc(GetProcessHeap(), 0, (max_val
+ 1) * sizeof(WCHAR
));
1641 data
= HeapAlloc(GetProcessHeap(), 0, max_data
);
1642 val_len
= max_val
+ 1;
1643 data_len
= max_data
;
1645 while(RegEnumValueW(hkey
, index
++, value
, &val_len
, NULL
, &type
, (LPBYTE
)data
, &data_len
) == ERROR_SUCCESS
)
1647 TRACE("%s:\n", debugstr_w(value
));
1649 memset(&fs
, 0, sizeof(fs
));
1650 font_link
= HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link
));
1651 psub
= get_font_subst(&font_subst_list
, value
, -1);
1652 font_link
->font_name
= (psub
)? strdupW(psub
->to
.name
) : strdupW(value
);
1653 list_init(&font_link
->links
);
1654 for(entry
= data
; (char*)entry
< (char*)data
+ data_len
&& *entry
!= 0; entry
= next
)
1657 CHILD_FONT
*child_font
;
1659 TRACE("\t%s\n", debugstr_w(entry
));
1661 next
= entry
+ strlenW(entry
) + 1;
1663 face_name
= strchrW(entry
, ',');
1667 while(isspaceW(*face_name
))
1670 psub
= get_font_subst(&font_subst_list
, face_name
, -1);
1672 face_name
= psub
->to
.name
;
1674 face
= find_face_from_filename(entry
, face_name
);
1677 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry
), debugstr_w(face_name
));
1681 child_font
= HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font
));
1682 child_font
->face
= face
;
1683 child_font
->font
= NULL
;
1684 fs
.fsCsb
[0] |= face
->fs
.fsCsb
[0];
1685 fs
.fsCsb
[1] |= face
->fs
.fsCsb
[1];
1686 TRACE("Adding file %s index %ld\n", child_font
->face
->file
, child_font
->face
->face_index
);
1687 list_add_tail(&font_link
->links
, &child_font
->entry
);
1689 family
= find_family_from_name(font_link
->font_name
);
1692 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
1694 face
->fs_links
= fs
;
1697 list_add_tail(&system_links
, &font_link
->entry
);
1698 val_len
= max_val
+ 1;
1699 data_len
= max_data
;
1702 HeapFree(GetProcessHeap(), 0, value
);
1703 HeapFree(GetProcessHeap(), 0, data
);
1707 /* Explicitly add an entry for the system font, this links to Tahoma and any links
1710 system_font_link
= HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link
));
1711 system_font_link
->font_name
= strdupW(System
);
1712 list_init(&system_font_link
->links
);
1714 face
= find_face_from_filename(tahoma_ttf
, Tahoma
);
1717 child_font
= HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font
));
1718 child_font
->face
= face
;
1719 child_font
->font
= NULL
;
1720 TRACE("Found Tahoma in %s index %ld\n", child_font
->face
->file
, child_font
->face
->face_index
);
1721 list_add_tail(&system_font_link
->links
, &child_font
->entry
);
1723 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
1725 if(!strcmpiW(font_link
->font_name
, Tahoma
))
1727 CHILD_FONT
*font_link_entry
;
1728 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
1730 CHILD_FONT
*new_child
;
1731 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
1732 new_child
->face
= font_link_entry
->face
;
1733 new_child
->font
= NULL
;
1734 list_add_tail(&system_font_link
->links
, &new_child
->entry
);
1739 list_add_tail(&system_links
, &system_font_link
->entry
);
1743 static BOOL
ReadFontDir(const char *dirname
, BOOL external_fonts
)
1746 struct dirent
*dent
;
1747 char path
[MAX_PATH
];
1749 TRACE("Loading fonts from %s\n", debugstr_a(dirname
));
1751 dir
= opendir(dirname
);
1753 WARN("Can't open directory %s\n", debugstr_a(dirname
));
1756 while((dent
= readdir(dir
)) != NULL
) {
1757 struct stat statbuf
;
1759 if(!strcmp(dent
->d_name
, ".") || !strcmp(dent
->d_name
, ".."))
1762 TRACE("Found %s in %s\n", debugstr_a(dent
->d_name
), debugstr_a(dirname
));
1764 sprintf(path
, "%s/%s", dirname
, dent
->d_name
);
1766 if(stat(path
, &statbuf
) == -1)
1768 WARN("Can't stat %s\n", debugstr_a(path
));
1771 if(S_ISDIR(statbuf
.st_mode
))
1772 ReadFontDir(path
, external_fonts
);
1774 AddFontFileToList(path
, NULL
, NULL
, external_fonts
? ADDFONT_EXTERNAL_FONT
: 0);
1780 static void load_fontconfig_fonts(void)
1782 #ifdef SONAME_LIBFONTCONFIG
1783 void *fc_handle
= NULL
;
1792 fc_handle
= wine_dlopen(SONAME_LIBFONTCONFIG
, RTLD_NOW
, NULL
, 0);
1794 TRACE("Wine cannot find the fontconfig library (%s).\n",
1795 SONAME_LIBFONTCONFIG
);
1798 #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;}
1799 LOAD_FUNCPTR(FcConfigGetCurrent
);
1800 LOAD_FUNCPTR(FcFontList
);
1801 LOAD_FUNCPTR(FcFontSetDestroy
);
1802 LOAD_FUNCPTR(FcInit
);
1803 LOAD_FUNCPTR(FcObjectSetAdd
);
1804 LOAD_FUNCPTR(FcObjectSetCreate
);
1805 LOAD_FUNCPTR(FcObjectSetDestroy
);
1806 LOAD_FUNCPTR(FcPatternCreate
);
1807 LOAD_FUNCPTR(FcPatternDestroy
);
1808 LOAD_FUNCPTR(FcPatternGetBool
);
1809 LOAD_FUNCPTR(FcPatternGetString
);
1812 if(!pFcInit()) return;
1814 config
= pFcConfigGetCurrent();
1815 pat
= pFcPatternCreate();
1816 os
= pFcObjectSetCreate();
1817 pFcObjectSetAdd(os
, FC_FILE
);
1818 pFcObjectSetAdd(os
, FC_SCALABLE
);
1819 fontset
= pFcFontList(config
, pat
, os
);
1820 if(!fontset
) return;
1821 for(i
= 0; i
< fontset
->nfont
; i
++) {
1824 if(pFcPatternGetString(fontset
->fonts
[i
], FC_FILE
, 0, (FcChar8
**)&file
) != FcResultMatch
)
1826 TRACE("fontconfig: %s\n", file
);
1828 /* We're just interested in OT/TT fonts for now, so this hack just
1829 picks up the scalable fonts without extensions .pf[ab] to save time
1830 loading every other font */
1832 if(pFcPatternGetBool(fontset
->fonts
[i
], FC_SCALABLE
, 0, &scalable
) == FcResultMatch
&& !scalable
)
1834 TRACE("not scalable\n");
1838 len
= strlen( file
);
1839 if(len
< 4) continue;
1840 ext
= &file
[ len
- 3 ];
1841 if(strcasecmp(ext
, "pfa") && strcasecmp(ext
, "pfb"))
1842 AddFontFileToList(file
, NULL
, NULL
, ADDFONT_EXTERNAL_FONT
);
1844 pFcFontSetDestroy(fontset
);
1845 pFcObjectSetDestroy(os
);
1846 pFcPatternDestroy(pat
);
1852 static BOOL
load_font_from_data_dir(LPCWSTR file
)
1855 const char *data_dir
= wine_get_data_dir();
1857 if (!data_dir
) data_dir
= wine_get_build_dir();
1864 len
= WideCharToMultiByte(CP_UNIXCP
, 0, file
, -1, NULL
, 0, NULL
, NULL
);
1866 unix_name
= HeapAlloc(GetProcessHeap(), 0, strlen(data_dir
) + len
+ sizeof("/fonts/"));
1868 strcpy(unix_name
, data_dir
);
1869 strcat(unix_name
, "/fonts/");
1871 WideCharToMultiByte(CP_UNIXCP
, 0, file
, -1, unix_name
+ strlen(unix_name
), len
, NULL
, NULL
);
1873 EnterCriticalSection( &freetype_cs
);
1874 ret
= AddFontFileToList(unix_name
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
1875 LeaveCriticalSection( &freetype_cs
);
1876 HeapFree(GetProcessHeap(), 0, unix_name
);
1881 static BOOL
load_font_from_winfonts_dir(LPCWSTR file
)
1883 static const WCHAR slashW
[] = {'\\','\0'};
1885 WCHAR windowsdir
[MAX_PATH
];
1888 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
1889 strcatW(windowsdir
, fontsW
);
1890 strcatW(windowsdir
, slashW
);
1891 strcatW(windowsdir
, file
);
1892 if ((unixname
= wine_get_unix_file_name(windowsdir
))) {
1893 EnterCriticalSection( &freetype_cs
);
1894 ret
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
1895 LeaveCriticalSection( &freetype_cs
);
1896 HeapFree(GetProcessHeap(), 0, unixname
);
1901 static void load_system_fonts(void)
1904 WCHAR data
[MAX_PATH
], windowsdir
[MAX_PATH
], pathW
[MAX_PATH
];
1905 const WCHAR
* const *value
;
1907 static const WCHAR fmtW
[] = {'%','s','\\','%','s','\0'};
1910 if(RegOpenKeyW(HKEY_CURRENT_CONFIG
, system_fonts_reg_key
, &hkey
) == ERROR_SUCCESS
) {
1911 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
1912 strcatW(windowsdir
, fontsW
);
1913 for(value
= SystemFontValues
; *value
; value
++) {
1914 dlen
= sizeof(data
);
1915 if(RegQueryValueExW(hkey
, *value
, 0, &type
, (void*)data
, &dlen
) == ERROR_SUCCESS
&&
1919 sprintfW(pathW
, fmtW
, windowsdir
, data
);
1920 if((unixname
= wine_get_unix_file_name(pathW
))) {
1921 added
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
1922 HeapFree(GetProcessHeap(), 0, unixname
);
1925 load_font_from_data_dir(data
);
1932 /*************************************************************
1934 * This adds registry entries for any externally loaded fonts
1935 * (fonts from fontconfig or FontDirs). It also deletes entries
1936 * of no longer existing fonts.
1939 static void update_reg_entries(void)
1941 HKEY winnt_key
= 0, win9x_key
= 0, external_key
= 0;
1946 struct list
*family_elem_ptr
, *face_elem_ptr
;
1948 static const WCHAR TrueType
[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
1949 static const WCHAR spaceW
[] = {' ', '\0'};
1952 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
,
1953 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &winnt_key
, NULL
) != ERROR_SUCCESS
) {
1954 ERR("Can't create Windows font reg key\n");
1958 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
,
1959 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &win9x_key
, NULL
) != ERROR_SUCCESS
) {
1960 ERR("Can't create Windows font reg key\n");
1964 if(RegCreateKeyExW(HKEY_CURRENT_USER
, external_fonts_reg_key
,
1965 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &external_key
, NULL
) != ERROR_SUCCESS
) {
1966 ERR("Can't create external font reg key\n");
1970 /* enumerate the fonts and add external ones to the two keys */
1972 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1973 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1974 len_fam
= strlenW(family
->FamilyName
) + sizeof(TrueType
) / sizeof(WCHAR
) + 1;
1975 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
1976 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1977 if(!face
->external
) continue;
1979 if (!(face
->ntmFlags
& NTM_REGULAR
))
1980 len
= len_fam
+ strlenW(face
->StyleName
) + 1;
1981 valueW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1982 strcpyW(valueW
, family
->FamilyName
);
1983 if(len
!= len_fam
) {
1984 strcatW(valueW
, spaceW
);
1985 strcatW(valueW
, face
->StyleName
);
1987 strcatW(valueW
, TrueType
);
1989 file
= wine_get_dos_file_name(face
->file
);
1991 len
= strlenW(file
) + 1;
1994 if((path
= strrchr(face
->file
, '/')) == NULL
)
1998 len
= MultiByteToWideChar(CP_ACP
, 0, path
, -1, NULL
, 0);
2000 file
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2001 MultiByteToWideChar(CP_ACP
, 0, path
, -1, file
, len
);
2003 RegSetValueExW(winnt_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2004 RegSetValueExW(win9x_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2005 RegSetValueExW(external_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2007 HeapFree(GetProcessHeap(), 0, file
);
2008 HeapFree(GetProcessHeap(), 0, valueW
);
2012 if(external_key
) RegCloseKey(external_key
);
2013 if(win9x_key
) RegCloseKey(win9x_key
);
2014 if(winnt_key
) RegCloseKey(winnt_key
);
2018 static void delete_external_font_keys(void)
2020 HKEY winnt_key
= 0, win9x_key
= 0, external_key
= 0;
2021 DWORD dlen
, vlen
, datalen
, valuelen
, i
, type
;
2025 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
,
2026 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &winnt_key
, NULL
) != ERROR_SUCCESS
) {
2027 ERR("Can't create Windows font reg key\n");
2031 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
,
2032 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &win9x_key
, NULL
) != ERROR_SUCCESS
) {
2033 ERR("Can't create Windows font reg key\n");
2037 if(RegCreateKeyW(HKEY_CURRENT_USER
, external_fonts_reg_key
, &external_key
) != ERROR_SUCCESS
) {
2038 ERR("Can't create external font reg key\n");
2042 /* Delete all external fonts added last time */
2044 RegQueryInfoKeyW(external_key
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2045 &valuelen
, &datalen
, NULL
, NULL
);
2046 valuelen
++; /* returned value doesn't include room for '\0' */
2047 valueW
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
2048 data
= HeapAlloc(GetProcessHeap(), 0, datalen
* sizeof(WCHAR
));
2050 dlen
= datalen
* sizeof(WCHAR
);
2053 while(RegEnumValueW(external_key
, i
++, valueW
, &vlen
, NULL
, &type
, data
,
2054 &dlen
) == ERROR_SUCCESS
) {
2056 RegDeleteValueW(winnt_key
, valueW
);
2057 RegDeleteValueW(win9x_key
, valueW
);
2058 /* reset dlen and vlen */
2062 HeapFree(GetProcessHeap(), 0, data
);
2063 HeapFree(GetProcessHeap(), 0, valueW
);
2065 /* Delete the old external fonts key */
2066 RegCloseKey(external_key
);
2067 RegDeleteKeyW(HKEY_CURRENT_USER
, external_fonts_reg_key
);
2070 if(win9x_key
) RegCloseKey(win9x_key
);
2071 if(winnt_key
) RegCloseKey(winnt_key
);
2074 /*************************************************************
2075 * WineEngAddFontResourceEx
2078 INT
WineEngAddFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
2081 if (ft_handle
) /* do it only if we have freetype up and running */
2086 FIXME("Ignoring flags %x\n", flags
);
2088 if((unixname
= wine_get_unix_file_name(file
)))
2090 EnterCriticalSection( &freetype_cs
);
2091 ret
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2092 LeaveCriticalSection( &freetype_cs
);
2093 HeapFree(GetProcessHeap(), 0, unixname
);
2095 if (!ret
&& !strchrW(file
, '\\')) {
2096 /* Try in %WINDIR%/fonts, needed for Fotobuch Designer */
2097 ret
= load_font_from_winfonts_dir(file
);
2099 /* Try in datadir/fonts (or builddir/fonts),
2100 * needed for Magic the Gathering Online
2102 ret
= load_font_from_data_dir(file
);
2109 /*************************************************************
2110 * WineEngAddFontMemResourceEx
2113 HANDLE
WineEngAddFontMemResourceEx(PVOID pbFont
, DWORD cbFont
, PVOID pdv
, DWORD
*pcFonts
)
2115 if (ft_handle
) /* do it only if we have freetype up and running */
2117 PVOID pFontCopy
= HeapAlloc(GetProcessHeap(), 0, cbFont
);
2119 TRACE("Copying %d bytes of data from %p to %p\n", cbFont
, pbFont
, pFontCopy
);
2120 memcpy(pFontCopy
, pbFont
, cbFont
);
2122 EnterCriticalSection( &freetype_cs
);
2123 *pcFonts
= AddFontToList(NULL
, pFontCopy
, cbFont
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2124 LeaveCriticalSection( &freetype_cs
);
2128 TRACE("AddFontToList failed\n");
2129 HeapFree(GetProcessHeap(), 0, pFontCopy
);
2132 /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
2133 * For now return something unique but quite random
2135 TRACE("Returning handle %lx\n", ((INT_PTR
)pFontCopy
)^0x87654321);
2136 return (HANDLE
)(((INT_PTR
)pFontCopy
)^0x87654321);
2143 /*************************************************************
2144 * WineEngRemoveFontResourceEx
2147 BOOL
WineEngRemoveFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
2153 static const struct nls_update_font_list
2155 UINT ansi_cp
, oem_cp
;
2156 const char *oem
, *fixed
, *system
;
2157 const char *courier
, *serif
, *small
, *sserif
;
2158 /* these are for font substitutes */
2159 const char *shelldlg
, *tmsrmn
;
2160 const char *fixed_0
, *system_0
, *courier_0
, *serif_0
, *small_0
, *sserif_0
,
2164 const char *from
, *to
;
2165 } arial_0
, courier_new_0
, times_new_roman_0
;
2166 } nls_update_font_list
[] =
2168 /* Latin 1 (United States) */
2169 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
2170 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2171 "Tahoma","Times New Roman",
2172 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2175 /* Latin 1 (Multilingual) */
2176 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
2177 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2178 "Tahoma","Times New Roman", /* FIXME unverified */
2179 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2182 /* Eastern Europe */
2183 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
2184 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
2185 "Tahoma","Times New Roman", /* FIXME unverified */
2186 "Fixedsys,238", "System,238",
2187 "Courier New,238", "MS Serif,238", "Small Fonts,238",
2188 "MS Sans Serif,238", "MS Sans Serif,238", "MS Serif,238",
2189 { "Arial CE,0", "Arial,238" },
2190 { "Courier New CE,0", "Courier New,238" },
2191 { "Times New Roman CE,0", "Times New Roman,238" }
2194 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
2195 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
2196 "Tahoma","Times New Roman", /* FIXME unverified */
2197 "Fixedsys,204", "System,204",
2198 "Courier New,204", "MS Serif,204", "Small Fonts,204",
2199 "MS Sans Serif,204", "MS Sans Serif,204", "MS Serif,204",
2200 { "Arial Cyr,0", "Arial,204" },
2201 { "Courier New Cyr,0", "Courier New,204" },
2202 { "Times New Roman Cyr,0", "Times New Roman,204" }
2205 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
2206 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
2207 "Tahoma","Times New Roman", /* FIXME unverified */
2208 "Fixedsys,161", "System,161",
2209 "Courier New,161", "MS Serif,161", "Small Fonts,161",
2210 "MS Sans Serif,161", "MS Sans Serif,161", "MS Serif,161",
2211 { "Arial Greek,0", "Arial,161" },
2212 { "Courier New Greek,0", "Courier New,161" },
2213 { "Times New Roman Greek,0", "Times New Roman,161" }
2216 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
2217 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
2218 "Tahoma","Times New Roman", /* FIXME unverified */
2219 "Fixedsys,162", "System,162",
2220 "Courier New,162", "MS Serif,162", "Small Fonts,162",
2221 "MS Sans Serif,162", "MS Sans Serif,162", "MS Serif,162",
2222 { "Arial Tur,0", "Arial,162" },
2223 { "Courier New Tur,0", "Courier New,162" },
2224 { "Times New Roman Tur,0", "Times New Roman,162" }
2227 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
2228 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
2229 "Tahoma","Times New Roman", /* FIXME unverified */
2230 "Fixedsys,177", "System,177",
2231 "Courier New,177", "MS Serif,177", "Small Fonts,177",
2232 "MS Sans Serif,177", "MS Sans Serif,177", "MS Serif,177",
2236 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
2237 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
2238 "Tahoma","Times New Roman", /* FIXME unverified */
2239 "Fixedsys,178", "System,178",
2240 "Courier New,178", "MS Serif,178", "Small Fonts,178",
2241 "MS Sans Serif,178", "MS Sans Serif,178", "MS Serif,178",
2245 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
2246 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
2247 "Tahoma","Times New Roman", /* FIXME unverified */
2248 "Fixedsys,186", "System,186",
2249 "Courier New,186", "MS Serif,186", "Small Fonts,186",
2250 "MS Sans Serif,186", "MS Sans Serif,186", "MS Serif,186",
2251 { "Arial Baltic,0", "Arial,186" },
2252 { "Courier New Baltic,0", "Courier New,186" },
2253 { "Times New Roman Baltic,0", "Times New Roman,186" }
2256 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
2257 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2258 "Tahoma","Times New Roman", /* FIXME unverified */
2259 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2263 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
2264 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
2265 "Tahoma","Times New Roman", /* FIXME unverified */
2266 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2270 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
2271 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
2272 "MS UI Gothic","MS Serif",
2273 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2276 /* Chinese Simplified */
2277 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
2278 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2279 "Tahoma", "Times New Roman", /* FIXME unverified */
2280 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2284 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
2285 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2287 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2290 /* Chinese Traditional */
2291 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
2292 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2293 "PMingLiU", "MingLiU",
2294 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2299 static inline BOOL
is_dbcs_ansi_cp(UINT ansi_cp
)
2301 return ( ansi_cp
== 932 /* CP932 for Japanese */
2302 || ansi_cp
== 936 /* CP936 for Chinese Simplified */
2303 || ansi_cp
== 949 /* CP949 for Korean */
2304 || ansi_cp
== 950 ); /* CP950 for Chinese Traditional */
2307 static inline HKEY
create_fonts_NT_registry_key(void)
2311 RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
, 0, NULL
,
2312 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2316 static inline HKEY
create_fonts_9x_registry_key(void)
2320 RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
, 0, NULL
,
2321 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2325 static inline HKEY
create_config_fonts_registry_key(void)
2329 RegCreateKeyExW(HKEY_CURRENT_CONFIG
, system_fonts_reg_key
, 0, NULL
,
2330 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2334 static void add_font_list(HKEY hkey
, const struct nls_update_font_list
*fl
)
2336 RegSetValueExA(hkey
, "Courier", 0, REG_SZ
, (const BYTE
*)fl
->courier
, strlen(fl
->courier
)+1);
2337 RegSetValueExA(hkey
, "MS Serif", 0, REG_SZ
, (const BYTE
*)fl
->serif
, strlen(fl
->serif
)+1);
2338 RegSetValueExA(hkey
, "MS Sans Serif", 0, REG_SZ
, (const BYTE
*)fl
->sserif
, strlen(fl
->sserif
)+1);
2339 RegSetValueExA(hkey
, "Small Fonts", 0, REG_SZ
, (const BYTE
*)fl
->small
, strlen(fl
->small
)+1);
2342 static void set_value_key(HKEY hkey
, const char *name
, const char *value
)
2345 RegSetValueExA(hkey
, name
, 0, REG_SZ
, (const BYTE
*)value
, strlen(value
) + 1);
2347 RegDeleteValueA(hkey
, name
);
2350 static void update_font_info(void)
2352 char buf
[40], cpbuf
[40];
2355 UINT i
, ansi_cp
= 0, oem_cp
= 0;
2358 if (RegCreateKeyExA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts", 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
) != ERROR_SUCCESS
)
2361 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_IDEFAULTANSICODEPAGE
|LOCALE_RETURN_NUMBER
|LOCALE_NOUSEROVERRIDE
,
2362 (WCHAR
*)&ansi_cp
, sizeof(ansi_cp
)/sizeof(WCHAR
));
2363 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_IDEFAULTCODEPAGE
|LOCALE_RETURN_NUMBER
|LOCALE_NOUSEROVERRIDE
,
2364 (WCHAR
*)&oem_cp
, sizeof(oem_cp
)/sizeof(WCHAR
));
2365 sprintf( cpbuf
, "%u,%u", ansi_cp
, oem_cp
);
2367 /* Setup Default_Fallback usage for DBCS ANSI codepages */
2368 if (is_dbcs_ansi_cp(ansi_cp
))
2369 use_default_fallback
= TRUE
;
2372 if (RegQueryValueExA(hkey
, "Codepages", 0, &type
, (BYTE
*)buf
, &len
) == ERROR_SUCCESS
&& type
== REG_SZ
)
2374 if (!strcmp( buf
, cpbuf
)) /* already set correctly */
2379 TRACE("updating registry, codepages changed %s -> %u,%u\n", buf
, ansi_cp
, oem_cp
);
2381 else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp
, oem_cp
);
2383 RegSetValueExA(hkey
, "Codepages", 0, REG_SZ
, (const BYTE
*)cpbuf
, strlen(cpbuf
)+1);
2386 for (i
= 0; i
< sizeof(nls_update_font_list
)/sizeof(nls_update_font_list
[0]); i
++)
2390 if (nls_update_font_list
[i
].ansi_cp
== ansi_cp
&&
2391 nls_update_font_list
[i
].oem_cp
== oem_cp
)
2393 hkey
= create_config_fonts_registry_key();
2394 RegSetValueExA(hkey
, "OEMFONT.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].oem
, strlen(nls_update_font_list
[i
].oem
)+1);
2395 RegSetValueExA(hkey
, "FIXEDFON.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].fixed
, strlen(nls_update_font_list
[i
].fixed
)+1);
2396 RegSetValueExA(hkey
, "FONTS.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].system
, strlen(nls_update_font_list
[i
].system
)+1);
2399 hkey
= create_fonts_NT_registry_key();
2400 add_font_list(hkey
, &nls_update_font_list
[i
]);
2403 hkey
= create_fonts_9x_registry_key();
2404 add_font_list(hkey
, &nls_update_font_list
[i
]);
2407 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey
))
2409 RegSetValueExA(hkey
, "MS Shell Dlg", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].shelldlg
,
2410 strlen(nls_update_font_list
[i
].shelldlg
)+1);
2411 RegSetValueExA(hkey
, "Tms Rmn", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].tmsrmn
,
2412 strlen(nls_update_font_list
[i
].tmsrmn
)+1);
2414 set_value_key(hkey
, "Fixedsys,0", nls_update_font_list
[i
].fixed_0
);
2415 set_value_key(hkey
, "System,0", nls_update_font_list
[i
].system_0
);
2416 set_value_key(hkey
, "Courier,0", nls_update_font_list
[i
].courier_0
);
2417 set_value_key(hkey
, "MS Serif,0", nls_update_font_list
[i
].serif_0
);
2418 set_value_key(hkey
, "Small Fonts,0", nls_update_font_list
[i
].small_0
);
2419 set_value_key(hkey
, "MS Sans Serif,0", nls_update_font_list
[i
].sserif_0
);
2420 set_value_key(hkey
, "Helv,0", nls_update_font_list
[i
].helv_0
);
2421 set_value_key(hkey
, "Tms Rmn,0", nls_update_font_list
[i
].tmsrmn_0
);
2423 set_value_key(hkey
, nls_update_font_list
[i
].arial_0
.from
, nls_update_font_list
[i
].arial_0
.to
);
2424 set_value_key(hkey
, nls_update_font_list
[i
].courier_new_0
.from
, nls_update_font_list
[i
].courier_new_0
.to
);
2425 set_value_key(hkey
, nls_update_font_list
[i
].times_new_roman_0
.from
, nls_update_font_list
[i
].times_new_roman_0
.to
);
2433 /* Delete the FontSubstitutes from other locales */
2434 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey
))
2436 set_value_key(hkey
, nls_update_font_list
[i
].arial_0
.from
, NULL
);
2437 set_value_key(hkey
, nls_update_font_list
[i
].courier_new_0
.from
, NULL
);
2438 set_value_key(hkey
, nls_update_font_list
[i
].times_new_roman_0
.from
, NULL
);
2444 FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp
, oem_cp
);
2448 static BOOL
init_freetype(void)
2450 ft_handle
= wine_dlopen(SONAME_LIBFREETYPE
, RTLD_NOW
, NULL
, 0);
2453 "Wine cannot find the FreeType font library. To enable Wine to\n"
2454 "use TrueType fonts please install a version of FreeType greater than\n"
2455 "or equal to 2.0.5.\n"
2456 "http://www.freetype.org\n");
2460 #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;}
2462 LOAD_FUNCPTR(FT_Vector_Unit
)
2463 LOAD_FUNCPTR(FT_Done_Face
)
2464 LOAD_FUNCPTR(FT_Get_Char_Index
)
2465 LOAD_FUNCPTR(FT_Get_Module
)
2466 LOAD_FUNCPTR(FT_Get_Sfnt_Name
)
2467 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count
)
2468 LOAD_FUNCPTR(FT_Get_Sfnt_Table
)
2469 LOAD_FUNCPTR(FT_Init_FreeType
)
2470 LOAD_FUNCPTR(FT_Load_Glyph
)
2471 LOAD_FUNCPTR(FT_Matrix_Multiply
)
2472 #ifndef FT_MULFIX_INLINED
2473 LOAD_FUNCPTR(FT_MulFix
)
2475 LOAD_FUNCPTR(FT_New_Face
)
2476 LOAD_FUNCPTR(FT_New_Memory_Face
)
2477 LOAD_FUNCPTR(FT_Outline_Get_Bitmap
)
2478 LOAD_FUNCPTR(FT_Outline_Transform
)
2479 LOAD_FUNCPTR(FT_Outline_Translate
)
2480 LOAD_FUNCPTR(FT_Select_Charmap
)
2481 LOAD_FUNCPTR(FT_Set_Charmap
)
2482 LOAD_FUNCPTR(FT_Set_Pixel_Sizes
)
2483 LOAD_FUNCPTR(FT_Vector_Transform
)
2486 /* Don't warn if these ones are missing */
2487 pFT_Library_Version
= wine_dlsym(ft_handle
, "FT_Library_Version", NULL
, 0);
2488 pFT_Load_Sfnt_Table
= wine_dlsym(ft_handle
, "FT_Load_Sfnt_Table", NULL
, 0);
2489 pFT_Get_First_Char
= wine_dlsym(ft_handle
, "FT_Get_First_Char", NULL
, 0);
2490 pFT_Get_Next_Char
= wine_dlsym(ft_handle
, "FT_Get_Next_Char", NULL
, 0);
2491 pFT_Get_TrueType_Engine_Type
= wine_dlsym(ft_handle
, "FT_Get_TrueType_Engine_Type", NULL
, 0);
2492 #ifdef HAVE_FREETYPE_FTWINFNT_H
2493 pFT_Get_WinFNT_Header
= wine_dlsym(ft_handle
, "FT_Get_WinFNT_Header", NULL
, 0);
2495 if(!wine_dlsym(ft_handle
, "FT_Get_Postscript_Name", NULL
, 0) &&
2496 !wine_dlsym(ft_handle
, "FT_Sqrt64", NULL
, 0)) {
2497 /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
2498 <= 2.0.3 has FT_Sqrt64 */
2502 if(pFT_Init_FreeType(&library
) != 0) {
2503 ERR("Can't init FreeType library\n");
2504 wine_dlclose(ft_handle
, NULL
, 0);
2508 FT_Version
.major
= FT_Version
.minor
= FT_Version
.patch
= -1;
2509 if (pFT_Library_Version
)
2510 pFT_Library_Version(library
,&FT_Version
.major
,&FT_Version
.minor
,&FT_Version
.patch
);
2512 if (FT_Version
.major
<=0)
2518 TRACE("FreeType version is %d.%d.%d\n",FT_Version
.major
,FT_Version
.minor
,FT_Version
.patch
);
2519 FT_SimpleVersion
= ((FT_Version
.major
<< 16) & 0xff0000) |
2520 ((FT_Version
.minor
<< 8) & 0x00ff00) |
2521 ((FT_Version
.patch
) & 0x0000ff);
2527 "Wine cannot find certain functions that it needs inside the FreeType\n"
2528 "font library. To enable Wine to use TrueType fonts please upgrade\n"
2529 "FreeType to at least version 2.0.5.\n"
2530 "http://www.freetype.org\n");
2531 wine_dlclose(ft_handle
, NULL
, 0);
2536 /*************************************************************
2539 * Initialize FreeType library and create a list of available faces
2541 BOOL
WineEngInit(void)
2543 static const WCHAR dot_fonW
[] = {'.','f','o','n','\0'};
2544 static const WCHAR pathW
[] = {'P','a','t','h',0};
2546 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
2548 WCHAR windowsdir
[MAX_PATH
];
2551 const char *data_dir
;
2555 /* update locale dependent font info in registry */
2558 if(!init_freetype()) return FALSE
;
2560 if((font_mutex
= CreateMutexW(NULL
, FALSE
, font_mutex_nameW
)) == NULL
) {
2561 ERR("Failed to create font mutex\n");
2564 WaitForSingleObject(font_mutex
, INFINITE
);
2566 delete_external_font_keys();
2568 /* load the system bitmap fonts */
2569 load_system_fonts();
2571 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
2572 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
2573 strcatW(windowsdir
, fontsW
);
2574 if((unixname
= wine_get_unix_file_name(windowsdir
)))
2576 ReadFontDir(unixname
, FALSE
);
2577 HeapFree(GetProcessHeap(), 0, unixname
);
2580 /* load the system truetype fonts */
2581 data_dir
= wine_get_data_dir();
2582 if (!data_dir
) data_dir
= wine_get_build_dir();
2583 if (data_dir
&& (unixname
= HeapAlloc(GetProcessHeap(), 0, strlen(data_dir
) + sizeof("/fonts/")))) {
2584 strcpy(unixname
, data_dir
);
2585 strcat(unixname
, "/fonts/");
2586 ReadFontDir(unixname
, TRUE
);
2587 HeapFree(GetProcessHeap(), 0, unixname
);
2590 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
2591 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
2592 full path as the entry. Also look for any .fon fonts, since ReadFontDir
2594 if(RegOpenKeyW(HKEY_LOCAL_MACHINE
,
2595 is_win9x() ? win9x_font_reg_key
: winnt_font_reg_key
,
2596 &hkey
) == ERROR_SUCCESS
) {
2598 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2599 &valuelen
, &datalen
, NULL
, NULL
);
2601 valuelen
++; /* returned value doesn't include room for '\0' */
2602 valueW
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
2603 data
= HeapAlloc(GetProcessHeap(), 0, datalen
* sizeof(WCHAR
));
2606 dlen
= datalen
* sizeof(WCHAR
);
2608 while(RegEnumValueW(hkey
, i
++, valueW
, &vlen
, NULL
, &type
, data
,
2609 &dlen
) == ERROR_SUCCESS
) {
2610 if(((LPWSTR
)data
)[0] && ((LPWSTR
)data
)[1] == ':')
2612 if((unixname
= wine_get_unix_file_name((LPWSTR
)data
)))
2614 AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2615 HeapFree(GetProcessHeap(), 0, unixname
);
2618 else if(dlen
/ 2 >= 6 && !strcmpiW(((LPWSTR
)data
) + dlen
/ 2 - 5, dot_fonW
))
2620 WCHAR pathW
[MAX_PATH
];
2621 static const WCHAR fmtW
[] = {'%','s','\\','%','s','\0'};
2624 sprintfW(pathW
, fmtW
, windowsdir
, data
);
2625 if((unixname
= wine_get_unix_file_name(pathW
)))
2627 added
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2628 HeapFree(GetProcessHeap(), 0, unixname
);
2631 load_font_from_data_dir(data
);
2633 /* reset dlen and vlen */
2638 HeapFree(GetProcessHeap(), 0, data
);
2639 HeapFree(GetProcessHeap(), 0, valueW
);
2643 load_fontconfig_fonts();
2645 /* then look in any directories that we've specified in the config file */
2646 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
2647 if(RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts", &hkey
) == ERROR_SUCCESS
)
2653 if (RegQueryValueExW( hkey
, pathW
, NULL
, NULL
, NULL
, &len
) == ERROR_SUCCESS
)
2655 len
+= sizeof(WCHAR
);
2656 valueW
= HeapAlloc( GetProcessHeap(), 0, len
);
2657 if (RegQueryValueExW( hkey
, pathW
, NULL
, NULL
, (LPBYTE
)valueW
, &len
) == ERROR_SUCCESS
)
2659 len
= WideCharToMultiByte( CP_UNIXCP
, 0, valueW
, -1, NULL
, 0, NULL
, NULL
);
2660 valueA
= HeapAlloc( GetProcessHeap(), 0, len
);
2661 WideCharToMultiByte( CP_UNIXCP
, 0, valueW
, -1, valueA
, len
, NULL
, NULL
);
2662 TRACE( "got font path %s\n", debugstr_a(valueA
) );
2666 LPSTR next
= strchr( ptr
, ':' );
2667 if (next
) *next
++ = 0;
2668 ReadFontDir( ptr
, TRUE
);
2671 HeapFree( GetProcessHeap(), 0, valueA
);
2673 HeapFree( GetProcessHeap(), 0, valueW
);
2682 update_reg_entries();
2684 init_system_links();
2686 ReleaseMutex(font_mutex
);
2691 static LONG
calc_ppem_for_height(FT_Face ft_face
, LONG height
)
2694 TT_HoriHeader
*pHori
;
2698 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
2699 pHori
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
);
2701 if(height
== 0) height
= 16;
2703 /* Calc. height of EM square:
2705 * For +ve lfHeight we have
2706 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
2707 * Re-arranging gives:
2708 * ppem = units_per_em * lfheight / (winAscent + winDescent)
2710 * For -ve lfHeight we have
2712 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
2713 * with il = winAscent + winDescent - units_per_em]
2718 if(pOS2
->usWinAscent
+ pOS2
->usWinDescent
== 0)
2719 ppem
= MulDiv(ft_face
->units_per_EM
, height
,
2720 pHori
->Ascender
- pHori
->Descender
);
2722 ppem
= MulDiv(ft_face
->units_per_EM
, height
,
2723 pOS2
->usWinAscent
+ pOS2
->usWinDescent
);
2731 static struct font_mapping
*map_font_file( const char *name
)
2733 struct font_mapping
*mapping
;
2737 if ((fd
= open( name
, O_RDONLY
)) == -1) return NULL
;
2738 if (fstat( fd
, &st
) == -1) goto error
;
2740 LIST_FOR_EACH_ENTRY( mapping
, &mappings_list
, struct font_mapping
, entry
)
2742 if (mapping
->dev
== st
.st_dev
&& mapping
->ino
== st
.st_ino
)
2744 mapping
->refcount
++;
2749 if (!(mapping
= HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping
) )))
2752 mapping
->data
= mmap( NULL
, st
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0 );
2755 if (mapping
->data
== MAP_FAILED
)
2757 HeapFree( GetProcessHeap(), 0, mapping
);
2760 mapping
->refcount
= 1;
2761 mapping
->dev
= st
.st_dev
;
2762 mapping
->ino
= st
.st_ino
;
2763 mapping
->size
= st
.st_size
;
2764 list_add_tail( &mappings_list
, &mapping
->entry
);
2772 static void unmap_font_file( struct font_mapping
*mapping
)
2774 if (!--mapping
->refcount
)
2776 list_remove( &mapping
->entry
);
2777 munmap( mapping
->data
, mapping
->size
);
2778 HeapFree( GetProcessHeap(), 0, mapping
);
2782 static LONG
load_VDMX(GdiFont
*, LONG
);
2784 static FT_Face
OpenFontFace(GdiFont
*font
, Face
*face
, LONG width
, LONG height
)
2791 TRACE("%s/%p, %ld, %d x %d\n", debugstr_a(face
->file
), face
->font_data_ptr
, face
->face_index
, width
, height
);
2795 if (!(font
->mapping
= map_font_file( face
->file
)))
2797 WARN("failed to map %s\n", debugstr_a(face
->file
));
2800 data_ptr
= font
->mapping
->data
;
2801 data_size
= font
->mapping
->size
;
2805 data_ptr
= face
->font_data_ptr
;
2806 data_size
= face
->font_data_size
;
2809 err
= pFT_New_Memory_Face(library
, data_ptr
, data_size
, face
->face_index
, &ft_face
);
2811 ERR("FT_New_Face rets %d\n", err
);
2815 /* set it here, as load_VDMX needs it */
2816 font
->ft_face
= ft_face
;
2818 if(FT_IS_SCALABLE(ft_face
)) {
2819 /* load the VDMX table if we have one */
2820 font
->ppem
= load_VDMX(font
, height
);
2822 font
->ppem
= calc_ppem_for_height(ft_face
, height
);
2823 TRACE("height %d => ppem %d\n", height
, font
->ppem
);
2825 if((err
= pFT_Set_Pixel_Sizes(ft_face
, 0, font
->ppem
)) != 0)
2826 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font
->ppem
, err
);
2828 font
->ppem
= height
;
2829 if((err
= pFT_Set_Pixel_Sizes(ft_face
, width
, height
)) != 0)
2830 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width
, height
, err
);
2836 static int get_nearest_charset(Face
*face
, int *cp
)
2838 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
2839 a single face with the requested charset. The idea is to check if
2840 the selected font supports the current ANSI codepage, if it does
2841 return the corresponding charset, else return the first charset */
2844 int acp
= GetACP(), i
;
2848 if(TranslateCharsetInfo((DWORD
*)(INT_PTR
)acp
, &csi
, TCI_SRCCODEPAGE
))
2849 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]))
2850 return csi
.ciCharset
;
2852 for(i
= 0; i
< 32; i
++) {
2854 if(face
->fs
.fsCsb
[0] & fs0
) {
2855 if(TranslateCharsetInfo(&fs0
, &csi
, TCI_SRCFONTSIG
)) {
2857 return csi
.ciCharset
;
2860 FIXME("TCI failing on %x\n", fs0
);
2864 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
2865 face
->fs
.fsCsb
[0], face
->file
);
2867 return DEFAULT_CHARSET
;
2870 static GdiFont
*alloc_font(void)
2872 GdiFont
*ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*ret
));
2874 ret
->gm
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(GM
*));
2875 ret
->gm
[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(GM
) * GM_BLOCK_SIZE
);
2877 ret
->font_desc
.matrix
.eM11
= ret
->font_desc
.matrix
.eM22
= 1.0;
2878 ret
->total_kern_pairs
= (DWORD
)-1;
2879 ret
->kern_pairs
= NULL
;
2880 list_init(&ret
->hfontlist
);
2881 list_init(&ret
->child_fonts
);
2885 static void free_font(GdiFont
*font
)
2887 struct list
*cursor
, *cursor2
;
2890 LIST_FOR_EACH_SAFE(cursor
, cursor2
, &font
->child_fonts
)
2892 CHILD_FONT
*child
= LIST_ENTRY(cursor
, CHILD_FONT
, entry
);
2893 struct list
*first_hfont
;
2894 HFONTLIST
*hfontlist
;
2895 list_remove(cursor
);
2898 first_hfont
= list_head(&child
->font
->hfontlist
);
2899 hfontlist
= LIST_ENTRY(first_hfont
, HFONTLIST
, entry
);
2900 DeleteObject(hfontlist
->hfont
);
2901 HeapFree(GetProcessHeap(), 0, hfontlist
);
2902 free_font(child
->font
);
2904 HeapFree(GetProcessHeap(), 0, child
);
2907 if (font
->ft_face
) pFT_Done_Face(font
->ft_face
);
2908 if (font
->mapping
) unmap_font_file( font
->mapping
);
2909 HeapFree(GetProcessHeap(), 0, font
->kern_pairs
);
2910 HeapFree(GetProcessHeap(), 0, font
->potm
);
2911 HeapFree(GetProcessHeap(), 0, font
->name
);
2912 for (i
= 0; i
< font
->gmsize
; i
++)
2913 HeapFree(GetProcessHeap(),0,font
->gm
[i
]);
2914 HeapFree(GetProcessHeap(), 0, font
->gm
);
2915 HeapFree(GetProcessHeap(), 0, font
->GSUB_Table
);
2916 HeapFree(GetProcessHeap(), 0, font
);
2920 /*************************************************************
2923 * load the vdmx entry for the specified height
2926 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
2927 ( ( (FT_ULong)_x4 << 24 ) | \
2928 ( (FT_ULong)_x3 << 16 ) | \
2929 ( (FT_ULong)_x2 << 8 ) | \
2932 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
2947 static LONG
load_VDMX(GdiFont
*font
, LONG height
)
2951 BYTE devXRatio
, devYRatio
;
2952 USHORT numRecs
, numRatios
;
2953 DWORD result
, offset
= -1;
2957 result
= WineEngGetFontData(font
, MS_VDMX_TAG
, 0, hdr
, 6);
2959 if(result
== GDI_ERROR
) /* no vdmx table present, use linear scaling */
2962 /* FIXME: need the real device aspect ratio */
2966 numRecs
= GET_BE_WORD(hdr
[1]);
2967 numRatios
= GET_BE_WORD(hdr
[2]);
2969 TRACE("numRecs = %d numRatios = %d\n", numRecs
, numRatios
);
2970 for(i
= 0; i
< numRatios
; i
++) {
2973 offset
= (3 * 2) + (i
* sizeof(Ratios
));
2974 WineEngGetFontData(font
, MS_VDMX_TAG
, offset
, &ratio
, sizeof(Ratios
));
2977 TRACE("Ratios[%d] %d %d : %d -> %d\n", i
, ratio
.bCharSet
, ratio
.xRatio
, ratio
.yStartRatio
, ratio
.yEndRatio
);
2979 if((ratio
.xRatio
== 0 &&
2980 ratio
.yStartRatio
== 0 &&
2981 ratio
.yEndRatio
== 0) ||
2982 (devXRatio
== ratio
.xRatio
&&
2983 devYRatio
>= ratio
.yStartRatio
&&
2984 devYRatio
<= ratio
.yEndRatio
))
2986 offset
= (3 * 2) + (numRatios
* 4) + (i
* 2);
2987 WineEngGetFontData(font
, MS_VDMX_TAG
, offset
, &tmp
, 2);
2988 offset
= GET_BE_WORD(tmp
);
2994 FIXME("No suitable ratio found\n");
2998 if(WineEngGetFontData(font
, MS_VDMX_TAG
, offset
, &group
, 4) != GDI_ERROR
) {
3000 BYTE startsz
, endsz
;
3003 recs
= GET_BE_WORD(group
.recs
);
3004 startsz
= group
.startsz
;
3005 endsz
= group
.endsz
;
3007 TRACE("recs=%d startsz=%d endsz=%d\n", recs
, startsz
, endsz
);
3009 vTable
= HeapAlloc(GetProcessHeap(), 0, recs
* 6);
3010 result
= WineEngGetFontData(font
, MS_VDMX_TAG
, offset
+ 4, vTable
, recs
* 6);
3011 if(result
== GDI_ERROR
) {
3012 FIXME("Failed to retrieve vTable\n");
3017 for(i
= 0; i
< recs
; i
++) {
3018 SHORT yMax
= GET_BE_WORD(vTable
[(i
* 3) + 1]);
3019 SHORT yMin
= GET_BE_WORD(vTable
[(i
* 3) + 2]);
3020 ppem
= GET_BE_WORD(vTable
[i
* 3]);
3022 if(yMax
+ -yMin
== height
) {
3025 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem
, height
, font
->yMax
, font
->yMin
);
3028 if(yMax
+ -yMin
> height
) {
3031 goto end
; /* failed */
3033 font
->yMax
= GET_BE_WORD(vTable
[(i
* 3) + 1]);
3034 font
->yMin
= GET_BE_WORD(vTable
[(i
* 3) + 2]);
3035 ppem
= GET_BE_WORD(vTable
[i
* 3]);
3036 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem
, height
, font
->yMax
, font
->yMin
);
3042 TRACE("ppem not found for height %d\n", height
);
3046 if(ppem
< startsz
|| ppem
> endsz
)
3049 for(i
= 0; i
< recs
; i
++) {
3051 yPelHeight
= GET_BE_WORD(vTable
[i
* 3]);
3053 if(yPelHeight
> ppem
)
3056 if(yPelHeight
== ppem
) {
3057 font
->yMax
= GET_BE_WORD(vTable
[(i
* 3) + 1]);
3058 font
->yMin
= GET_BE_WORD(vTable
[(i
* 3) + 2]);
3059 TRACE("ppem %d found; yMax=%d yMin=%d\n", ppem
, font
->yMax
, font
->yMin
);
3065 HeapFree(GetProcessHeap(), 0, vTable
);
3071 static BOOL
fontcmp(const GdiFont
*font
, FONT_DESC
*fd
)
3073 if(font
->font_desc
.hash
!= fd
->hash
) return TRUE
;
3074 if(memcmp(&font
->font_desc
.matrix
, &fd
->matrix
, sizeof(fd
->matrix
))) return TRUE
;
3075 if(memcmp(&font
->font_desc
.lf
, &fd
->lf
, offsetof(LOGFONTW
, lfFaceName
))) return TRUE
;
3076 if(!font
->font_desc
.can_use_bitmap
!= !fd
->can_use_bitmap
) return TRUE
;
3077 return strcmpiW(font
->font_desc
.lf
.lfFaceName
, fd
->lf
.lfFaceName
);
3080 static void calc_hash(FONT_DESC
*pfd
)
3082 DWORD hash
= 0, *ptr
, two_chars
;
3086 for(i
= 0, ptr
= (DWORD
*)&pfd
->matrix
; i
< sizeof(FMAT2
)/sizeof(DWORD
); i
++, ptr
++)
3088 for(i
= 0, ptr
= (DWORD
*)&pfd
->lf
; i
< 7; i
++, ptr
++)
3090 for(i
= 0, ptr
= (DWORD
*)pfd
->lf
.lfFaceName
; i
< LF_FACESIZE
/2; i
++, ptr
++) {
3092 pwc
= (WCHAR
*)&two_chars
;
3094 *pwc
= toupperW(*pwc
);
3096 *pwc
= toupperW(*pwc
);
3100 hash
^= !pfd
->can_use_bitmap
;
3105 static GdiFont
*find_in_cache(HFONT hfont
, const LOGFONTW
*plf
, const FMAT2
*pmat
, BOOL can_use_bitmap
)
3110 struct list
*font_elem_ptr
, *hfontlist_elem_ptr
;
3114 fd
.can_use_bitmap
= can_use_bitmap
;
3117 /* try the in-use list */
3118 LIST_FOR_EACH(font_elem_ptr
, &gdi_font_list
) {
3119 ret
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3120 if(!fontcmp(ret
, &fd
)) {
3121 if(!can_use_bitmap
&& !FT_IS_SCALABLE(ret
->ft_face
)) continue;
3122 LIST_FOR_EACH(hfontlist_elem_ptr
, &ret
->hfontlist
) {
3123 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
3124 if(hflist
->hfont
== hfont
)
3127 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3128 hflist
->hfont
= hfont
;
3129 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3134 /* then the unused list */
3135 font_elem_ptr
= list_head(&unused_gdi_font_list
);
3136 while(font_elem_ptr
) {
3137 ret
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3138 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
3139 if(!fontcmp(ret
, &fd
)) {
3140 if(!can_use_bitmap
&& !FT_IS_SCALABLE(ret
->ft_face
)) continue;
3141 assert(list_empty(&ret
->hfontlist
));
3142 TRACE("Found %p in unused list\n", ret
);
3143 list_remove(&ret
->entry
);
3144 list_add_head(&gdi_font_list
, &ret
->entry
);
3145 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3146 hflist
->hfont
= hfont
;
3147 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3154 static void add_to_cache(GdiFont
*font
)
3156 static DWORD cache_num
= 1;
3158 font
->cache_num
= cache_num
++;
3159 list_add_head(&gdi_font_list
, &font
->entry
);
3162 /*************************************************************
3163 * create_child_font_list
3165 static BOOL
create_child_font_list(GdiFont
*font
)
3168 SYSTEM_LINKS
*font_link
;
3169 CHILD_FONT
*font_link_entry
, *new_child
;
3171 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3173 if(!strcmpW(font_link
->font_name
, font
->name
))
3175 TRACE("found entry in system list\n");
3176 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3178 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
3179 new_child
->face
= font_link_entry
->face
;
3180 new_child
->font
= NULL
;
3181 list_add_tail(&font
->child_fonts
, &new_child
->entry
);
3182 TRACE("font %s %ld\n", debugstr_a(new_child
->face
->file
), new_child
->face
->face_index
);
3189 * if not SYMBOL or OEM then we also get all the fonts for Microsoft
3190 * Sans Serif. This is how asian windows get default fallbacks for fonts
3192 if (use_default_fallback
&& font
->charset
!= SYMBOL_CHARSET
&&
3193 font
->charset
!= OEM_CHARSET
&&
3194 strcmpW(font
->name
,szDefaultFallbackLink
) != 0)
3195 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3197 if(!strcmpW(font_link
->font_name
,szDefaultFallbackLink
))
3199 TRACE("found entry in default fallback list\n");
3200 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3202 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
3203 new_child
->face
= font_link_entry
->face
;
3204 new_child
->font
= NULL
;
3205 list_add_tail(&font
->child_fonts
, &new_child
->entry
);
3206 TRACE("font %s %ld\n", debugstr_a(new_child
->face
->file
), new_child
->face
->face_index
);
3216 static BOOL
select_charmap(FT_Face ft_face
, FT_Encoding encoding
)
3218 FT_Error ft_err
= FT_Err_Invalid_CharMap_Handle
;
3220 if (pFT_Set_Charmap
)
3223 FT_CharMap cmap0
, cmap1
, cmap2
, cmap3
, cmap_def
;
3225 cmap0
= cmap1
= cmap2
= cmap3
= cmap_def
= NULL
;
3227 for (i
= 0; i
< ft_face
->num_charmaps
; i
++)
3229 if (ft_face
->charmaps
[i
]->encoding
== encoding
)
3231 TRACE("found cmap with platform_id %u, encoding_id %u\n",
3232 ft_face
->charmaps
[i
]->platform_id
, ft_face
->charmaps
[i
]->encoding_id
);
3234 switch (ft_face
->charmaps
[i
]->platform_id
)
3237 cmap_def
= ft_face
->charmaps
[i
];
3239 case 0: /* Apple Unicode */
3240 cmap0
= ft_face
->charmaps
[i
];
3242 case 1: /* Macintosh */
3243 cmap1
= ft_face
->charmaps
[i
];
3246 cmap2
= ft_face
->charmaps
[i
];
3248 case 3: /* Microsoft */
3249 cmap3
= ft_face
->charmaps
[i
];
3254 if (cmap3
) /* prefer Microsoft cmap table */
3255 ft_err
= pFT_Set_Charmap(ft_face
, cmap3
);
3257 ft_err
= pFT_Set_Charmap(ft_face
, cmap1
);
3259 ft_err
= pFT_Set_Charmap(ft_face
, cmap2
);
3261 ft_err
= pFT_Set_Charmap(ft_face
, cmap0
);
3263 ft_err
= pFT_Set_Charmap(ft_face
, cmap_def
);
3265 return ft_err
== FT_Err_Ok
;
3268 return pFT_Select_Charmap(ft_face
, encoding
) == FT_Err_Ok
;
3271 /*************************************************************
3272 * WineEngCreateFontInstance
3275 GdiFont
*WineEngCreateFontInstance(DC
*dc
, HFONT hfont
)
3278 Face
*face
, *best
, *best_bitmap
;
3279 Family
*family
, *last_resort_family
;
3280 struct list
*family_elem_ptr
, *face_elem_ptr
;
3281 INT height
, width
= 0;
3282 unsigned int score
= 0, new_score
;
3283 signed int diff
= 0, newdiff
;
3284 BOOL bd
, it
, can_use_bitmap
;
3289 FontSubst
*psub
= NULL
;
3291 if (!GetObjectW( hfont
, sizeof(lf
), &lf
)) return NULL
;
3292 lf
.lfWidth
= abs(lf
.lfWidth
);
3294 can_use_bitmap
= GetDeviceCaps(dc
->hSelf
, TEXTCAPS
) & TC_RA_ABLE
;
3296 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
3297 debugstr_w(lf
.lfFaceName
), lf
.lfHeight
, lf
.lfItalic
,
3298 lf
.lfWeight
, lf
.lfPitchAndFamily
, lf
.lfCharSet
, lf
.lfOrientation
,
3301 if(dc
->GraphicsMode
== GM_ADVANCED
)
3302 memcpy(&dcmat
, &dc
->xformWorld2Vport
, sizeof(FMAT2
));
3305 /* Windows 3.1 compatibility mode GM_COMPATIBLE has only limited
3306 font scaling abilities. */
3307 dcmat
.eM11
= dcmat
.eM22
= fabs(dc
->xformWorld2Vport
.eM22
);
3308 dcmat
.eM21
= dcmat
.eM12
= 0;
3311 TRACE("DC transform %f %f %f %f\n", dcmat
.eM11
, dcmat
.eM12
,
3312 dcmat
.eM21
, dcmat
.eM22
);
3314 EnterCriticalSection( &freetype_cs
);
3316 /* check the cache first */
3317 if((ret
= find_in_cache(hfont
, &lf
, &dcmat
, can_use_bitmap
)) != NULL
) {
3318 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret
, hfont
);
3319 LeaveCriticalSection( &freetype_cs
);
3323 TRACE("not in cache\n");
3324 if(list_empty(&font_list
)) /* No fonts installed */
3326 TRACE("No fonts installed\n");
3327 LeaveCriticalSection( &freetype_cs
);
3330 if(!have_installed_roman_font
)
3332 TRACE("No roman font installed\n");
3333 LeaveCriticalSection( &freetype_cs
);
3339 ret
->font_desc
.matrix
= dcmat
;
3340 ret
->font_desc
.lf
= lf
;
3341 ret
->font_desc
.can_use_bitmap
= can_use_bitmap
;
3342 calc_hash(&ret
->font_desc
);
3343 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3344 hflist
->hfont
= hfont
;
3345 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3347 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
3348 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
3349 original value lfCharSet. Note this is a special case for
3350 Symbol and doesn't happen at least for "Wingdings*" */
3352 if(!strcmpiW(lf
.lfFaceName
, SymbolW
))
3353 lf
.lfCharSet
= SYMBOL_CHARSET
;
3355 if(!TranslateCharsetInfo((DWORD
*)(INT_PTR
)lf
.lfCharSet
, &csi
, TCI_SRCCHARSET
)) {
3356 switch(lf
.lfCharSet
) {
3357 case DEFAULT_CHARSET
:
3358 csi
.fs
.fsCsb
[0] = 0;
3361 FIXME("Untranslated charset %d\n", lf
.lfCharSet
);
3362 csi
.fs
.fsCsb
[0] = 0;
3368 if(lf
.lfFaceName
[0] != '\0') {
3369 SYSTEM_LINKS
*font_link
;
3370 CHILD_FONT
*font_link_entry
;
3371 LPWSTR FaceName
= lf
.lfFaceName
;
3374 * Check for a leading '@' this signals that the font is being
3375 * requested in tategaki mode (vertical writing substitution) but
3376 * does not affect the fontface that is to be selected.
3378 if (lf
.lfFaceName
[0]=='@')
3379 FaceName
= &lf
.lfFaceName
[1];
3381 psub
= get_font_subst(&font_subst_list
, FaceName
, lf
.lfCharSet
);
3384 TRACE("substituting %s,%d -> %s,%d\n", debugstr_w(FaceName
), lf
.lfCharSet
,
3385 debugstr_w(psub
->to
.name
), (psub
->to
.charset
!= -1) ? psub
->to
.charset
: lf
.lfCharSet
);
3386 if (psub
->to
.charset
!= -1)
3387 lf
.lfCharSet
= psub
->to
.charset
;
3390 /* We want a match on name and charset or just name if
3391 charset was DEFAULT_CHARSET. If the latter then
3392 we fixup the returned charset later in get_nearest_charset
3393 where we'll either use the charset of the current ansi codepage
3394 or if that's unavailable the first charset that the font supports.
3396 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3397 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3398 if (!strcmpiW(family
->FamilyName
, FaceName
) ||
3399 (psub
&& !strcmpiW(family
->FamilyName
, psub
->to
.name
)))
3401 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3402 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3403 if((csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) || !csi
.fs
.fsCsb
[0])
3404 if(face
->scalable
|| can_use_bitmap
)
3411 * Try check the SystemLink list first for a replacement font.
3412 * We may find good replacements there.
3414 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3416 if(!strcmpiW(font_link
->font_name
, FaceName
))
3418 TRACE("found entry in system list\n");
3419 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3421 face
= font_link_entry
->face
;
3422 family
= face
->family
;
3423 if(csi
.fs
.fsCsb
[0] &
3424 (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]) || !csi
.fs
.fsCsb
[0])
3426 if(face
->scalable
|| can_use_bitmap
)
3434 psub
= NULL
; /* substitution is no more relevant */
3436 /* If requested charset was DEFAULT_CHARSET then try using charset
3437 corresponding to the current ansi codepage */
3438 if (!csi
.fs
.fsCsb
[0])
3441 if(!TranslateCharsetInfo((DWORD
*)(INT_PTR
)acp
, &csi
, TCI_SRCCODEPAGE
)) {
3442 FIXME("TCI failed on codepage %d\n", acp
);
3443 csi
.fs
.fsCsb
[0] = 0;
3445 lf
.lfCharSet
= csi
.ciCharset
;
3448 /* Face families are in the top 4 bits of lfPitchAndFamily,
3449 so mask with 0xF0 before testing */
3451 if((lf
.lfPitchAndFamily
& FIXED_PITCH
) ||
3452 (lf
.lfPitchAndFamily
& 0xF0) == FF_MODERN
)
3453 strcpyW(lf
.lfFaceName
, defFixed
);
3454 else if((lf
.lfPitchAndFamily
& 0xF0) == FF_ROMAN
)
3455 strcpyW(lf
.lfFaceName
, defSerif
);
3456 else if((lf
.lfPitchAndFamily
& 0xF0) == FF_SWISS
)
3457 strcpyW(lf
.lfFaceName
, defSans
);
3459 strcpyW(lf
.lfFaceName
, defSans
);
3460 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3461 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3462 if(!strcmpiW(family
->FamilyName
, lf
.lfFaceName
)) {
3463 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3464 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3465 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]))
3466 if(face
->scalable
|| can_use_bitmap
)
3472 last_resort_family
= NULL
;
3473 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3474 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3475 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3476 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3477 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) {
3480 if(can_use_bitmap
&& !last_resort_family
)
3481 last_resort_family
= family
;
3486 if(last_resort_family
) {
3487 family
= last_resort_family
;
3488 csi
.fs
.fsCsb
[0] = 0;
3492 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3493 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3494 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3495 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3496 if(face
->scalable
) {
3497 csi
.fs
.fsCsb
[0] = 0;
3498 WARN("just using first face for now\n");
3501 if(can_use_bitmap
&& !last_resort_family
)
3502 last_resort_family
= family
;
3505 if(!last_resort_family
) {
3506 FIXME("can't find a single appropriate font - bailing\n");
3508 LeaveCriticalSection( &freetype_cs
);
3512 WARN("could only find a bitmap font - this will probably look awful!\n");
3513 family
= last_resort_family
;
3514 csi
.fs
.fsCsb
[0] = 0;
3517 it
= lf
.lfItalic
? 1 : 0;
3518 bd
= lf
.lfWeight
> 550 ? 1 : 0;
3520 height
= lf
.lfHeight
;
3522 face
= best
= best_bitmap
= NULL
;
3523 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
3525 if((csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) || !csi
.fs
.fsCsb
[0])
3529 italic
= (face
->ntmFlags
& NTM_ITALIC
) ? 1 : 0;
3530 bold
= (face
->ntmFlags
& NTM_BOLD
) ? 1 : 0;
3531 new_score
= (italic
^ it
) + (bold
^ bd
);
3532 if(!best
|| new_score
<= score
)
3534 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
3535 italic
, bold
, it
, bd
);
3538 if(best
->scalable
&& score
== 0) break;
3542 newdiff
= height
- (signed int)(best
->size
.height
);
3544 newdiff
= -height
- ((signed int)(best
->size
.height
) - best
->size
.internal_leading
);
3545 if(!best_bitmap
|| new_score
< score
||
3546 (diff
> 0 && newdiff
< diff
&& newdiff
>= 0) || (diff
< 0 && newdiff
> diff
))
3548 TRACE("%d is better for %d diff was %d\n", best
->size
.height
, height
, diff
);
3551 if(score
== 0 && diff
== 0) break;
3558 face
= best
->scalable
? best
: best_bitmap
;
3559 ret
->fake_italic
= (it
&& !(face
->ntmFlags
& NTM_ITALIC
));
3560 ret
->fake_bold
= (bd
&& !(face
->ntmFlags
& NTM_BOLD
));
3564 if(csi
.fs
.fsCsb
[0]) {
3565 ret
->charset
= lf
.lfCharSet
;
3566 ret
->codepage
= csi
.ciACP
;
3569 ret
->charset
= get_nearest_charset(face
, &ret
->codepage
);
3571 TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family
->FamilyName
),
3572 debugstr_w(face
->StyleName
), face
->file
, face
->font_data_ptr
, face
->face_index
);
3574 ret
->aveWidth
= height
? lf
.lfWidth
: 0;
3576 if(!face
->scalable
) {
3577 /* Windows uses integer scaling factors for bitmap fonts */
3578 INT scale
, scaled_height
;
3580 /* FIXME: rotation of bitmap fonts is ignored */
3581 height
= abs(GDI_ROUND( (double)height
* ret
->font_desc
.matrix
.eM22
));
3583 ret
->aveWidth
= (double)ret
->aveWidth
* ret
->font_desc
.matrix
.eM11
;
3584 ret
->font_desc
.matrix
.eM11
= ret
->font_desc
.matrix
.eM22
= 1.0;
3586 if (height
!= 0) height
= diff
;
3587 height
+= face
->size
.height
;
3589 scale
= (height
+ face
->size
.height
- 1) / face
->size
.height
;
3590 scaled_height
= scale
* face
->size
.height
;
3591 /* XP allows not more than 10% deviation */
3592 if (scale
> 1 && scaled_height
- height
> scaled_height
/ 10) scale
--;
3593 ret
->scale_y
= scale
;
3595 width
= face
->size
.x_ppem
>> 6;
3596 height
= face
->size
.y_ppem
>> 6;
3600 TRACE("font scale y: %f\n", ret
->scale_y
);
3602 ret
->ft_face
= OpenFontFace(ret
, face
, width
, height
);
3607 LeaveCriticalSection( &freetype_cs
);
3611 ret
->ntmFlags
= face
->ntmFlags
;
3613 if (ret
->charset
== SYMBOL_CHARSET
&&
3614 select_charmap(ret
->ft_face
, FT_ENCODING_MS_SYMBOL
)) {
3617 else if (select_charmap(ret
->ft_face
, FT_ENCODING_UNICODE
)) {
3621 select_charmap(ret
->ft_face
, FT_ENCODING_APPLE_ROMAN
);
3624 ret
->orientation
= FT_IS_SCALABLE(ret
->ft_face
) ? lf
.lfOrientation
: 0;
3625 ret
->name
= psub
? strdupW(psub
->from
.name
) : strdupW(family
->FamilyName
);
3626 ret
->underline
= lf
.lfUnderline
? 0xff : 0;
3627 ret
->strikeout
= lf
.lfStrikeOut
? 0xff : 0;
3628 create_child_font_list(ret
);
3630 if (lf
.lfFaceName
[0]=='@') /* We need to try to load the GSUB table */
3632 int length
= WineEngGetFontData (ret
, GSUB_TAG
, 0, NULL
, 0);
3633 if (length
!= GDI_ERROR
)
3635 ret
->GSUB_Table
= HeapAlloc(GetProcessHeap(),0,length
);
3636 WineEngGetFontData(ret
, GSUB_TAG
, 0, ret
->GSUB_Table
, length
);
3637 TRACE("Loaded GSUB table of %i bytes\n",length
);
3641 TRACE("caching: gdiFont=%p hfont=%p\n", ret
, hfont
);
3644 LeaveCriticalSection( &freetype_cs
);
3648 static void dump_gdi_font_list(void)
3651 struct list
*elem_ptr
;
3653 TRACE("---------- gdiFont Cache ----------\n");
3654 LIST_FOR_EACH(elem_ptr
, &gdi_font_list
) {
3655 gdiFont
= LIST_ENTRY(elem_ptr
, struct tagGdiFont
, entry
);
3656 TRACE("gdiFont=%p %s %d\n",
3657 gdiFont
, debugstr_w(gdiFont
->font_desc
.lf
.lfFaceName
), gdiFont
->font_desc
.lf
.lfHeight
);
3660 TRACE("---------- Unused gdiFont Cache ----------\n");
3661 LIST_FOR_EACH(elem_ptr
, &unused_gdi_font_list
) {
3662 gdiFont
= LIST_ENTRY(elem_ptr
, struct tagGdiFont
, entry
);
3663 TRACE("gdiFont=%p %s %d\n",
3664 gdiFont
, debugstr_w(gdiFont
->font_desc
.lf
.lfFaceName
), gdiFont
->font_desc
.lf
.lfHeight
);
3668 /*************************************************************
3669 * WineEngDestroyFontInstance
3671 * free the gdiFont associated with this handle
3674 BOOL
WineEngDestroyFontInstance(HFONT handle
)
3679 struct list
*font_elem_ptr
, *hfontlist_elem_ptr
;
3682 EnterCriticalSection( &freetype_cs
);
3684 LIST_FOR_EACH_ENTRY(gdiFont
, &child_font_list
, struct tagGdiFont
, entry
)
3686 struct list
*first_hfont
= list_head(&gdiFont
->hfontlist
);
3687 hflist
= LIST_ENTRY(first_hfont
, HFONTLIST
, entry
);
3688 if(hflist
->hfont
== handle
)
3690 TRACE("removing child font %p from child list\n", gdiFont
);
3691 list_remove(&gdiFont
->entry
);
3692 LeaveCriticalSection( &freetype_cs
);
3697 TRACE("destroying hfont=%p\n", handle
);
3699 dump_gdi_font_list();
3701 font_elem_ptr
= list_head(&gdi_font_list
);
3702 while(font_elem_ptr
) {
3703 gdiFont
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3704 font_elem_ptr
= list_next(&gdi_font_list
, font_elem_ptr
);
3706 hfontlist_elem_ptr
= list_head(&gdiFont
->hfontlist
);
3707 while(hfontlist_elem_ptr
) {
3708 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
3709 hfontlist_elem_ptr
= list_next(&gdiFont
->hfontlist
, hfontlist_elem_ptr
);
3710 if(hflist
->hfont
== handle
) {
3711 list_remove(&hflist
->entry
);
3712 HeapFree(GetProcessHeap(), 0, hflist
);
3716 if(list_empty(&gdiFont
->hfontlist
)) {
3717 TRACE("Moving to Unused list\n");
3718 list_remove(&gdiFont
->entry
);
3719 list_add_head(&unused_gdi_font_list
, &gdiFont
->entry
);
3724 font_elem_ptr
= list_head(&unused_gdi_font_list
);
3725 while(font_elem_ptr
&& i
++ < UNUSED_CACHE_SIZE
)
3726 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
3727 while(font_elem_ptr
) {
3728 gdiFont
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3729 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
3730 TRACE("freeing %p\n", gdiFont
);
3731 list_remove(&gdiFont
->entry
);
3734 LeaveCriticalSection( &freetype_cs
);
3738 static void GetEnumStructs(Face
*face
, LPENUMLOGFONTEXW pelf
,
3739 NEWTEXTMETRICEXW
*pntm
, LPDWORD ptype
)
3744 if (face
->cached_enum_data
)
3747 *pelf
= face
->cached_enum_data
->elf
;
3748 *pntm
= face
->cached_enum_data
->ntm
;
3749 *ptype
= face
->cached_enum_data
->type
;
3753 font
= alloc_font();
3755 if(face
->scalable
) {
3756 height
= -2048; /* 2048 is the most common em size */
3759 height
= face
->size
.y_ppem
>> 6;
3760 width
= face
->size
.x_ppem
>> 6;
3762 font
->scale_y
= 1.0;
3764 if (!(font
->ft_face
= OpenFontFace(font
, face
, width
, height
)))
3770 font
->name
= strdupW(face
->family
->FamilyName
);
3771 font
->ntmFlags
= face
->ntmFlags
;
3773 if (WineEngGetOutlineTextMetrics(font
, 0, NULL
))
3775 memcpy(&pntm
->ntmTm
, &font
->potm
->otmTextMetrics
, sizeof(TEXTMETRICW
));
3777 pntm
->ntmTm
.ntmSizeEM
= font
->potm
->otmEMSquare
;
3779 lstrcpynW(pelf
->elfLogFont
.lfFaceName
,
3780 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpFamilyName
),
3782 lstrcpynW(pelf
->elfFullName
,
3783 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpFaceName
),
3785 lstrcpynW(pelf
->elfStyle
,
3786 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpStyleName
),
3791 WineEngGetTextMetrics(font
, (TEXTMETRICW
*)&pntm
->ntmTm
);
3793 pntm
->ntmTm
.ntmSizeEM
= pntm
->ntmTm
.tmHeight
- pntm
->ntmTm
.tmInternalLeading
;
3795 lstrcpynW(pelf
->elfLogFont
.lfFaceName
, face
->family
->FamilyName
, LF_FACESIZE
);
3796 lstrcpynW(pelf
->elfFullName
, face
->family
->FamilyName
, LF_FULLFACESIZE
);
3797 lstrcpynW(pelf
->elfStyle
, face
->StyleName
, LF_FACESIZE
);
3800 pntm
->ntmTm
.ntmFlags
= face
->ntmFlags
;
3801 pntm
->ntmTm
.ntmCellHeight
= pntm
->ntmTm
.tmHeight
;
3802 pntm
->ntmTm
.ntmAvgWidth
= pntm
->ntmTm
.tmAveCharWidth
;
3803 pntm
->ntmFontSig
= face
->fs
;
3805 pelf
->elfScript
[0] = '\0'; /* This will get set in WineEngEnumFonts */
3807 pelf
->elfLogFont
.lfEscapement
= 0;
3808 pelf
->elfLogFont
.lfOrientation
= 0;
3809 pelf
->elfLogFont
.lfHeight
= pntm
->ntmTm
.tmHeight
;
3810 pelf
->elfLogFont
.lfWidth
= pntm
->ntmTm
.tmAveCharWidth
;
3811 pelf
->elfLogFont
.lfWeight
= pntm
->ntmTm
.tmWeight
;
3812 pelf
->elfLogFont
.lfItalic
= pntm
->ntmTm
.tmItalic
;
3813 pelf
->elfLogFont
.lfUnderline
= pntm
->ntmTm
.tmUnderlined
;
3814 pelf
->elfLogFont
.lfStrikeOut
= pntm
->ntmTm
.tmStruckOut
;
3815 pelf
->elfLogFont
.lfCharSet
= pntm
->ntmTm
.tmCharSet
;
3816 pelf
->elfLogFont
.lfOutPrecision
= OUT_STROKE_PRECIS
;
3817 pelf
->elfLogFont
.lfClipPrecision
= CLIP_STROKE_PRECIS
;
3818 pelf
->elfLogFont
.lfQuality
= DRAFT_QUALITY
;
3819 pelf
->elfLogFont
.lfPitchAndFamily
= (pntm
->ntmTm
.tmPitchAndFamily
& 0xf1) + 1;
3822 if (pntm
->ntmTm
.tmPitchAndFamily
& TMPF_TRUETYPE
)
3823 *ptype
|= TRUETYPE_FONTTYPE
;
3824 if (pntm
->ntmTm
.tmPitchAndFamily
& TMPF_DEVICE
)
3825 *ptype
|= DEVICE_FONTTYPE
;
3826 if(!(pntm
->ntmTm
.tmPitchAndFamily
& TMPF_VECTOR
))
3827 *ptype
|= RASTER_FONTTYPE
;
3829 face
->cached_enum_data
= HeapAlloc(GetProcessHeap(), 0, sizeof(*face
->cached_enum_data
));
3830 if (face
->cached_enum_data
)
3832 face
->cached_enum_data
->elf
= *pelf
;
3833 face
->cached_enum_data
->ntm
= *pntm
;
3834 face
->cached_enum_data
->type
= *ptype
;
3840 /*************************************************************
3844 DWORD
WineEngEnumFonts(LPLOGFONTW plf
, FONTENUMPROCW proc
, LPARAM lparam
)
3848 struct list
*family_elem_ptr
, *face_elem_ptr
;
3850 NEWTEXTMETRICEXW ntm
;
3859 lf
.lfCharSet
= DEFAULT_CHARSET
;
3860 lf
.lfPitchAndFamily
= 0;
3861 lf
.lfFaceName
[0] = 0;
3865 TRACE("facename = %s charset %d\n", debugstr_w(plf
->lfFaceName
), plf
->lfCharSet
);
3867 EnterCriticalSection( &freetype_cs
);
3868 if(plf
->lfFaceName
[0]) {
3870 psub
= get_font_subst(&font_subst_list
, plf
->lfFaceName
, plf
->lfCharSet
);
3873 TRACE("substituting %s -> %s\n", debugstr_w(plf
->lfFaceName
),
3874 debugstr_w(psub
->to
.name
));
3876 strcpyW(lf
.lfFaceName
, psub
->to
.name
);
3880 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3881 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3882 if(!strcmpiW(plf
->lfFaceName
, family
->FamilyName
)) {
3883 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3884 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3885 GetEnumStructs(face
, &elf
, &ntm
, &type
);
3886 for(i
= 0; i
< 32; i
++) {
3887 if(!face
->scalable
&& face
->fs
.fsCsb
[0] == 0) { /* OEM bitmap */
3888 elf
.elfLogFont
.lfCharSet
= ntm
.ntmTm
.tmCharSet
= OEM_CHARSET
;
3889 strcpyW(elf
.elfScript
, OEM_DOSW
);
3890 i
= 32; /* break out of loop */
3891 } else if(!(face
->fs
.fsCsb
[0] & (1L << i
)))
3894 fs
.fsCsb
[0] = 1L << i
;
3896 if(!TranslateCharsetInfo(fs
.fsCsb
, &csi
,
3898 csi
.ciCharset
= DEFAULT_CHARSET
;
3899 if(i
== 31) csi
.ciCharset
= SYMBOL_CHARSET
;
3900 if(csi
.ciCharset
!= DEFAULT_CHARSET
) {
3901 elf
.elfLogFont
.lfCharSet
=
3902 ntm
.ntmTm
.tmCharSet
= csi
.ciCharset
;
3904 strcpyW(elf
.elfScript
, ElfScriptsW
[i
]);
3906 FIXME("Unknown elfscript for bit %d\n", i
);
3909 TRACE("enuming face %s full %s style %s charset %d type %d script %s it %d weight %d ntmflags %08x\n",
3910 debugstr_w(elf
.elfLogFont
.lfFaceName
),
3911 debugstr_w(elf
.elfFullName
), debugstr_w(elf
.elfStyle
),
3912 csi
.ciCharset
, type
, debugstr_w(elf
.elfScript
),
3913 elf
.elfLogFont
.lfItalic
, elf
.elfLogFont
.lfWeight
,
3914 ntm
.ntmTm
.ntmFlags
);
3915 /* release section before callback (FIXME) */
3916 LeaveCriticalSection( &freetype_cs
);
3917 if (!proc(&elf
.elfLogFont
, (TEXTMETRICW
*)&ntm
, type
, lparam
)) return 0;
3918 EnterCriticalSection( &freetype_cs
);
3924 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3925 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3926 face_elem_ptr
= list_head(&family
->faces
);
3927 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3928 GetEnumStructs(face
, &elf
, &ntm
, &type
);
3929 for(i
= 0; i
< 32; i
++) {
3930 if(!face
->scalable
&& face
->fs
.fsCsb
[0] == 0) { /* OEM bitmap */
3931 elf
.elfLogFont
.lfCharSet
= ntm
.ntmTm
.tmCharSet
= OEM_CHARSET
;
3932 strcpyW(elf
.elfScript
, OEM_DOSW
);
3933 i
= 32; /* break out of loop */
3934 } else if(!(face
->fs
.fsCsb
[0] & (1L << i
)))
3937 fs
.fsCsb
[0] = 1L << i
;
3939 if(!TranslateCharsetInfo(fs
.fsCsb
, &csi
,
3941 csi
.ciCharset
= DEFAULT_CHARSET
;
3942 if(i
== 31) csi
.ciCharset
= SYMBOL_CHARSET
;
3943 if(csi
.ciCharset
!= DEFAULT_CHARSET
) {
3944 elf
.elfLogFont
.lfCharSet
= ntm
.ntmTm
.tmCharSet
=
3947 strcpyW(elf
.elfScript
, ElfScriptsW
[i
]);
3949 FIXME("Unknown elfscript for bit %d\n", i
);
3952 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
3953 debugstr_w(elf
.elfLogFont
.lfFaceName
),
3954 debugstr_w(elf
.elfFullName
), debugstr_w(elf
.elfStyle
),
3955 csi
.ciCharset
, type
, debugstr_w(elf
.elfScript
),
3956 elf
.elfLogFont
.lfItalic
, elf
.elfLogFont
.lfWeight
,
3957 ntm
.ntmTm
.ntmFlags
);
3958 /* release section before callback (FIXME) */
3959 LeaveCriticalSection( &freetype_cs
);
3960 if (!proc(&elf
.elfLogFont
, (TEXTMETRICW
*)&ntm
, type
, lparam
)) return 0;
3961 EnterCriticalSection( &freetype_cs
);
3965 LeaveCriticalSection( &freetype_cs
);
3969 static void FTVectorToPOINTFX(FT_Vector
*vec
, POINTFX
*pt
)
3971 pt
->x
.value
= vec
->x
>> 6;
3972 pt
->x
.fract
= (vec
->x
& 0x3f) << 10;
3973 pt
->x
.fract
|= ((pt
->x
.fract
>> 6) | (pt
->x
.fract
>> 12));
3974 pt
->y
.value
= vec
->y
>> 6;
3975 pt
->y
.fract
= (vec
->y
& 0x3f) << 10;
3976 pt
->y
.fract
|= ((pt
->y
.fract
>> 6) | (pt
->y
.fract
>> 12));
3980 /***************************************************
3981 * According to the MSDN documentation on WideCharToMultiByte,
3982 * certain codepages cannot set the default_used parameter.
3983 * This returns TRUE if the codepage can set that parameter, false else
3984 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
3986 static BOOL
codepage_sets_default_used(UINT codepage
)
4000 * GSUB Table handling functions
4003 static INT
GSUB_is_glyph_covered(LPCVOID table
, UINT glyph
)
4005 const GSUB_CoverageFormat1
* cf1
;
4007 cf1
= (GSUB_CoverageFormat1
*)table
;
4009 if (GET_BE_WORD(cf1
->CoverageFormat
) == 1)
4011 int count
= GET_BE_WORD(cf1
->GlyphCount
);
4013 TRACE("Coverage Format 1, %i glyphs\n",count
);
4014 for (i
= 0; i
< count
; i
++)
4015 if (glyph
== GET_BE_WORD(cf1
->GlyphArray
[i
]))
4019 else if (GET_BE_WORD(cf1
->CoverageFormat
) == 2)
4021 const GSUB_CoverageFormat2
* cf2
;
4024 cf2
= (GSUB_CoverageFormat2
*)cf1
;
4026 count
= GET_BE_WORD(cf2
->RangeCount
);
4027 TRACE("Coverage Format 2, %i ranges\n",count
);
4028 for (i
= 0; i
< count
; i
++)
4030 if (glyph
< GET_BE_WORD(cf2
->RangeRecord
[i
].Start
))
4032 if ((glyph
>= GET_BE_WORD(cf2
->RangeRecord
[i
].Start
)) &&
4033 (glyph
<= GET_BE_WORD(cf2
->RangeRecord
[i
].End
)))
4035 return (GET_BE_WORD(cf2
->RangeRecord
[i
].StartCoverageIndex
) +
4036 glyph
- GET_BE_WORD(cf2
->RangeRecord
[i
].Start
));
4042 ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1
->CoverageFormat
));
4047 static const GSUB_Script
* GSUB_get_script_table( const GSUB_Header
* header
, const char* tag
)
4049 const GSUB_ScriptList
*script
;
4050 const GSUB_Script
*deflt
= NULL
;
4052 script
= (GSUB_ScriptList
*)((LPBYTE
)header
+ GET_BE_WORD(header
->ScriptList
));
4054 TRACE("%i scripts in this font\n",GET_BE_WORD(script
->ScriptCount
));
4055 for (i
= 0; i
< GET_BE_WORD(script
->ScriptCount
); i
++)
4057 const GSUB_Script
*scr
;
4060 offset
= GET_BE_WORD(script
->ScriptRecord
[i
].Script
);
4061 scr
= (GSUB_Script
*)((LPBYTE
)script
+ offset
);
4063 if (strncmp(script
->ScriptRecord
[i
].ScriptTag
, tag
,4)==0)
4065 if (strncmp(script
->ScriptRecord
[i
].ScriptTag
, "dflt",4)==0)
4071 static const GSUB_LangSys
* GSUB_get_lang_table( const GSUB_Script
* script
, const char* tag
)
4075 const GSUB_LangSys
*Lang
;
4077 TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script
->DefaultLangSys
), GET_BE_WORD(script
->LangSysCount
));
4079 for (i
= 0; i
< GET_BE_WORD(script
->LangSysCount
) ; i
++)
4081 offset
= GET_BE_WORD(script
->LangSysRecord
[i
].LangSys
);
4082 Lang
= (GSUB_LangSys
*)((LPBYTE
)script
+ offset
);
4084 if ( strncmp(script
->LangSysRecord
[i
].LangSysTag
,tag
,4)==0)
4087 offset
= GET_BE_WORD(script
->DefaultLangSys
);
4090 Lang
= (GSUB_LangSys
*)((LPBYTE
)script
+ offset
);
4096 static const GSUB_Feature
* GSUB_get_feature(const GSUB_Header
*header
, const GSUB_LangSys
*lang
, const char* tag
)
4099 const GSUB_FeatureList
*feature
;
4100 feature
= (GSUB_FeatureList
*)((LPBYTE
)header
+ GET_BE_WORD(header
->FeatureList
));
4102 TRACE("%i features\n",GET_BE_WORD(lang
->FeatureCount
));
4103 for (i
= 0; i
< GET_BE_WORD(lang
->FeatureCount
); i
++)
4105 int index
= GET_BE_WORD(lang
->FeatureIndex
[i
]);
4106 if (strncmp(feature
->FeatureRecord
[index
].FeatureTag
,tag
,4)==0)
4108 const GSUB_Feature
*feat
;
4109 feat
= (GSUB_Feature
*)((LPBYTE
)feature
+ GET_BE_WORD(feature
->FeatureRecord
[index
].Feature
));
4116 static FT_UInt
GSUB_apply_feature(const GSUB_Header
* header
, const GSUB_Feature
* feature
, UINT glyph
)
4120 const GSUB_LookupList
*lookup
;
4121 lookup
= (GSUB_LookupList
*)((LPBYTE
)header
+ GET_BE_WORD(header
->LookupList
));
4123 TRACE("%i lookups\n", GET_BE_WORD(feature
->LookupCount
));
4124 for (i
= 0; i
< GET_BE_WORD(feature
->LookupCount
); i
++)
4126 const GSUB_LookupTable
*look
;
4127 offset
= GET_BE_WORD(lookup
->Lookup
[GET_BE_WORD(feature
->LookupListIndex
[i
])]);
4128 look
= (GSUB_LookupTable
*)((LPBYTE
)lookup
+ offset
);
4129 TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look
->LookupType
),GET_BE_WORD(look
->LookupFlag
),GET_BE_WORD(look
->SubTableCount
));
4130 if (GET_BE_WORD(look
->LookupType
) != 1)
4131 FIXME("We only handle SubType 1\n");
4136 for (j
= 0; j
< GET_BE_WORD(look
->SubTableCount
); j
++)
4138 const GSUB_SingleSubstFormat1
*ssf1
;
4139 offset
= GET_BE_WORD(look
->SubTable
[j
]);
4140 ssf1
= (GSUB_SingleSubstFormat1
*)((LPBYTE
)look
+offset
);
4141 if (GET_BE_WORD(ssf1
->SubstFormat
) == 1)
4143 int offset
= GET_BE_WORD(ssf1
->Coverage
);
4144 TRACE(" subtype 1, delta %i\n", GET_BE_WORD(ssf1
->DeltaGlyphID
));
4145 if (GSUB_is_glyph_covered((LPBYTE
)ssf1
+offset
, glyph
) != -1)
4147 TRACE(" Glyph 0x%x ->",glyph
);
4148 glyph
+= GET_BE_WORD(ssf1
->DeltaGlyphID
);
4149 TRACE(" 0x%x\n",glyph
);
4154 const GSUB_SingleSubstFormat2
*ssf2
;
4158 ssf2
= (GSUB_SingleSubstFormat2
*)ssf1
;
4159 offset
= GET_BE_WORD(ssf1
->Coverage
);
4160 TRACE(" subtype 2, glyph count %i\n", GET_BE_WORD(ssf2
->GlyphCount
));
4161 index
= GSUB_is_glyph_covered((LPBYTE
)ssf2
+offset
, glyph
);
4162 TRACE(" Coverage index %i\n",index
);
4165 TRACE(" Glyph is 0x%x ->",glyph
);
4166 glyph
= GET_BE_WORD(ssf2
->Substitute
[index
]);
4167 TRACE("0x%x\n",glyph
);
4176 static const char* get_opentype_script(const GdiFont
*font
)
4179 * I am not sure if this is the correct way to generate our script tag
4182 switch (font
->charset
)
4184 case ANSI_CHARSET
: return "latn";
4185 case BALTIC_CHARSET
: return "latn"; /* ?? */
4186 case CHINESEBIG5_CHARSET
: return "hani";
4187 case EASTEUROPE_CHARSET
: return "latn"; /* ?? */
4188 case GB2312_CHARSET
: return "hani";
4189 case GREEK_CHARSET
: return "grek";
4190 case HANGUL_CHARSET
: return "hang";
4191 case RUSSIAN_CHARSET
: return "cyrl";
4192 case SHIFTJIS_CHARSET
: return "kana";
4193 case TURKISH_CHARSET
: return "latn"; /* ?? */
4194 case VIETNAMESE_CHARSET
: return "latn";
4195 case JOHAB_CHARSET
: return "latn"; /* ?? */
4196 case ARABIC_CHARSET
: return "arab";
4197 case HEBREW_CHARSET
: return "hebr";
4198 case THAI_CHARSET
: return "thai";
4199 default: return "latn";
4203 static FT_UInt
get_GSUB_vert_glyph(const GdiFont
*font
, UINT glyph
)
4205 const GSUB_Header
*header
;
4206 const GSUB_Script
*script
;
4207 const GSUB_LangSys
*language
;
4208 const GSUB_Feature
*feature
;
4210 if (!font
->GSUB_Table
)
4213 header
= font
->GSUB_Table
;
4215 script
= GSUB_get_script_table(header
, get_opentype_script(font
));
4218 TRACE("Script not found\n");
4221 language
= GSUB_get_lang_table(script
, "xxxx"); /* Need to get Lang tag */
4224 TRACE("Language not found\n");
4227 feature
= GSUB_get_feature(header
, language
, "vrt2");
4229 feature
= GSUB_get_feature(header
, language
, "vert");
4232 TRACE("vrt2/vert feature not found\n");
4235 return GSUB_apply_feature(header
, feature
, glyph
);
4238 static FT_UInt
get_glyph_index(const GdiFont
*font
, UINT glyph
)
4242 if(font
->ft_face
->charmap
->encoding
== FT_ENCODING_NONE
) {
4243 WCHAR wc
= (WCHAR
)glyph
;
4245 BOOL
*default_used_pointer
;
4248 default_used_pointer
= NULL
;
4249 default_used
= FALSE
;
4250 if (codepage_sets_default_used(font
->codepage
))
4251 default_used_pointer
= &default_used
;
4252 if(!WideCharToMultiByte(font
->codepage
, 0, &wc
, 1, &buf
, sizeof(buf
), NULL
, default_used_pointer
) || default_used
)
4255 ret
= pFT_Get_Char_Index(font
->ft_face
, (unsigned char)buf
);
4256 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph
, buf
, ret
, default_used
);
4257 return get_GSUB_vert_glyph(font
,ret
);
4260 if(font
->ft_face
->charmap
->encoding
== FT_ENCODING_MS_SYMBOL
&& glyph
< 0x100)
4261 glyph
= glyph
+ 0xf000;
4262 glyphId
= pFT_Get_Char_Index(font
->ft_face
, glyph
);
4263 return get_GSUB_vert_glyph(font
,glyphId
);
4266 /*************************************************************
4267 * WineEngGetGlyphIndices
4270 DWORD
WineEngGetGlyphIndices(GdiFont
*font
, LPCWSTR lpstr
, INT count
,
4271 LPWORD pgi
, DWORD flags
)
4274 int default_char
= -1;
4276 if (flags
& GGI_MARK_NONEXISTING_GLYPHS
) default_char
= 0xffff; /* XP would use 0x1f for bitmap fonts */
4278 for(i
= 0; i
< count
; i
++)
4280 pgi
[i
] = get_glyph_index(font
, lpstr
[i
]);
4283 if (default_char
== -1)
4285 if (FT_IS_SFNT(font
->ft_face
))
4287 TT_OS2
*pOS2
= pFT_Get_Sfnt_Table(font
->ft_face
, ft_sfnt_os2
);
4288 default_char
= (pOS2
->usDefaultChar
? get_glyph_index(font
, pOS2
->usDefaultChar
) : 0);
4293 WineEngGetTextMetrics(font
, &textm
);
4294 default_char
= textm
.tmDefaultChar
;
4297 pgi
[i
] = default_char
;
4303 static inline BOOL
is_identity_FMAT2(const FMAT2
*matrix
)
4305 static const FMAT2 identity
= { 1.0, 0.0, 0.0, 1.0 };
4306 return !memcmp(matrix
, &identity
, sizeof(FMAT2
));
4309 static inline BOOL
is_identity_MAT2(const MAT2
*matrix
)
4311 static const MAT2 identity
= { {0,1}, {0,0}, {0,0}, {0,1} };
4312 return !memcmp(matrix
, &identity
, sizeof(MAT2
));
4315 /*************************************************************
4316 * WineEngGetGlyphOutline
4318 * Behaves in exactly the same way as the win32 api GetGlyphOutline
4319 * except that the first parameter is the HWINEENGFONT of the font in
4320 * question rather than an HDC.
4323 DWORD
WineEngGetGlyphOutline(GdiFont
*incoming_font
, UINT glyph
, UINT format
,
4324 LPGLYPHMETRICS lpgm
, DWORD buflen
, LPVOID buf
,
4327 static const FT_Matrix identityMat
= {(1 << 16), 0, 0, (1 << 16)};
4328 FT_Face ft_face
= incoming_font
->ft_face
;
4329 GdiFont
*font
= incoming_font
;
4330 FT_UInt glyph_index
;
4331 DWORD width
, height
, pitch
, needed
= 0;
4332 FT_Bitmap ft_bitmap
;
4334 INT left
, right
, top
= 0, bottom
= 0, adv
, lsb
, bbx
;
4336 FT_Int load_flags
= FT_LOAD_DEFAULT
| FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH
;
4337 double widthRatio
= 1.0;
4338 FT_Matrix transMat
= identityMat
;
4339 FT_Matrix transMatUnrotated
;
4340 BOOL needsTransform
= FALSE
;
4341 BOOL tategaki
= (font
->GSUB_Table
!= NULL
);
4342 UINT original_index
;
4344 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font
, glyph
, format
, lpgm
,
4345 buflen
, buf
, lpmat
);
4347 TRACE("font transform %f %f %f %f\n",
4348 font
->font_desc
.matrix
.eM11
, font
->font_desc
.matrix
.eM12
,
4349 font
->font_desc
.matrix
.eM21
, font
->font_desc
.matrix
.eM22
);
4351 EnterCriticalSection( &freetype_cs
);
4353 if(format
& GGO_GLYPH_INDEX
) {
4354 glyph_index
= get_GSUB_vert_glyph(incoming_font
,glyph
);
4355 original_index
= glyph
;
4356 format
&= ~GGO_GLYPH_INDEX
;
4358 get_glyph_index_linked(incoming_font
, glyph
, &font
, &glyph_index
);
4359 ft_face
= font
->ft_face
;
4360 original_index
= glyph_index
;
4363 /* tategaki never appears to happen to lower glyph index */
4364 if (glyph_index
< TATEGAKI_LOWER_BOUND
)
4367 if(original_index
>= font
->gmsize
* GM_BLOCK_SIZE
) {
4368 font
->gmsize
= (original_index
/ GM_BLOCK_SIZE
+ 1);
4369 font
->gm
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, font
->gm
,
4370 font
->gmsize
* sizeof(GM
*));
4372 if (format
== GGO_METRICS
&& font
->gm
[original_index
/ GM_BLOCK_SIZE
] != NULL
&&
4373 FONT_GM(font
,original_index
)->init
&& (!lpmat
|| is_identity_MAT2(lpmat
)))
4375 *lpgm
= FONT_GM(font
,original_index
)->gm
;
4376 TRACE("cached: %u,%u,%s,%d,%d\n", lpgm
->gmBlackBoxX
, lpgm
->gmBlackBoxY
,
4377 wine_dbgstr_point(&lpgm
->gmptGlyphOrigin
),
4378 lpgm
->gmCellIncX
, lpgm
->gmCellIncY
);
4379 LeaveCriticalSection( &freetype_cs
);
4380 return 1; /* FIXME */
4384 if (!font
->gm
[original_index
/ GM_BLOCK_SIZE
])
4385 font
->gm
[original_index
/ GM_BLOCK_SIZE
] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
, sizeof(GM
) * GM_BLOCK_SIZE
);
4387 /* Scaling factor */
4392 WineEngGetTextMetrics(font
, &tm
);
4394 widthRatio
= (double)font
->aveWidth
;
4395 widthRatio
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
4398 widthRatio
= font
->scale_y
;
4400 /* Scaling transform */
4401 if (widthRatio
!= 1.0 || font
->scale_y
!= 1.0)
4404 scaleMat
.xx
= FT_FixedFromFloat(widthRatio
);
4407 scaleMat
.yy
= FT_FixedFromFloat(font
->scale_y
);
4409 pFT_Matrix_Multiply(&scaleMat
, &transMat
);
4410 needsTransform
= TRUE
;
4413 /* Slant transform */
4414 if (font
->fake_italic
) {
4417 slantMat
.xx
= (1 << 16);
4418 slantMat
.xy
= ((1 << 16) >> 2);
4420 slantMat
.yy
= (1 << 16);
4421 pFT_Matrix_Multiply(&slantMat
, &transMat
);
4422 needsTransform
= TRUE
;
4425 /* Rotation transform */
4426 transMatUnrotated
= transMat
;
4427 if(font
->orientation
&& !tategaki
) {
4428 FT_Matrix rotationMat
;
4430 angle
= FT_FixedFromFloat((double)font
->orientation
/ 10.0);
4431 pFT_Vector_Unit(&vecAngle
, angle
);
4432 rotationMat
.xx
= vecAngle
.x
;
4433 rotationMat
.xy
= -vecAngle
.y
;
4434 rotationMat
.yx
= -rotationMat
.xy
;
4435 rotationMat
.yy
= rotationMat
.xx
;
4437 pFT_Matrix_Multiply(&rotationMat
, &transMat
);
4438 needsTransform
= TRUE
;
4441 /* World transform */
4442 if (!is_identity_FMAT2(&font
->font_desc
.matrix
))
4445 worldMat
.xx
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM11
);
4446 worldMat
.xy
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM21
);
4447 worldMat
.yx
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM12
);
4448 worldMat
.yy
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM22
);
4449 pFT_Matrix_Multiply(&worldMat
, &transMat
);
4450 pFT_Matrix_Multiply(&worldMat
, &transMatUnrotated
);
4451 needsTransform
= TRUE
;
4454 /* Extra transformation specified by caller */
4455 if (lpmat
&& !is_identity_MAT2(lpmat
))
4458 extraMat
.xx
= FT_FixedFromFIXED(lpmat
->eM11
);
4459 extraMat
.xy
= FT_FixedFromFIXED(lpmat
->eM21
);
4460 extraMat
.yx
= FT_FixedFromFIXED(lpmat
->eM12
);
4461 extraMat
.yy
= FT_FixedFromFIXED(lpmat
->eM22
);
4462 pFT_Matrix_Multiply(&extraMat
, &transMat
);
4463 pFT_Matrix_Multiply(&extraMat
, &transMatUnrotated
);
4464 needsTransform
= TRUE
;
4467 if (needsTransform
|| (format
!= GGO_METRICS
&& format
!= GGO_BITMAP
&& format
!= WINE_GGO_GRAY16_BITMAP
))
4468 load_flags
|= FT_LOAD_NO_BITMAP
;
4470 err
= pFT_Load_Glyph(ft_face
, glyph_index
, load_flags
);
4473 WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index
, err
);
4474 LeaveCriticalSection( &freetype_cs
);
4478 left
= (INT
)(ft_face
->glyph
->metrics
.horiBearingX
) & -64;
4479 right
= (INT
)((ft_face
->glyph
->metrics
.horiBearingX
+ ft_face
->glyph
->metrics
.width
) + 63) & -64;
4481 adv
= (INT
)((ft_face
->glyph
->metrics
.horiAdvance
) + 63) >> 6;
4483 bbx
= (right
- left
) >> 6;
4485 if(!needsTransform
) {
4486 top
= (ft_face
->glyph
->metrics
.horiBearingY
+ 63) & -64;
4487 bottom
= (ft_face
->glyph
->metrics
.horiBearingY
-
4488 ft_face
->glyph
->metrics
.height
) & -64;
4489 lpgm
->gmCellIncX
= adv
;
4490 lpgm
->gmCellIncY
= 0;
4494 for(xc
= 0; xc
< 2; xc
++) {
4495 for(yc
= 0; yc
< 2; yc
++) {
4496 vec
.x
= (ft_face
->glyph
->metrics
.horiBearingX
+
4497 xc
* ft_face
->glyph
->metrics
.width
);
4498 vec
.y
= ft_face
->glyph
->metrics
.horiBearingY
-
4499 yc
* ft_face
->glyph
->metrics
.height
;
4500 TRACE("Vec %ld,%ld\n", vec
.x
, vec
.y
);
4501 pFT_Vector_Transform(&vec
, &transMat
);
4502 if(xc
== 0 && yc
== 0) {
4503 left
= right
= vec
.x
;
4504 top
= bottom
= vec
.y
;
4506 if(vec
.x
< left
) left
= vec
.x
;
4507 else if(vec
.x
> right
) right
= vec
.x
;
4508 if(vec
.y
< bottom
) bottom
= vec
.y
;
4509 else if(vec
.y
> top
) top
= vec
.y
;
4514 right
= (right
+ 63) & -64;
4515 bottom
= bottom
& -64;
4516 top
= (top
+ 63) & -64;
4518 TRACE("transformed box: (%d,%d - %d,%d)\n", left
, top
, right
, bottom
);
4519 vec
.x
= ft_face
->glyph
->metrics
.horiAdvance
;
4521 pFT_Vector_Transform(&vec
, &transMat
);
4522 lpgm
->gmCellIncX
= (vec
.x
+63) >> 6;
4523 lpgm
->gmCellIncY
= -((vec
.y
+63) >> 6);
4525 vec
.x
= ft_face
->glyph
->metrics
.horiAdvance
;
4527 pFT_Vector_Transform(&vec
, &transMatUnrotated
);
4528 adv
= (vec
.x
+63) >> 6;
4530 lpgm
->gmBlackBoxX
= (right
- left
) >> 6;
4531 lpgm
->gmBlackBoxY
= (top
- bottom
) >> 6;
4532 lpgm
->gmptGlyphOrigin
.x
= left
>> 6;
4533 lpgm
->gmptGlyphOrigin
.y
= top
>> 6;
4535 TRACE("%u,%u,%s,%d,%d\n", lpgm
->gmBlackBoxX
, lpgm
->gmBlackBoxY
,
4536 wine_dbgstr_point(&lpgm
->gmptGlyphOrigin
),
4537 lpgm
->gmCellIncX
, lpgm
->gmCellIncY
);
4539 if ((format
== GGO_METRICS
|| format
== GGO_BITMAP
|| format
== WINE_GGO_GRAY16_BITMAP
) &&
4540 (!lpmat
|| is_identity_MAT2(lpmat
))) /* don't cache custom transforms */
4542 FONT_GM(font
,original_index
)->gm
= *lpgm
;
4543 FONT_GM(font
,original_index
)->adv
= adv
;
4544 FONT_GM(font
,original_index
)->lsb
= lsb
;
4545 FONT_GM(font
,original_index
)->bbx
= bbx
;
4546 FONT_GM(font
,original_index
)->init
= TRUE
;
4549 if(format
== GGO_METRICS
)
4551 LeaveCriticalSection( &freetype_cs
);
4552 return 1; /* FIXME */
4555 if(ft_face
->glyph
->format
!= ft_glyph_format_outline
&& format
!= GGO_BITMAP
&& format
!= WINE_GGO_GRAY16_BITMAP
) {
4556 TRACE("loaded a bitmap\n");
4557 LeaveCriticalSection( &freetype_cs
);
4563 width
= lpgm
->gmBlackBoxX
;
4564 height
= lpgm
->gmBlackBoxY
;
4565 pitch
= ((width
+ 31) >> 5) << 2;
4566 needed
= pitch
* height
;
4568 if(!buf
|| !buflen
) break;
4570 switch(ft_face
->glyph
->format
) {
4571 case ft_glyph_format_bitmap
:
4573 BYTE
*src
= ft_face
->glyph
->bitmap
.buffer
, *dst
= buf
;
4574 INT w
= (ft_face
->glyph
->bitmap
.width
+ 7) >> 3;
4575 INT h
= ft_face
->glyph
->bitmap
.rows
;
4577 memcpy(dst
, src
, w
);
4578 src
+= ft_face
->glyph
->bitmap
.pitch
;
4584 case ft_glyph_format_outline
:
4585 ft_bitmap
.width
= width
;
4586 ft_bitmap
.rows
= height
;
4587 ft_bitmap
.pitch
= pitch
;
4588 ft_bitmap
.pixel_mode
= ft_pixel_mode_mono
;
4589 ft_bitmap
.buffer
= buf
;
4591 if(needsTransform
) {
4592 pFT_Outline_Transform(&ft_face
->glyph
->outline
, &transMat
);
4595 pFT_Outline_Translate(&ft_face
->glyph
->outline
, -left
, -bottom
);
4597 /* Note: FreeType will only set 'black' bits for us. */
4598 memset(buf
, 0, needed
);
4599 pFT_Outline_Get_Bitmap(library
, &ft_face
->glyph
->outline
, &ft_bitmap
);
4603 FIXME("loaded glyph format %x\n", ft_face
->glyph
->format
);
4604 LeaveCriticalSection( &freetype_cs
);
4609 case GGO_GRAY2_BITMAP
:
4610 case GGO_GRAY4_BITMAP
:
4611 case GGO_GRAY8_BITMAP
:
4612 case WINE_GGO_GRAY16_BITMAP
:
4614 unsigned int mult
, row
, col
;
4617 width
= lpgm
->gmBlackBoxX
;
4618 height
= lpgm
->gmBlackBoxY
;
4619 pitch
= (width
+ 3) / 4 * 4;
4620 needed
= pitch
* height
;
4622 if(!buf
|| !buflen
) break;
4624 switch(ft_face
->glyph
->format
) {
4625 case ft_glyph_format_bitmap
:
4627 BYTE
*src
= ft_face
->glyph
->bitmap
.buffer
, *dst
= buf
;
4628 INT h
= ft_face
->glyph
->bitmap
.rows
;
4631 for(x
= 0; x
< pitch
; x
++)
4633 if(x
< ft_face
->glyph
->bitmap
.width
)
4634 dst
[x
] = (src
[x
/ 8] & (1 << ( (7 - (x
% 8))))) ? 0xff : 0;
4638 src
+= ft_face
->glyph
->bitmap
.pitch
;
4641 LeaveCriticalSection( &freetype_cs
);
4644 case ft_glyph_format_outline
:
4646 ft_bitmap
.width
= width
;
4647 ft_bitmap
.rows
= height
;
4648 ft_bitmap
.pitch
= pitch
;
4649 ft_bitmap
.pixel_mode
= ft_pixel_mode_grays
;
4650 ft_bitmap
.buffer
= buf
;
4653 pFT_Outline_Transform(&ft_face
->glyph
->outline
, &transMat
);
4655 pFT_Outline_Translate(&ft_face
->glyph
->outline
, -left
, -bottom
);
4657 memset(ft_bitmap
.buffer
, 0, buflen
);
4659 pFT_Outline_Get_Bitmap(library
, &ft_face
->glyph
->outline
, &ft_bitmap
);
4661 if(format
== GGO_GRAY2_BITMAP
)
4663 else if(format
== GGO_GRAY4_BITMAP
)
4665 else if(format
== GGO_GRAY8_BITMAP
)
4667 else /* format == WINE_GGO_GRAY16_BITMAP */
4669 LeaveCriticalSection( &freetype_cs
);
4675 FIXME("loaded glyph format %x\n", ft_face
->glyph
->format
);
4676 LeaveCriticalSection( &freetype_cs
);
4681 for(row
= 0; row
< height
; row
++) {
4683 for(col
= 0; col
< width
; col
++, ptr
++) {
4684 *ptr
= (((int)*ptr
) * mult
+ 128) / 256;
4693 int contour
, point
= 0, first_pt
;
4694 FT_Outline
*outline
= &ft_face
->glyph
->outline
;
4695 TTPOLYGONHEADER
*pph
;
4697 DWORD pph_start
, cpfx
, type
;
4699 if(buflen
== 0) buf
= NULL
;
4701 if (needsTransform
&& buf
) {
4702 pFT_Outline_Transform(outline
, &transMat
);
4705 for(contour
= 0; contour
< outline
->n_contours
; contour
++) {
4707 pph
= (TTPOLYGONHEADER
*)((char *)buf
+ needed
);
4710 pph
->dwType
= TT_POLYGON_TYPE
;
4711 FTVectorToPOINTFX(&outline
->points
[point
], &pph
->pfxStart
);
4713 needed
+= sizeof(*pph
);
4715 while(point
<= outline
->contours
[contour
]) {
4716 ppc
= (TTPOLYCURVE
*)((char *)buf
+ needed
);
4717 type
= (outline
->tags
[point
] & FT_Curve_Tag_On
) ?
4718 TT_PRIM_LINE
: TT_PRIM_QSPLINE
;
4722 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
4725 } while(point
<= outline
->contours
[contour
] &&
4726 (outline
->tags
[point
] & FT_Curve_Tag_On
) ==
4727 (outline
->tags
[point
-1] & FT_Curve_Tag_On
));
4728 /* At the end of a contour Windows adds the start point, but
4730 if(point
> outline
->contours
[contour
] &&
4731 !(outline
->tags
[point
-1] & FT_Curve_Tag_On
)) {
4733 FTVectorToPOINTFX(&outline
->points
[first_pt
], &ppc
->apfx
[cpfx
]);
4735 } else if(point
<= outline
->contours
[contour
] &&
4736 outline
->tags
[point
] & FT_Curve_Tag_On
) {
4737 /* add closing pt for bezier */
4739 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
4747 needed
+= sizeof(*ppc
) + (cpfx
- 1) * sizeof(POINTFX
);
4750 pph
->cb
= needed
- pph_start
;
4756 /* Convert the quadratic Beziers to cubic Beziers.
4757 The parametric eqn for a cubic Bezier is, from PLRM:
4758 r(t) = at^3 + bt^2 + ct + r0
4759 with the control points:
4764 A quadratic Beizer has the form:
4765 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
4767 So equating powers of t leads to:
4768 r1 = 2/3 p1 + 1/3 p0
4769 r2 = 2/3 p1 + 1/3 p2
4770 and of course r0 = p0, r3 = p2
4773 int contour
, point
= 0, first_pt
;
4774 FT_Outline
*outline
= &ft_face
->glyph
->outline
;
4775 TTPOLYGONHEADER
*pph
;
4777 DWORD pph_start
, cpfx
, type
;
4778 FT_Vector cubic_control
[4];
4779 if(buflen
== 0) buf
= NULL
;
4781 if (needsTransform
&& buf
) {
4782 pFT_Outline_Transform(outline
, &transMat
);
4785 for(contour
= 0; contour
< outline
->n_contours
; contour
++) {
4787 pph
= (TTPOLYGONHEADER
*)((char *)buf
+ needed
);
4790 pph
->dwType
= TT_POLYGON_TYPE
;
4791 FTVectorToPOINTFX(&outline
->points
[point
], &pph
->pfxStart
);
4793 needed
+= sizeof(*pph
);
4795 while(point
<= outline
->contours
[contour
]) {
4796 ppc
= (TTPOLYCURVE
*)((char *)buf
+ needed
);
4797 type
= (outline
->tags
[point
] & FT_Curve_Tag_On
) ?
4798 TT_PRIM_LINE
: TT_PRIM_CSPLINE
;
4801 if(type
== TT_PRIM_LINE
) {
4803 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
4807 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
4810 /* FIXME: Possible optimization in endpoint calculation
4811 if there are two consecutive curves */
4812 cubic_control
[0] = outline
->points
[point
-1];
4813 if(!(outline
->tags
[point
-1] & FT_Curve_Tag_On
)) {
4814 cubic_control
[0].x
+= outline
->points
[point
].x
+ 1;
4815 cubic_control
[0].y
+= outline
->points
[point
].y
+ 1;
4816 cubic_control
[0].x
>>= 1;
4817 cubic_control
[0].y
>>= 1;
4819 if(point
+1 > outline
->contours
[contour
])
4820 cubic_control
[3] = outline
->points
[first_pt
];
4822 cubic_control
[3] = outline
->points
[point
+1];
4823 if(!(outline
->tags
[point
+1] & FT_Curve_Tag_On
)) {
4824 cubic_control
[3].x
+= outline
->points
[point
].x
+ 1;
4825 cubic_control
[3].y
+= outline
->points
[point
].y
+ 1;
4826 cubic_control
[3].x
>>= 1;
4827 cubic_control
[3].y
>>= 1;
4830 /* r1 = 1/3 p0 + 2/3 p1
4831 r2 = 1/3 p2 + 2/3 p1 */
4832 cubic_control
[1].x
= (2 * outline
->points
[point
].x
+ 1) / 3;
4833 cubic_control
[1].y
= (2 * outline
->points
[point
].y
+ 1) / 3;
4834 cubic_control
[2] = cubic_control
[1];
4835 cubic_control
[1].x
+= (cubic_control
[0].x
+ 1) / 3;
4836 cubic_control
[1].y
+= (cubic_control
[0].y
+ 1) / 3;
4837 cubic_control
[2].x
+= (cubic_control
[3].x
+ 1) / 3;
4838 cubic_control
[2].y
+= (cubic_control
[3].y
+ 1) / 3;
4840 FTVectorToPOINTFX(&cubic_control
[1], &ppc
->apfx
[cpfx
]);
4841 FTVectorToPOINTFX(&cubic_control
[2], &ppc
->apfx
[cpfx
+1]);
4842 FTVectorToPOINTFX(&cubic_control
[3], &ppc
->apfx
[cpfx
+2]);
4847 } while(point
<= outline
->contours
[contour
] &&
4848 (outline
->tags
[point
] & FT_Curve_Tag_On
) ==
4849 (outline
->tags
[point
-1] & FT_Curve_Tag_On
));
4850 /* At the end of a contour Windows adds the start point,
4851 but only for Beziers and we've already done that.
4853 if(point
<= outline
->contours
[contour
] &&
4854 outline
->tags
[point
] & FT_Curve_Tag_On
) {
4855 /* This is the closing pt of a bezier, but we've already
4856 added it, so just inc point and carry on */
4863 needed
+= sizeof(*ppc
) + (cpfx
- 1) * sizeof(POINTFX
);
4866 pph
->cb
= needed
- pph_start
;
4872 FIXME("Unsupported format %d\n", format
);
4873 LeaveCriticalSection( &freetype_cs
);
4876 LeaveCriticalSection( &freetype_cs
);
4880 static BOOL
get_bitmap_text_metrics(GdiFont
*font
)
4882 FT_Face ft_face
= font
->ft_face
;
4883 #ifdef HAVE_FREETYPE_FTWINFNT_H
4884 FT_WinFNT_HeaderRec winfnt_header
;
4886 const DWORD size
= offsetof(OUTLINETEXTMETRICW
, otmFiller
);
4887 font
->potm
= HeapAlloc(GetProcessHeap(), 0, size
);
4888 font
->potm
->otmSize
= size
;
4890 #define TM font->potm->otmTextMetrics
4891 #ifdef HAVE_FREETYPE_FTWINFNT_H
4892 if(pFT_Get_WinFNT_Header
&& !pFT_Get_WinFNT_Header(ft_face
, &winfnt_header
))
4894 TM
.tmHeight
= winfnt_header
.pixel_height
;
4895 TM
.tmAscent
= winfnt_header
.ascent
;
4896 TM
.tmDescent
= TM
.tmHeight
- TM
.tmAscent
;
4897 TM
.tmInternalLeading
= winfnt_header
.internal_leading
;
4898 TM
.tmExternalLeading
= winfnt_header
.external_leading
;
4899 TM
.tmAveCharWidth
= winfnt_header
.avg_width
;
4900 TM
.tmMaxCharWidth
= winfnt_header
.max_width
;
4901 TM
.tmWeight
= winfnt_header
.weight
;
4903 TM
.tmDigitizedAspectX
= winfnt_header
.horizontal_resolution
;
4904 TM
.tmDigitizedAspectY
= winfnt_header
.vertical_resolution
;
4905 TM
.tmFirstChar
= winfnt_header
.first_char
;
4906 TM
.tmLastChar
= winfnt_header
.last_char
;
4907 TM
.tmDefaultChar
= winfnt_header
.default_char
+ winfnt_header
.first_char
;
4908 TM
.tmBreakChar
= winfnt_header
.break_char
+ winfnt_header
.first_char
;
4909 TM
.tmItalic
= winfnt_header
.italic
;
4910 TM
.tmUnderlined
= font
->underline
;
4911 TM
.tmStruckOut
= font
->strikeout
;
4912 TM
.tmPitchAndFamily
= winfnt_header
.pitch_and_family
;
4913 TM
.tmCharSet
= winfnt_header
.charset
;
4918 TM
.tmAscent
= ft_face
->size
->metrics
.ascender
>> 6;
4919 TM
.tmDescent
= -ft_face
->size
->metrics
.descender
>> 6;
4920 TM
.tmHeight
= TM
.tmAscent
+ TM
.tmDescent
;
4921 TM
.tmInternalLeading
= TM
.tmHeight
- ft_face
->size
->metrics
.y_ppem
;
4922 TM
.tmExternalLeading
= (ft_face
->size
->metrics
.height
>> 6) - TM
.tmHeight
;
4923 TM
.tmMaxCharWidth
= ft_face
->size
->metrics
.max_advance
>> 6;
4924 TM
.tmAveCharWidth
= TM
.tmMaxCharWidth
* 2 / 3; /* FIXME */
4925 TM
.tmWeight
= ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
? FW_BOLD
: FW_NORMAL
;
4927 TM
.tmDigitizedAspectX
= 96; /* FIXME */
4928 TM
.tmDigitizedAspectY
= 96; /* FIXME */
4930 TM
.tmLastChar
= 255;
4931 TM
.tmDefaultChar
= 32;
4932 TM
.tmBreakChar
= 32;
4933 TM
.tmItalic
= ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
? 1 : 0;
4934 TM
.tmUnderlined
= font
->underline
;
4935 TM
.tmStruckOut
= font
->strikeout
;
4936 /* NB inverted meaning of TMPF_FIXED_PITCH */
4937 TM
.tmPitchAndFamily
= ft_face
->face_flags
& FT_FACE_FLAG_FIXED_WIDTH
? 0 : TMPF_FIXED_PITCH
;
4938 TM
.tmCharSet
= font
->charset
;
4946 static void scale_font_metrics(const GdiFont
*font
, LPTEXTMETRICW ptm
)
4948 double scale_x
, scale_y
;
4952 scale_x
= (double)font
->aveWidth
;
4953 scale_x
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
4956 scale_x
= font
->scale_y
;
4958 scale_x
*= fabs(font
->font_desc
.matrix
.eM11
);
4959 scale_y
= font
->scale_y
* fabs(font
->font_desc
.matrix
.eM22
);
4961 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
4962 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
4964 SCALE_Y(ptm
->tmHeight
);
4965 SCALE_Y(ptm
->tmAscent
);
4966 SCALE_Y(ptm
->tmDescent
);
4967 SCALE_Y(ptm
->tmInternalLeading
);
4968 SCALE_Y(ptm
->tmExternalLeading
);
4969 SCALE_Y(ptm
->tmOverhang
);
4971 SCALE_X(ptm
->tmAveCharWidth
);
4972 SCALE_X(ptm
->tmMaxCharWidth
);
4978 static void scale_outline_font_metrics(const GdiFont
*font
, OUTLINETEXTMETRICW
*potm
)
4980 double scale_x
, scale_y
;
4984 scale_x
= (double)font
->aveWidth
;
4985 scale_x
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
4988 scale_x
= font
->scale_y
;
4990 scale_x
*= fabs(font
->font_desc
.matrix
.eM11
);
4991 scale_y
= font
->scale_y
* fabs(font
->font_desc
.matrix
.eM22
);
4993 scale_font_metrics(font
, &potm
->otmTextMetrics
);
4995 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
4996 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
4998 SCALE_Y(potm
->otmAscent
);
4999 SCALE_Y(potm
->otmDescent
);
5000 SCALE_Y(potm
->otmLineGap
);
5001 SCALE_Y(potm
->otmsCapEmHeight
);
5002 SCALE_Y(potm
->otmsXHeight
);
5003 SCALE_Y(potm
->otmrcFontBox
.top
);
5004 SCALE_Y(potm
->otmrcFontBox
.bottom
);
5005 SCALE_X(potm
->otmrcFontBox
.left
);
5006 SCALE_X(potm
->otmrcFontBox
.right
);
5007 SCALE_Y(potm
->otmMacAscent
);
5008 SCALE_Y(potm
->otmMacDescent
);
5009 SCALE_Y(potm
->otmMacLineGap
);
5010 SCALE_X(potm
->otmptSubscriptSize
.x
);
5011 SCALE_Y(potm
->otmptSubscriptSize
.y
);
5012 SCALE_X(potm
->otmptSubscriptOffset
.x
);
5013 SCALE_Y(potm
->otmptSubscriptOffset
.y
);
5014 SCALE_X(potm
->otmptSuperscriptSize
.x
);
5015 SCALE_Y(potm
->otmptSuperscriptSize
.y
);
5016 SCALE_X(potm
->otmptSuperscriptOffset
.x
);
5017 SCALE_Y(potm
->otmptSuperscriptOffset
.y
);
5018 SCALE_Y(potm
->otmsStrikeoutSize
);
5019 SCALE_Y(potm
->otmsStrikeoutPosition
);
5020 SCALE_Y(potm
->otmsUnderscoreSize
);
5021 SCALE_Y(potm
->otmsUnderscorePosition
);
5027 /*************************************************************
5028 * WineEngGetTextMetrics
5031 BOOL
WineEngGetTextMetrics(GdiFont
*font
, LPTEXTMETRICW ptm
)
5033 EnterCriticalSection( &freetype_cs
);
5035 if(!WineEngGetOutlineTextMetrics(font
, 0, NULL
))
5036 if(!get_bitmap_text_metrics(font
))
5038 LeaveCriticalSection( &freetype_cs
);
5044 LeaveCriticalSection( &freetype_cs
);
5047 *ptm
= font
->potm
->otmTextMetrics
;
5048 scale_font_metrics(font
, ptm
);
5049 LeaveCriticalSection( &freetype_cs
);
5054 /*************************************************************
5055 * WineEngGetOutlineTextMetrics
5058 UINT
WineEngGetOutlineTextMetrics(GdiFont
*font
, UINT cbSize
,
5059 OUTLINETEXTMETRICW
*potm
)
5061 FT_Face ft_face
= font
->ft_face
;
5062 UINT needed
, lenfam
, lensty
, ret
;
5064 TT_HoriHeader
*pHori
;
5065 TT_Postscript
*pPost
;
5066 FT_Fixed x_scale
, y_scale
;
5067 WCHAR
*family_nameW
, *style_nameW
;
5068 static const WCHAR spaceW
[] = {' ', '\0'};
5070 INT ascent
, descent
;
5072 TRACE("font=%p\n", font
);
5074 if(!FT_IS_SCALABLE(ft_face
))
5077 EnterCriticalSection( &freetype_cs
);
5080 if(cbSize
>= font
->potm
->otmSize
)
5082 memcpy(potm
, font
->potm
, font
->potm
->otmSize
);
5083 scale_outline_font_metrics(font
, potm
);
5085 LeaveCriticalSection( &freetype_cs
);
5086 return font
->potm
->otmSize
;
5090 needed
= sizeof(*potm
);
5092 lenfam
= (strlenW(font
->name
) + 1) * sizeof(WCHAR
);
5093 family_nameW
= strdupW(font
->name
);
5095 lensty
= MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, NULL
, 0)
5097 style_nameW
= HeapAlloc(GetProcessHeap(), 0, lensty
);
5098 MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1,
5099 style_nameW
, lensty
/sizeof(WCHAR
));
5101 /* These names should be read from the TT name table */
5103 /* length of otmpFamilyName */
5106 /* length of otmpFaceName */
5107 if ((ft_face
->style_flags
& (FT_STYLE_FLAG_ITALIC
| FT_STYLE_FLAG_BOLD
)) == 0) {
5108 needed
+= lenfam
; /* just the family name */
5110 needed
+= lenfam
+ lensty
; /* family + " " + style */
5113 /* length of otmpStyleName */
5116 /* length of otmpFullName */
5117 needed
+= lenfam
+ lensty
;
5120 x_scale
= ft_face
->size
->metrics
.x_scale
;
5121 y_scale
= ft_face
->size
->metrics
.y_scale
;
5123 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
5125 FIXME("Can't find OS/2 table - not TT font?\n");
5130 pHori
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
);
5132 FIXME("Can't find HHEA table - not TT font?\n");
5137 pPost
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_post
); /* we can live with this failing */
5139 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",
5140 pOS2
->usWinAscent
, pOS2
->usWinDescent
,
5141 pOS2
->sTypoAscender
, pOS2
->sTypoDescender
, pOS2
->sTypoLineGap
,
5142 ft_face
->ascender
, ft_face
->descender
, ft_face
->height
,
5143 pHori
->Ascender
, pHori
->Descender
, pHori
->Line_Gap
,
5144 ft_face
->bbox
.yMax
, ft_face
->bbox
.yMin
);
5146 font
->potm
= HeapAlloc(GetProcessHeap(), 0, needed
);
5147 font
->potm
->otmSize
= needed
;
5149 #define TM font->potm->otmTextMetrics
5151 if(pOS2
->usWinAscent
+ pOS2
->usWinDescent
== 0) {
5152 ascent
= pHori
->Ascender
;
5153 descent
= -pHori
->Descender
;
5155 ascent
= pOS2
->usWinAscent
;
5156 descent
= pOS2
->usWinDescent
;
5160 TM
.tmAscent
= font
->yMax
;
5161 TM
.tmDescent
= -font
->yMin
;
5162 TM
.tmInternalLeading
= (TM
.tmAscent
+ TM
.tmDescent
) - ft_face
->size
->metrics
.y_ppem
;
5164 TM
.tmAscent
= (pFT_MulFix(ascent
, y_scale
) + 32) >> 6;
5165 TM
.tmDescent
= (pFT_MulFix(descent
, y_scale
) + 32) >> 6;
5166 TM
.tmInternalLeading
= (pFT_MulFix(ascent
+ descent
5167 - ft_face
->units_per_EM
, y_scale
) + 32) >> 6;
5170 TM
.tmHeight
= TM
.tmAscent
+ TM
.tmDescent
;
5173 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
5175 TM
.tmExternalLeading
= max(0, (pFT_MulFix(pHori
->Line_Gap
-
5176 ((ascent
+ descent
) -
5177 (pHori
->Ascender
- pHori
->Descender
)), y_scale
) + 32) >> 6);
5179 TM
.tmAveCharWidth
= (pFT_MulFix(pOS2
->xAvgCharWidth
, x_scale
) + 32) >> 6;
5180 if (TM
.tmAveCharWidth
== 0) {
5181 TM
.tmAveCharWidth
= 1;
5183 TM
.tmMaxCharWidth
= (pFT_MulFix(ft_face
->bbox
.xMax
- ft_face
->bbox
.xMin
, x_scale
) + 32) >> 6;
5184 TM
.tmWeight
= (font
->fake_bold
|| (ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
)) ? FW_BOLD
: FW_REGULAR
;
5186 TM
.tmDigitizedAspectX
= 300;
5187 TM
.tmDigitizedAspectY
= 300;
5188 /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
5189 * symbol range to 0 - f0ff
5191 if (font
->charset
== SYMBOL_CHARSET
)
5194 TM
.tmDefaultChar
= pOS2
->usDefaultChar
? pOS2
->usDefaultChar
: 0x1f;
5198 TM
.tmFirstChar
= pOS2
->usFirstCharIndex
;
5199 TM
.tmDefaultChar
= pOS2
->usDefaultChar
? pOS2
->usDefaultChar
: 0xffff;
5201 TM
.tmLastChar
= pOS2
->usLastCharIndex
;
5202 TM
.tmBreakChar
= pOS2
->usBreakChar
? pOS2
->usBreakChar
: ' ';
5203 TM
.tmItalic
= font
->fake_italic
? 255 : ((ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
) ? 255 : 0);
5204 TM
.tmUnderlined
= font
->underline
;
5205 TM
.tmStruckOut
= font
->strikeout
;
5207 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
5208 if(!FT_IS_FIXED_WIDTH(ft_face
) &&
5209 (pOS2
->version
== 0xFFFFU
||
5210 pOS2
->panose
[PAN_PROPORTION_INDEX
] != PAN_PROP_MONOSPACED
))
5211 TM
.tmPitchAndFamily
= TMPF_FIXED_PITCH
;
5213 TM
.tmPitchAndFamily
= 0;
5215 switch(pOS2
->panose
[PAN_FAMILYTYPE_INDEX
]) {
5216 case PAN_FAMILY_SCRIPT
:
5217 TM
.tmPitchAndFamily
|= FF_SCRIPT
;
5219 case PAN_FAMILY_DECORATIVE
:
5220 case PAN_FAMILY_PICTORIAL
:
5221 TM
.tmPitchAndFamily
|= FF_DECORATIVE
;
5223 case PAN_FAMILY_TEXT_DISPLAY
:
5224 if(TM
.tmPitchAndFamily
== 0) /* fixed */
5225 TM
.tmPitchAndFamily
= FF_MODERN
;
5227 switch(pOS2
->panose
[PAN_SERIFSTYLE_INDEX
]) {
5228 case PAN_SERIF_NORMAL_SANS
:
5229 case PAN_SERIF_OBTUSE_SANS
:
5230 case PAN_SERIF_PERP_SANS
:
5231 TM
.tmPitchAndFamily
|= FF_SWISS
;
5234 TM
.tmPitchAndFamily
|= FF_ROMAN
;
5239 TM
.tmPitchAndFamily
|= FF_DONTCARE
;
5242 if(FT_IS_SCALABLE(ft_face
))
5243 TM
.tmPitchAndFamily
|= TMPF_VECTOR
;
5245 if(FT_IS_SFNT(ft_face
))
5247 if (font
->ntmFlags
& NTM_PS_OPENTYPE
)
5248 TM
.tmPitchAndFamily
|= TMPF_DEVICE
;
5250 TM
.tmPitchAndFamily
|= TMPF_TRUETYPE
;
5253 TM
.tmCharSet
= font
->charset
;
5255 font
->potm
->otmFiller
= 0;
5256 memcpy(&font
->potm
->otmPanoseNumber
, pOS2
->panose
, PANOSE_COUNT
);
5257 font
->potm
->otmfsSelection
= pOS2
->fsSelection
;
5258 font
->potm
->otmfsType
= pOS2
->fsType
;
5259 font
->potm
->otmsCharSlopeRise
= pHori
->caret_Slope_Rise
;
5260 font
->potm
->otmsCharSlopeRun
= pHori
->caret_Slope_Run
;
5261 font
->potm
->otmItalicAngle
= 0; /* POST table */
5262 font
->potm
->otmEMSquare
= ft_face
->units_per_EM
;
5263 font
->potm
->otmAscent
= (pFT_MulFix(pOS2
->sTypoAscender
, y_scale
) + 32) >> 6;
5264 font
->potm
->otmDescent
= (pFT_MulFix(pOS2
->sTypoDescender
, y_scale
) + 32) >> 6;
5265 font
->potm
->otmLineGap
= (pFT_MulFix(pOS2
->sTypoLineGap
, y_scale
) + 32) >> 6;
5266 font
->potm
->otmsCapEmHeight
= (pFT_MulFix(pOS2
->sCapHeight
, y_scale
) + 32) >> 6;
5267 font
->potm
->otmsXHeight
= (pFT_MulFix(pOS2
->sxHeight
, y_scale
) + 32) >> 6;
5268 font
->potm
->otmrcFontBox
.left
= (pFT_MulFix(ft_face
->bbox
.xMin
, x_scale
) + 32) >> 6;
5269 font
->potm
->otmrcFontBox
.right
= (pFT_MulFix(ft_face
->bbox
.xMax
, x_scale
) + 32) >> 6;
5270 font
->potm
->otmrcFontBox
.top
= (pFT_MulFix(ft_face
->bbox
.yMax
, y_scale
) + 32) >> 6;
5271 font
->potm
->otmrcFontBox
.bottom
= (pFT_MulFix(ft_face
->bbox
.yMin
, y_scale
) + 32) >> 6;
5272 font
->potm
->otmMacAscent
= TM
.tmAscent
;
5273 font
->potm
->otmMacDescent
= -TM
.tmDescent
;
5274 font
->potm
->otmMacLineGap
= font
->potm
->otmLineGap
;
5275 font
->potm
->otmusMinimumPPEM
= 0; /* TT Header */
5276 font
->potm
->otmptSubscriptSize
.x
= (pFT_MulFix(pOS2
->ySubscriptXSize
, x_scale
) + 32) >> 6;
5277 font
->potm
->otmptSubscriptSize
.y
= (pFT_MulFix(pOS2
->ySubscriptYSize
, y_scale
) + 32) >> 6;
5278 font
->potm
->otmptSubscriptOffset
.x
= (pFT_MulFix(pOS2
->ySubscriptXOffset
, x_scale
) + 32) >> 6;
5279 font
->potm
->otmptSubscriptOffset
.y
= (pFT_MulFix(pOS2
->ySubscriptYOffset
, y_scale
) + 32) >> 6;
5280 font
->potm
->otmptSuperscriptSize
.x
= (pFT_MulFix(pOS2
->ySuperscriptXSize
, x_scale
) + 32) >> 6;
5281 font
->potm
->otmptSuperscriptSize
.y
= (pFT_MulFix(pOS2
->ySuperscriptYSize
, y_scale
) + 32) >> 6;
5282 font
->potm
->otmptSuperscriptOffset
.x
= (pFT_MulFix(pOS2
->ySuperscriptXOffset
, x_scale
) + 32) >> 6;
5283 font
->potm
->otmptSuperscriptOffset
.y
= (pFT_MulFix(pOS2
->ySuperscriptYOffset
, y_scale
) + 32) >> 6;
5284 font
->potm
->otmsStrikeoutSize
= (pFT_MulFix(pOS2
->yStrikeoutSize
, y_scale
) + 32) >> 6;
5285 font
->potm
->otmsStrikeoutPosition
= (pFT_MulFix(pOS2
->yStrikeoutPosition
, y_scale
) + 32) >> 6;
5287 font
->potm
->otmsUnderscoreSize
= 0;
5288 font
->potm
->otmsUnderscorePosition
= 0;
5290 font
->potm
->otmsUnderscoreSize
= (pFT_MulFix(pPost
->underlineThickness
, y_scale
) + 32) >> 6;
5291 font
->potm
->otmsUnderscorePosition
= (pFT_MulFix(pPost
->underlinePosition
, y_scale
) + 32) >> 6;
5295 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
5296 cp
= (char*)font
->potm
+ sizeof(*font
->potm
);
5297 font
->potm
->otmpFamilyName
= (LPSTR
)(cp
- (char*)font
->potm
);
5298 strcpyW((WCHAR
*)cp
, family_nameW
);
5300 font
->potm
->otmpStyleName
= (LPSTR
)(cp
- (char*)font
->potm
);
5301 strcpyW((WCHAR
*)cp
, style_nameW
);
5303 font
->potm
->otmpFaceName
= (LPSTR
)(cp
- (char*)font
->potm
);
5304 strcpyW((WCHAR
*)cp
, family_nameW
);
5305 if (ft_face
->style_flags
& (FT_STYLE_FLAG_ITALIC
| FT_STYLE_FLAG_BOLD
)) {
5306 strcatW((WCHAR
*)cp
, spaceW
);
5307 strcatW((WCHAR
*)cp
, style_nameW
);
5308 cp
+= lenfam
+ lensty
;
5311 font
->potm
->otmpFullName
= (LPSTR
)(cp
- (char*)font
->potm
);
5312 strcpyW((WCHAR
*)cp
, family_nameW
);
5313 strcatW((WCHAR
*)cp
, spaceW
);
5314 strcatW((WCHAR
*)cp
, style_nameW
);
5317 if(potm
&& needed
<= cbSize
)
5319 memcpy(potm
, font
->potm
, font
->potm
->otmSize
);
5320 scale_outline_font_metrics(font
, potm
);
5324 HeapFree(GetProcessHeap(), 0, style_nameW
);
5325 HeapFree(GetProcessHeap(), 0, family_nameW
);
5327 LeaveCriticalSection( &freetype_cs
);
5331 static BOOL
load_child_font(GdiFont
*font
, CHILD_FONT
*child
)
5333 HFONTLIST
*hfontlist
;
5334 child
->font
= alloc_font();
5335 child
->font
->ft_face
= OpenFontFace(child
->font
, child
->face
, 0, -font
->ppem
);
5336 if(!child
->font
->ft_face
)
5338 free_font(child
->font
);
5343 child
->font
->ntmFlags
= child
->face
->ntmFlags
;
5344 child
->font
->orientation
= font
->orientation
;
5345 child
->font
->scale_y
= font
->scale_y
;
5346 hfontlist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist
));
5347 hfontlist
->hfont
= CreateFontIndirectW(&font
->font_desc
.lf
);
5348 list_add_head(&child
->font
->hfontlist
, &hfontlist
->entry
);
5349 child
->font
->base_font
= font
;
5350 list_add_head(&child_font_list
, &child
->font
->entry
);
5351 TRACE("created child font hfont %p for base %p child %p\n", hfontlist
->hfont
, font
, child
->font
);
5355 static BOOL
get_glyph_index_linked(GdiFont
*font
, UINT c
, GdiFont
**linked_font
, FT_UInt
*glyph
)
5358 CHILD_FONT
*child_font
;
5361 font
= font
->base_font
;
5363 *linked_font
= font
;
5365 if((*glyph
= get_glyph_index(font
, c
)))
5368 LIST_FOR_EACH_ENTRY(child_font
, &font
->child_fonts
, CHILD_FONT
, entry
)
5370 if(!child_font
->font
)
5371 if(!load_child_font(font
, child_font
))
5374 if(!child_font
->font
->ft_face
)
5376 g
= get_glyph_index(child_font
->font
, c
);
5380 *linked_font
= child_font
->font
;
5387 /*************************************************************
5388 * WineEngGetCharWidth
5391 BOOL
WineEngGetCharWidth(GdiFont
*font
, UINT firstChar
, UINT lastChar
,
5396 FT_UInt glyph_index
;
5397 GdiFont
*linked_font
;
5399 TRACE("%p, %d, %d, %p\n", font
, firstChar
, lastChar
, buffer
);
5401 EnterCriticalSection( &freetype_cs
);
5402 for(c
= firstChar
; c
<= lastChar
; c
++) {
5403 get_glyph_index_linked(font
, c
, &linked_font
, &glyph_index
);
5404 WineEngGetGlyphOutline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
5405 &gm
, 0, NULL
, NULL
);
5406 buffer
[c
- firstChar
] = FONT_GM(linked_font
,glyph_index
)->adv
;
5408 LeaveCriticalSection( &freetype_cs
);
5412 /*************************************************************
5413 * WineEngGetCharABCWidths
5416 BOOL
WineEngGetCharABCWidths(GdiFont
*font
, UINT firstChar
, UINT lastChar
,
5421 FT_UInt glyph_index
;
5422 GdiFont
*linked_font
;
5424 TRACE("%p, %d, %d, %p\n", font
, firstChar
, lastChar
, buffer
);
5426 if(!FT_IS_SCALABLE(font
->ft_face
))
5429 EnterCriticalSection( &freetype_cs
);
5431 for(c
= firstChar
; c
<= lastChar
; c
++) {
5432 get_glyph_index_linked(font
, c
, &linked_font
, &glyph_index
);
5433 WineEngGetGlyphOutline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
5434 &gm
, 0, NULL
, NULL
);
5435 buffer
[c
- firstChar
].abcA
= FONT_GM(linked_font
,glyph_index
)->lsb
;
5436 buffer
[c
- firstChar
].abcB
= FONT_GM(linked_font
,glyph_index
)->bbx
;
5437 buffer
[c
- firstChar
].abcC
= FONT_GM(linked_font
,glyph_index
)->adv
- FONT_GM(linked_font
,glyph_index
)->lsb
-
5438 FONT_GM(linked_font
,glyph_index
)->bbx
;
5440 LeaveCriticalSection( &freetype_cs
);
5444 /*************************************************************
5445 * WineEngGetCharABCWidthsI
5448 BOOL
WineEngGetCharABCWidthsI(GdiFont
*font
, UINT firstChar
, UINT count
, LPWORD pgi
,
5453 FT_UInt glyph_index
;
5454 GdiFont
*linked_font
;
5456 if(!FT_HAS_HORIZONTAL(font
->ft_face
))
5459 EnterCriticalSection( &freetype_cs
);
5461 get_glyph_index_linked(font
, 'a', &linked_font
, &glyph_index
);
5463 for(c
= firstChar
; c
< firstChar
+count
; c
++) {
5464 WineEngGetGlyphOutline(linked_font
, c
, GGO_METRICS
| GGO_GLYPH_INDEX
,
5465 &gm
, 0, NULL
, NULL
);
5466 buffer
[c
- firstChar
].abcA
= FONT_GM(linked_font
,c
)->lsb
;
5467 buffer
[c
- firstChar
].abcB
= FONT_GM(linked_font
,c
)->bbx
;
5468 buffer
[c
- firstChar
].abcC
= FONT_GM(linked_font
,c
)->adv
- FONT_GM(linked_font
,c
)->lsb
5469 - FONT_GM(linked_font
,c
)->bbx
;
5472 for(c
= 0; c
< count
; c
++) {
5473 WineEngGetGlyphOutline(linked_font
, pgi
[c
], GGO_METRICS
| GGO_GLYPH_INDEX
,
5474 &gm
, 0, NULL
, NULL
);
5475 buffer
[c
].abcA
= FONT_GM(linked_font
,pgi
[c
])->lsb
;
5476 buffer
[c
].abcB
= FONT_GM(linked_font
,pgi
[c
])->bbx
;
5477 buffer
[c
].abcC
= FONT_GM(linked_font
,pgi
[c
])->adv
5478 - FONT_GM(linked_font
,pgi
[c
])->lsb
- FONT_GM(linked_font
,pgi
[c
])->bbx
;
5481 LeaveCriticalSection( &freetype_cs
);
5485 /*************************************************************
5486 * WineEngGetTextExtentExPoint
5489 BOOL
WineEngGetTextExtentExPoint(GdiFont
*font
, LPCWSTR wstr
, INT count
,
5490 INT max_ext
, LPINT pnfit
, LPINT dxs
, LPSIZE size
)
5496 FT_UInt glyph_index
;
5497 GdiFont
*linked_font
;
5499 TRACE("%p, %s, %d, %d, %p\n", font
, debugstr_wn(wstr
, count
), count
,
5502 EnterCriticalSection( &freetype_cs
);
5505 WineEngGetTextMetrics(font
, &tm
);
5506 size
->cy
= tm
.tmHeight
;
5508 for(idx
= 0; idx
< count
; idx
++) {
5509 get_glyph_index_linked(font
, wstr
[idx
], &linked_font
, &glyph_index
);
5510 WineEngGetGlyphOutline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
5511 &gm
, 0, NULL
, NULL
);
5512 size
->cx
+= FONT_GM(linked_font
,glyph_index
)->adv
;
5514 if (! pnfit
|| ext
<= max_ext
) {
5524 LeaveCriticalSection( &freetype_cs
);
5525 TRACE("return %d, %d, %d\n", size
->cx
, size
->cy
, nfit
);
5529 /*************************************************************
5530 * WineEngGetTextExtentExPointI
5533 BOOL
WineEngGetTextExtentExPointI(GdiFont
*font
, const WORD
*indices
, INT count
,
5534 INT max_ext
, LPINT pnfit
, LPINT dxs
, LPSIZE size
)
5541 TRACE("%p, %p, %d, %d, %p\n", font
, indices
, count
, max_ext
, size
);
5543 EnterCriticalSection( &freetype_cs
);
5546 WineEngGetTextMetrics(font
, &tm
);
5547 size
->cy
= tm
.tmHeight
;
5549 for(idx
= 0; idx
< count
; idx
++) {
5550 WineEngGetGlyphOutline(font
, indices
[idx
],
5551 GGO_METRICS
| GGO_GLYPH_INDEX
, &gm
, 0, NULL
,
5553 size
->cx
+= FONT_GM(font
,indices
[idx
])->adv
;
5555 if (! pnfit
|| ext
<= max_ext
) {
5565 LeaveCriticalSection( &freetype_cs
);
5566 TRACE("return %d, %d, %d\n", size
->cx
, size
->cy
, nfit
);
5570 /*************************************************************
5571 * WineEngGetFontData
5574 DWORD
WineEngGetFontData(GdiFont
*font
, DWORD table
, DWORD offset
, LPVOID buf
,
5577 FT_Face ft_face
= font
->ft_face
;
5581 TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
5582 font
, LOBYTE(LOWORD(table
)), HIBYTE(LOWORD(table
)),
5583 LOBYTE(HIWORD(table
)), HIBYTE(HIWORD(table
)), offset
, buf
, cbData
);
5585 if(!FT_IS_SFNT(ft_face
))
5593 if(table
) { /* MS tags differ in endianness from FT ones */
5594 table
= table
>> 24 | table
<< 24 |
5595 (table
>> 8 & 0xff00) | (table
<< 8 & 0xff0000);
5598 /* make sure value of len is the value freetype says it needs */
5601 FT_ULong needed
= 0;
5602 err
= load_sfnt_table(ft_face
, table
, offset
, NULL
, &needed
);
5603 if( !err
&& needed
< len
) len
= needed
;
5605 err
= load_sfnt_table(ft_face
, table
, offset
, buf
, &len
);
5608 TRACE("Can't find table %c%c%c%c\n",
5609 /* bytes were reversed */
5610 HIBYTE(HIWORD(table
)), LOBYTE(HIWORD(table
)),
5611 HIBYTE(LOWORD(table
)), LOBYTE(LOWORD(table
)));
5617 /*************************************************************
5618 * WineEngGetTextFace
5621 INT
WineEngGetTextFace(GdiFont
*font
, INT count
, LPWSTR str
)
5623 INT n
= strlenW(font
->name
) + 1;
5625 lstrcpynW(str
, font
->name
, count
);
5626 return min(count
, n
);
5631 UINT
WineEngGetTextCharsetInfo(GdiFont
*font
, LPFONTSIGNATURE fs
, DWORD flags
)
5633 if (fs
) *fs
= font
->fs
;
5634 return font
->charset
;
5637 BOOL
WineEngGetLinkedHFont(DC
*dc
, WCHAR c
, HFONT
*new_hfont
, UINT
*glyph
)
5639 GdiFont
*font
= dc
->gdiFont
, *linked_font
;
5640 struct list
*first_hfont
;
5643 EnterCriticalSection( &freetype_cs
);
5644 ret
= get_glyph_index_linked(font
, c
, &linked_font
, glyph
);
5645 TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph
, linked_font
);
5646 if(font
== linked_font
)
5647 *new_hfont
= dc
->hFont
;
5650 first_hfont
= list_head(&linked_font
->hfontlist
);
5651 *new_hfont
= LIST_ENTRY(first_hfont
, struct tagHFONTLIST
, entry
)->hfont
;
5653 LeaveCriticalSection( &freetype_cs
);
5657 /* Retrieve a list of supported Unicode ranges for a given font.
5658 * Can be called with NULL gs to calculate the buffer size. Returns
5659 * the number of ranges found.
5661 static DWORD
get_font_unicode_ranges(FT_Face face
, GLYPHSET
*gs
)
5663 DWORD num_ranges
= 0;
5665 if (face
->charmap
->encoding
== FT_ENCODING_UNICODE
&& pFT_Get_First_Char
)
5668 FT_ULong char_code
, char_code_prev
;
5671 char_code_prev
= char_code
= pFT_Get_First_Char(face
, &glyph_code
);
5673 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
5674 face
->num_glyphs
, glyph_code
, char_code
);
5676 if (!glyph_code
) return 0;
5680 gs
->ranges
[0].wcLow
= (USHORT
)char_code
;
5681 gs
->ranges
[0].cGlyphs
= 0;
5682 gs
->cGlyphsSupported
= 0;
5688 if (char_code
< char_code_prev
)
5690 ERR("expected increasing char code from FT_Get_Next_Char\n");
5693 if (char_code
- char_code_prev
> 1)
5698 gs
->ranges
[num_ranges
- 1].wcLow
= (USHORT
)char_code
;
5699 gs
->ranges
[num_ranges
- 1].cGlyphs
= 1;
5700 gs
->cGlyphsSupported
++;
5705 gs
->ranges
[num_ranges
- 1].cGlyphs
++;
5706 gs
->cGlyphsSupported
++;
5708 char_code_prev
= char_code
;
5709 char_code
= pFT_Get_Next_Char(face
, char_code
, &glyph_code
);
5713 FIXME("encoding %u not supported\n", face
->charmap
->encoding
);
5718 DWORD
WineEngGetFontUnicodeRanges(GdiFont
*font
, LPGLYPHSET glyphset
)
5721 DWORD num_ranges
= get_font_unicode_ranges(font
->ft_face
, glyphset
);
5723 size
= sizeof(GLYPHSET
) + sizeof(WCRANGE
) * (num_ranges
- 1);
5726 glyphset
->cbThis
= size
;
5727 glyphset
->cRanges
= num_ranges
;
5732 /*************************************************************
5735 BOOL
WineEngFontIsLinked(GdiFont
*font
)
5738 EnterCriticalSection( &freetype_cs
);
5739 ret
= !list_empty(&font
->child_fonts
);
5740 LeaveCriticalSection( &freetype_cs
);
5744 static BOOL
is_hinting_enabled(void)
5746 /* Use the >= 2.2.0 function if available */
5747 if(pFT_Get_TrueType_Engine_Type
)
5749 FT_TrueTypeEngineType type
= pFT_Get_TrueType_Engine_Type(library
);
5750 return type
== FT_TRUETYPE_ENGINE_TYPE_PATENTED
;
5752 #ifdef FT_DRIVER_HAS_HINTER
5757 /* otherwise if we've been compiled with < 2.2.0 headers
5758 use the internal macro */
5759 mod
= pFT_Get_Module(library
, "truetype");
5760 if(mod
&& FT_DRIVER_HAS_HINTER(mod
))
5768 /*************************************************************************
5769 * GetRasterizerCaps (GDI32.@)
5771 BOOL WINAPI
GetRasterizerCaps( LPRASTERIZER_STATUS lprs
, UINT cbNumBytes
)
5773 static int hinting
= -1;
5777 hinting
= is_hinting_enabled();
5778 TRACE("hinting is %senabled\n", hinting
? "" : "NOT ");
5781 lprs
->nSize
= sizeof(RASTERIZER_STATUS
);
5782 lprs
->wFlags
= TT_AVAILABLE
| TT_ENABLED
| (hinting
? WINE_TT_HINTER_ENABLED
: 0);
5783 lprs
->nLanguageID
= 0;
5787 /*************************************************************
5788 * WineEngRealizationInfo
5790 BOOL
WineEngRealizationInfo(GdiFont
*font
, realization_info_t
*info
)
5792 FIXME("(%p, %p): stub!\n", font
, info
);
5795 if(FT_IS_SCALABLE(font
->ft_face
))
5798 info
->cache_num
= font
->cache_num
;
5799 info
->unknown2
= -1;
5803 /*************************************************************************
5804 * Kerning support for TrueType fonts
5806 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
5808 struct TT_kern_table
5814 struct TT_kern_subtable
5823 USHORT horizontal
: 1;
5825 USHORT cross_stream
: 1;
5826 USHORT override
: 1;
5827 USHORT reserved1
: 4;
5833 struct TT_format0_kern_subtable
5837 USHORT entrySelector
;
5848 static DWORD
parse_format0_kern_subtable(GdiFont
*font
,
5849 const struct TT_format0_kern_subtable
*tt_f0_ks
,
5850 const USHORT
*glyph_to_char
,
5851 KERNINGPAIR
*kern_pair
, DWORD cPairs
)
5854 const struct TT_kern_pair
*tt_kern_pair
;
5856 TRACE("font height %d, units_per_EM %d\n", font
->ppem
, font
->ft_face
->units_per_EM
);
5858 nPairs
= GET_BE_WORD(tt_f0_ks
->nPairs
);
5860 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
5861 nPairs
, GET_BE_WORD(tt_f0_ks
->searchRange
),
5862 GET_BE_WORD(tt_f0_ks
->entrySelector
), GET_BE_WORD(tt_f0_ks
->rangeShift
));
5864 if (!kern_pair
|| !cPairs
)
5867 tt_kern_pair
= (const struct TT_kern_pair
*)(tt_f0_ks
+ 1);
5869 nPairs
= min(nPairs
, cPairs
);
5871 for (i
= 0; i
< nPairs
; i
++)
5873 kern_pair
->wFirst
= glyph_to_char
[GET_BE_WORD(tt_kern_pair
[i
].left
)];
5874 kern_pair
->wSecond
= glyph_to_char
[GET_BE_WORD(tt_kern_pair
[i
].right
)];
5875 /* this algorithm appears to better match what Windows does */
5876 kern_pair
->iKernAmount
= (short)GET_BE_WORD(tt_kern_pair
[i
].value
) * font
->ppem
;
5877 if (kern_pair
->iKernAmount
< 0)
5879 kern_pair
->iKernAmount
-= font
->ft_face
->units_per_EM
/ 2;
5880 kern_pair
->iKernAmount
-= font
->ppem
;
5882 else if (kern_pair
->iKernAmount
> 0)
5884 kern_pair
->iKernAmount
+= font
->ft_face
->units_per_EM
/ 2;
5885 kern_pair
->iKernAmount
+= font
->ppem
;
5887 kern_pair
->iKernAmount
/= font
->ft_face
->units_per_EM
;
5889 TRACE("left %u right %u value %d\n",
5890 kern_pair
->wFirst
, kern_pair
->wSecond
, kern_pair
->iKernAmount
);
5894 TRACE("copied %u entries\n", nPairs
);
5898 DWORD
WineEngGetKerningPairs(GdiFont
*font
, DWORD cPairs
, KERNINGPAIR
*kern_pair
)
5902 const struct TT_kern_table
*tt_kern_table
;
5903 const struct TT_kern_subtable
*tt_kern_subtable
;
5905 USHORT
*glyph_to_char
;
5907 EnterCriticalSection( &freetype_cs
);
5908 if (font
->total_kern_pairs
!= (DWORD
)-1)
5910 if (cPairs
&& kern_pair
)
5912 cPairs
= min(cPairs
, font
->total_kern_pairs
);
5913 memcpy(kern_pair
, font
->kern_pairs
, cPairs
* sizeof(*kern_pair
));
5914 LeaveCriticalSection( &freetype_cs
);
5917 LeaveCriticalSection( &freetype_cs
);
5918 return font
->total_kern_pairs
;
5921 font
->total_kern_pairs
= 0;
5923 length
= WineEngGetFontData(font
, MS_KERN_TAG
, 0, NULL
, 0);
5925 if (length
== GDI_ERROR
)
5927 TRACE("no kerning data in the font\n");
5928 LeaveCriticalSection( &freetype_cs
);
5932 buf
= HeapAlloc(GetProcessHeap(), 0, length
);
5935 WARN("Out of memory\n");
5936 LeaveCriticalSection( &freetype_cs
);
5940 WineEngGetFontData(font
, MS_KERN_TAG
, 0, buf
, length
);
5942 /* build a glyph index to char code map */
5943 glyph_to_char
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(USHORT
) * 65536);
5946 WARN("Out of memory allocating a glyph index to char code map\n");
5947 HeapFree(GetProcessHeap(), 0, buf
);
5948 LeaveCriticalSection( &freetype_cs
);
5952 if (font
->ft_face
->charmap
->encoding
== FT_ENCODING_UNICODE
&& pFT_Get_First_Char
)
5958 char_code
= pFT_Get_First_Char(font
->ft_face
, &glyph_code
);
5960 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
5961 font
->ft_face
->num_glyphs
, glyph_code
, char_code
);
5965 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
5967 /* FIXME: This doesn't match what Windows does: it does some fancy
5968 * things with duplicate glyph index to char code mappings, while
5969 * we just avoid overriding existing entries.
5971 if (glyph_code
<= 65535 && !glyph_to_char
[glyph_code
])
5972 glyph_to_char
[glyph_code
] = (USHORT
)char_code
;
5974 char_code
= pFT_Get_Next_Char(font
->ft_face
, char_code
, &glyph_code
);
5981 FIXME("encoding %u not supported\n", font
->ft_face
->charmap
->encoding
);
5982 for (n
= 0; n
<= 65535; n
++)
5983 glyph_to_char
[n
] = (USHORT
)n
;
5986 tt_kern_table
= buf
;
5987 nTables
= GET_BE_WORD(tt_kern_table
->nTables
);
5988 TRACE("version %u, nTables %u\n",
5989 GET_BE_WORD(tt_kern_table
->version
), nTables
);
5991 tt_kern_subtable
= (const struct TT_kern_subtable
*)(tt_kern_table
+ 1);
5993 for (i
= 0; i
< nTables
; i
++)
5995 struct TT_kern_subtable tt_kern_subtable_copy
;
5997 tt_kern_subtable_copy
.version
= GET_BE_WORD(tt_kern_subtable
->version
);
5998 tt_kern_subtable_copy
.length
= GET_BE_WORD(tt_kern_subtable
->length
);
5999 tt_kern_subtable_copy
.coverage
.word
= GET_BE_WORD(tt_kern_subtable
->coverage
.word
);
6001 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
6002 tt_kern_subtable_copy
.version
, tt_kern_subtable_copy
.length
,
6003 tt_kern_subtable_copy
.coverage
.word
, tt_kern_subtable_copy
.coverage
.bits
.format
);
6005 /* According to the TrueType specification this is the only format
6006 * that will be properly interpreted by Windows and OS/2
6008 if (tt_kern_subtable_copy
.coverage
.bits
.format
== 0)
6010 DWORD new_chunk
, old_total
= font
->total_kern_pairs
;
6012 new_chunk
= parse_format0_kern_subtable(font
, (const struct TT_format0_kern_subtable
*)(tt_kern_subtable
+ 1),
6013 glyph_to_char
, NULL
, 0);
6014 font
->total_kern_pairs
+= new_chunk
;
6016 if (!font
->kern_pairs
)
6017 font
->kern_pairs
= HeapAlloc(GetProcessHeap(), 0,
6018 font
->total_kern_pairs
* sizeof(*font
->kern_pairs
));
6020 font
->kern_pairs
= HeapReAlloc(GetProcessHeap(), 0, font
->kern_pairs
,
6021 font
->total_kern_pairs
* sizeof(*font
->kern_pairs
));
6023 parse_format0_kern_subtable(font
, (const struct TT_format0_kern_subtable
*)(tt_kern_subtable
+ 1),
6024 glyph_to_char
, font
->kern_pairs
+ old_total
, new_chunk
);
6027 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy
.coverage
.bits
.format
);
6029 tt_kern_subtable
= (const struct TT_kern_subtable
*)((const char *)tt_kern_subtable
+ tt_kern_subtable_copy
.length
);
6032 HeapFree(GetProcessHeap(), 0, glyph_to_char
);
6033 HeapFree(GetProcessHeap(), 0, buf
);
6035 if (cPairs
&& kern_pair
)
6037 cPairs
= min(cPairs
, font
->total_kern_pairs
);
6038 memcpy(kern_pair
, font
->kern_pairs
, cPairs
* sizeof(*kern_pair
));
6039 LeaveCriticalSection( &freetype_cs
);
6042 LeaveCriticalSection( &freetype_cs
);
6043 return font
->total_kern_pairs
;
6046 #else /* HAVE_FREETYPE */
6048 /*************************************************************************/
6050 BOOL
WineEngInit(void)
6054 GdiFont
*WineEngCreateFontInstance(DC
*dc
, HFONT hfont
)
6058 BOOL
WineEngDestroyFontInstance(HFONT hfont
)
6063 DWORD
WineEngEnumFonts(LPLOGFONTW plf
, FONTENUMPROCW proc
, LPARAM lparam
)
6068 DWORD
WineEngGetGlyphIndices(GdiFont
*font
, LPCWSTR lpstr
, INT count
,
6069 LPWORD pgi
, DWORD flags
)
6074 DWORD
WineEngGetGlyphOutline(GdiFont
*font
, UINT glyph
, UINT format
,
6075 LPGLYPHMETRICS lpgm
, DWORD buflen
, LPVOID buf
,
6078 ERR("called but we don't have FreeType\n");
6082 BOOL
WineEngGetTextMetrics(GdiFont
*font
, LPTEXTMETRICW ptm
)
6084 ERR("called but we don't have FreeType\n");
6088 UINT
WineEngGetOutlineTextMetrics(GdiFont
*font
, UINT cbSize
,
6089 OUTLINETEXTMETRICW
*potm
)
6091 ERR("called but we don't have FreeType\n");
6095 BOOL
WineEngGetCharWidth(GdiFont
*font
, UINT firstChar
, UINT lastChar
,
6098 ERR("called but we don't have FreeType\n");
6102 BOOL
WineEngGetCharABCWidths(GdiFont
*font
, UINT firstChar
, UINT lastChar
,
6105 ERR("called but we don't have FreeType\n");
6109 BOOL
WineEngGetCharABCWidthsI(GdiFont
*font
, UINT firstChar
, UINT count
, LPWORD pgi
,
6112 ERR("called but we don't have FreeType\n");
6116 BOOL
WineEngGetTextExtentExPoint(GdiFont
*font
, LPCWSTR wstr
, INT count
,
6117 INT max_ext
, LPINT nfit
, LPINT dx
, LPSIZE size
)
6119 ERR("called but we don't have FreeType\n");
6123 BOOL
WineEngGetTextExtentExPointI(GdiFont
*font
, const WORD
*indices
, INT count
,
6124 INT max_ext
, LPINT nfit
, LPINT dx
, LPSIZE size
)
6126 ERR("called but we don't have FreeType\n");
6130 DWORD
WineEngGetFontData(GdiFont
*font
, DWORD table
, DWORD offset
, LPVOID buf
,
6133 ERR("called but we don't have FreeType\n");
6137 INT
WineEngGetTextFace(GdiFont
*font
, INT count
, LPWSTR str
)
6139 ERR("called but we don't have FreeType\n");
6143 INT
WineEngAddFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
6149 INT
WineEngRemoveFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
6155 HANDLE
WineEngAddFontMemResourceEx(PVOID pbFont
, DWORD cbFont
, PVOID pdv
, DWORD
*pcFonts
)
6161 UINT
WineEngGetTextCharsetInfo(GdiFont
*font
, LPFONTSIGNATURE fs
, DWORD flags
)
6164 return DEFAULT_CHARSET
;
6167 BOOL
WineEngGetLinkedHFont(DC
*dc
, WCHAR c
, HFONT
*new_hfont
, UINT
*glyph
)
6172 DWORD
WineEngGetFontUnicodeRanges(GdiFont
*font
, LPGLYPHSET glyphset
)
6174 FIXME("(%p, %p): stub\n", font
, glyphset
);
6178 BOOL
WineEngFontIsLinked(GdiFont
*font
)
6183 /*************************************************************************
6184 * GetRasterizerCaps (GDI32.@)
6186 BOOL WINAPI
GetRasterizerCaps( LPRASTERIZER_STATUS lprs
, UINT cbNumBytes
)
6188 lprs
->nSize
= sizeof(RASTERIZER_STATUS
);
6190 lprs
->nLanguageID
= 0;
6194 DWORD
WineEngGetKerningPairs(GdiFont
*font
, DWORD cPairs
, KERNINGPAIR
*kern_pair
)
6196 ERR("called but we don't have FreeType\n");
6200 BOOL
WineEngRealizationInfo(GdiFont
*font
, realization_info_t
*info
)
6202 ERR("called but we don't have FreeType\n");
6206 #endif /* HAVE_FREETYPE */