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/library.h"
88 #include "wine/unicode.h"
89 #include "wine/debug.h"
90 #include "wine/list.h"
92 WINE_DEFAULT_DEBUG_CHANNEL(font
);
96 #ifdef HAVE_FT2BUILD_H
99 #ifdef HAVE_FREETYPE_FREETYPE_H
100 #include <freetype/freetype.h>
102 #ifdef HAVE_FREETYPE_FTGLYPH_H
103 #include <freetype/ftglyph.h>
105 #ifdef HAVE_FREETYPE_TTTABLES_H
106 #include <freetype/tttables.h>
108 #ifdef HAVE_FREETYPE_FTTYPES_H
109 #include <freetype/fttypes.h>
111 #ifdef HAVE_FREETYPE_FTSNAMES_H
112 #include <freetype/ftsnames.h>
114 #ifdef HAVE_FREETYPE_TTNAMEID_H
115 #include <freetype/ttnameid.h>
117 #ifdef HAVE_FREETYPE_FTOUTLN_H
118 #include <freetype/ftoutln.h>
120 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
121 #include <freetype/internal/sfnt.h>
123 #ifdef HAVE_FREETYPE_FTTRIGON_H
124 #include <freetype/fttrigon.h>
126 #ifdef HAVE_FREETYPE_FTWINFNT_H
127 #include <freetype/ftwinfnt.h>
129 #ifdef HAVE_FREETYPE_FTMODAPI_H
130 #include <freetype/ftmodapi.h>
132 #ifdef HAVE_FREETYPE_FTLCDFIL_H
133 #include <freetype/ftlcdfil.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 MAKE_FUNCPTR(FT_Render_Glyph
);
183 static void (*pFT_Library_Version
)(FT_Library
,FT_Int
*,FT_Int
*,FT_Int
*);
184 static FT_Error (*pFT_Load_Sfnt_Table
)(FT_Face
,FT_ULong
,FT_Long
,FT_Byte
*,FT_ULong
*);
185 static FT_ULong (*pFT_Get_First_Char
)(FT_Face
,FT_UInt
*);
186 static FT_ULong (*pFT_Get_Next_Char
)(FT_Face
,FT_ULong
,FT_UInt
*);
187 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type
)(FT_Library
);
188 #ifdef HAVE_FREETYPE_FTLCDFIL_H
189 static FT_Error (*pFT_Library_SetLcdFilter
)(FT_Library
, FT_LcdFilter
);
191 #ifdef HAVE_FREETYPE_FTWINFNT_H
192 MAKE_FUNCPTR(FT_Get_WinFNT_Header
);
195 #ifdef SONAME_LIBFONTCONFIG
196 #include <fontconfig/fontconfig.h>
197 MAKE_FUNCPTR(FcConfigGetCurrent
);
198 MAKE_FUNCPTR(FcFontList
);
199 MAKE_FUNCPTR(FcFontSetDestroy
);
200 MAKE_FUNCPTR(FcInit
);
201 MAKE_FUNCPTR(FcObjectSetAdd
);
202 MAKE_FUNCPTR(FcObjectSetCreate
);
203 MAKE_FUNCPTR(FcObjectSetDestroy
);
204 MAKE_FUNCPTR(FcPatternCreate
);
205 MAKE_FUNCPTR(FcPatternDestroy
);
206 MAKE_FUNCPTR(FcPatternGetBool
);
207 MAKE_FUNCPTR(FcPatternGetString
);
213 #define FT_MAKE_TAG( ch0, ch1, ch2, ch3 ) \
214 ( ((DWORD)(BYTE)(ch0) << 24) | ((DWORD)(BYTE)(ch1) << 16) | \
215 ((DWORD)(BYTE)(ch2) << 8) | (DWORD)(BYTE)(ch3) )
218 #ifndef ft_encoding_none
219 #define FT_ENCODING_NONE ft_encoding_none
221 #ifndef ft_encoding_ms_symbol
222 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
224 #ifndef ft_encoding_unicode
225 #define FT_ENCODING_UNICODE ft_encoding_unicode
227 #ifndef ft_encoding_apple_roman
228 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
231 #ifdef WORDS_BIGENDIAN
232 #define GET_BE_WORD(x) (x)
234 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
237 /* This is basically a copy of FT_Bitmap_Size with an extra element added */
244 FT_Short internal_leading
;
247 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
248 So to let this compile on older versions of FreeType we'll define the
249 new structure here. */
251 FT_Short height
, width
;
252 FT_Pos size
, x_ppem
, y_ppem
;
258 NEWTEXTMETRICEXW ntm
;
262 typedef struct tagFace
{
267 DWORD font_data_size
;
270 FONTSIGNATURE fs_links
;
272 FT_Fixed font_version
;
274 Bitmap_Size size
; /* set if face is a bitmap */
275 BOOL external
; /* TRUE if we should manually add this font to the registry */
276 struct tagFamily
*family
;
277 /* Cached data for Enum */
278 struct enum_data
*cached_enum_data
;
281 typedef struct tagFamily
{
283 const WCHAR
*FamilyName
;
289 INT adv
; /* These three hold to widths of the unrotated chars */
307 typedef struct tagHFONTLIST
{
322 struct list hfontlist
;
323 OUTLINETEXTMETRICW
*potm
;
324 DWORD total_kern_pairs
;
325 KERNINGPAIR
*kern_pairs
;
326 struct list child_fonts
;
328 /* the following members can be accessed without locking, they are never modified after creation */
330 struct font_mapping
*mapping
;
353 const WCHAR
*font_name
;
357 #define GM_BLOCK_SIZE 128
358 #define FONT_GM(font,idx) (&(font)->gm[(idx) / GM_BLOCK_SIZE][(idx) % GM_BLOCK_SIZE])
360 static struct list gdi_font_list
= LIST_INIT(gdi_font_list
);
361 static struct list unused_gdi_font_list
= LIST_INIT(unused_gdi_font_list
);
362 #define UNUSED_CACHE_SIZE 10
363 static struct list child_font_list
= LIST_INIT(child_font_list
);
364 static struct list system_links
= LIST_INIT(system_links
);
366 static struct list font_subst_list
= LIST_INIT(font_subst_list
);
368 static struct list font_list
= LIST_INIT(font_list
);
370 static const WCHAR defSerif
[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
371 static const WCHAR defSans
[] = {'A','r','i','a','l','\0'};
372 static const WCHAR defFixed
[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
374 static const WCHAR fontsW
[] = {'\\','f','o','n','t','s','\0'};
375 static const WCHAR win9x_font_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
376 'W','i','n','d','o','w','s','\\',
377 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
378 'F','o','n','t','s','\0'};
380 static const WCHAR winnt_font_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
381 'W','i','n','d','o','w','s',' ','N','T','\\',
382 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
383 'F','o','n','t','s','\0'};
385 static const WCHAR system_fonts_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
386 static const WCHAR FixedSys_Value
[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
387 static const WCHAR System_Value
[] = {'F','O','N','T','S','.','F','O','N','\0'};
388 static const WCHAR OEMFont_Value
[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
390 static const WCHAR
* const SystemFontValues
[4] = {
397 static const WCHAR external_fonts_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
398 'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
400 /* Interesting and well-known (frequently-assumed!) font names */
401 static const WCHAR Lucida_Sans_Unicode
[] = {'L','u','c','i','d','a',' ','S','a','n','s',' ','U','n','i','c','o','d','e',0};
402 static const WCHAR Microsoft_Sans_Serif
[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0 };
403 static const WCHAR Tahoma
[] = {'T','a','h','o','m','a',0};
404 static const WCHAR MS_UI_Gothic
[] = {'M','S',' ','U','I',' ','G','o','t','h','i','c',0};
405 static const WCHAR SimSun
[] = {'S','i','m','S','u','n',0};
406 static const WCHAR Gulim
[] = {'G','u','l','i','m',0};
407 static const WCHAR PMingLiU
[] = {'P','M','i','n','g','L','i','U',0};
408 static const WCHAR Batang
[] = {'B','a','t','a','n','g',0};
410 static const WCHAR ArabicW
[] = {'A','r','a','b','i','c','\0'};
411 static const WCHAR BalticW
[] = {'B','a','l','t','i','c','\0'};
412 static const WCHAR CHINESE_BIG5W
[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
413 static const WCHAR CHINESE_GB2312W
[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
414 static const WCHAR Central_EuropeanW
[] = {'C','e','n','t','r','a','l',' ',
415 'E','u','r','o','p','e','a','n','\0'};
416 static const WCHAR CyrillicW
[] = {'C','y','r','i','l','l','i','c','\0'};
417 static const WCHAR GreekW
[] = {'G','r','e','e','k','\0'};
418 static const WCHAR HangulW
[] = {'H','a','n','g','u','l','\0'};
419 static const WCHAR Hangul_Johab_W
[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
420 static const WCHAR HebrewW
[] = {'H','e','b','r','e','w','\0'};
421 static const WCHAR JapaneseW
[] = {'J','a','p','a','n','e','s','e','\0'};
422 static const WCHAR SymbolW
[] = {'S','y','m','b','o','l','\0'};
423 static const WCHAR ThaiW
[] = {'T','h','a','i','\0'};
424 static const WCHAR TurkishW
[] = {'T','u','r','k','i','s','h','\0'};
425 static const WCHAR VietnameseW
[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
426 static const WCHAR WesternW
[] = {'W','e','s','t','e','r','n','\0'};
427 static const WCHAR OEM_DOSW
[] = {'O','E','M','/','D','O','S','\0'};
429 static const WCHAR
* const ElfScriptsW
[32] = { /* these are in the order of the fsCsb[0] bits */
439 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /*15*/
447 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
456 typedef struct tagFontSubst
{
472 static struct list mappings_list
= LIST_INIT( mappings_list
);
474 static BOOL have_installed_roman_font
= FALSE
; /* CreateFontInstance will fail if this is still FALSE */
476 static CRITICAL_SECTION freetype_cs
;
477 static CRITICAL_SECTION_DEBUG critsect_debug
=
480 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
481 0, 0, { (DWORD_PTR
)(__FILE__
": freetype_cs") }
483 static CRITICAL_SECTION freetype_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
485 static const WCHAR font_mutex_nameW
[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
487 static const WCHAR szDefaultFallbackLink
[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0};
488 static BOOL use_default_fallback
= FALSE
;
490 static BOOL
get_glyph_index_linked(GdiFont
*font
, UINT c
, GdiFont
**linked_font
, FT_UInt
*glyph
);
492 static const WCHAR system_link
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
493 'W','i','n','d','o','w','s',' ','N','T','\\',
494 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
495 'S','y','s','t','e','m','L','i','n','k',0};
497 /****************************************
498 * Notes on .fon files
500 * The fonts System, FixedSys and Terminal are special. There are typically multiple
501 * versions installed for different resolutions and codepages. Windows stores which one to use
502 * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
504 * FIXEDFON.FON FixedSys
506 * OEMFONT.FON Terminal
507 * LogPixels Current dpi set by the display control panel applet
508 * (HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontDPI
509 * also has a LogPixels value that appears to mirror this)
511 * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
512 * (vgaoem.fon would be your oemfont.fon if you have a US setup).
513 * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
514 * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
515 * so that makes sense.
517 * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
518 * to be mapped into the registry on Windows 2000 at least).
521 * ega80woa.fon=ega80850.fon
522 * ega40woa.fon=ega40850.fon
523 * cga80woa.fon=cga80850.fon
524 * cga40woa.fon=cga40850.fon
527 /* These are all structures needed for the GSUB table */
529 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
530 #define TATEGAKI_LOWER_BOUND 0x02F1
546 GSUB_ScriptRecord ScriptRecord
[1];
552 } GSUB_LangSysRecord
;
557 GSUB_LangSysRecord LangSysRecord
[1];
561 WORD LookupOrder
; /* Reserved */
562 WORD ReqFeatureIndex
;
564 WORD FeatureIndex
[1];
570 } GSUB_FeatureRecord
;
574 GSUB_FeatureRecord FeatureRecord
[1];
578 WORD FeatureParams
; /* Reserved */
580 WORD LookupListIndex
[1];
599 } GSUB_CoverageFormat1
;
604 WORD StartCoverageIndex
;
610 GSUB_RangeRecord RangeRecord
[1];
611 } GSUB_CoverageFormat2
;
614 WORD SubstFormat
; /* = 1 */
617 } GSUB_SingleSubstFormat1
;
620 WORD SubstFormat
; /* = 2 */
624 }GSUB_SingleSubstFormat2
;
626 #ifdef HAVE_CARBON_CARBON_H
627 static char *find_cache_dir(void)
631 static char cached_path
[MAX_PATH
];
632 static const char *wine
= "/Wine", *fonts
= "/Fonts";
634 if(*cached_path
) return cached_path
;
636 err
= FSFindFolder(kUserDomain
, kCachedDataFolderType
, kCreateFolder
, &ref
);
639 WARN("can't create cached data folder\n");
642 err
= FSRefMakePath(&ref
, (unsigned char*)cached_path
, sizeof(cached_path
));
645 WARN("can't create cached data path\n");
649 if(strlen(cached_path
) + strlen(wine
) + strlen(fonts
) + 1 > sizeof(cached_path
))
651 ERR("Could not create full path\n");
655 strcat(cached_path
, wine
);
657 if(mkdir(cached_path
, 0700) == -1 && errno
!= EEXIST
)
659 WARN("Couldn't mkdir %s\n", cached_path
);
663 strcat(cached_path
, fonts
);
664 if(mkdir(cached_path
, 0700) == -1 && errno
!= EEXIST
)
666 WARN("Couldn't mkdir %s\n", cached_path
);
673 /******************************************************************
676 * Extracts individual TrueType font files from a Mac suitcase font
677 * and saves them into the user's caches directory (see
679 * Returns a NULL terminated array of filenames.
681 * We do this because they are apps that try to read ttf files
682 * themselves and they don't like Mac suitcase files.
684 static char **expand_mac_font(const char *path
)
691 const char *filename
;
695 unsigned int size
, max_size
;
698 TRACE("path %s\n", path
);
700 s
= FSPathMakeRef((unsigned char*)path
, &ref
, FALSE
);
703 WARN("failed to get ref\n");
707 s
= FSOpenResourceFile(&ref
, 0, NULL
, fsRdPerm
, &res_ref
);
710 TRACE("no data fork, so trying resource fork\n");
711 res_ref
= FSOpenResFile(&ref
, fsRdPerm
);
714 TRACE("unable to open resource fork\n");
721 ret
.array
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, ret
.max_size
* sizeof(*ret
.array
));
724 CloseResFile(res_ref
);
728 out_dir
= find_cache_dir();
730 filename
= strrchr(path
, '/');
731 if(!filename
) filename
= path
;
734 /* output filename has the form out_dir/filename_%04x.ttf */
735 output_len
= strlen(out_dir
) + 1 + strlen(filename
) + 5 + 5;
742 unsigned short *num_faces_ptr
, num_faces
, face
;
745 ResType fond_res
= FT_MAKE_TAG('F','O','N','D');
747 fond
= Get1IndResource(fond_res
, idx
);
749 TRACE("got fond resource %d\n", idx
);
752 fam_rec
= *(FamRec
**)fond
;
753 num_faces_ptr
= (unsigned short *)(fam_rec
+ 1);
754 num_faces
= GET_BE_WORD(*num_faces_ptr
);
756 assoc
= (AsscEntry
*)(num_faces_ptr
+ 1);
757 TRACE("num faces %04x\n", num_faces
);
758 for(face
= 0; face
< num_faces
; face
++, assoc
++)
761 ResType sfnt_res
= FT_MAKE_TAG('s','f','n','t');
762 unsigned short size
, font_id
;
765 size
= GET_BE_WORD(assoc
->fontSize
);
766 font_id
= GET_BE_WORD(assoc
->fontID
);
769 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id
, size
);
773 TRACE("trying to load sfnt id %04x\n", font_id
);
774 sfnt
= GetResource(sfnt_res
, font_id
);
777 TRACE("can't get sfnt resource %04x\n", font_id
);
781 output
= HeapAlloc(GetProcessHeap(), 0, output_len
);
786 sprintf(output
, "%s/%s_%04x.ttf", out_dir
, filename
, font_id
);
788 fd
= open(output
, O_CREAT
| O_EXCL
| O_WRONLY
, 0600);
789 if(fd
!= -1 || errno
== EEXIST
)
793 unsigned char *sfnt_data
;
796 sfnt_data
= *(unsigned char**)sfnt
;
797 write(fd
, sfnt_data
, GetHandleSize(sfnt
));
801 if(ret
.size
>= ret
.max_size
- 1) /* Always want the last element to be NULL */
804 ret
.array
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, ret
.array
, ret
.max_size
* sizeof(*ret
.array
));
806 ret
.array
[ret
.size
++] = output
;
810 WARN("unable to create %s\n", output
);
811 HeapFree(GetProcessHeap(), 0, output
);
814 ReleaseResource(sfnt
);
817 ReleaseResource(fond
);
820 CloseResFile(res_ref
);
825 #endif /* HAVE_CARBON_CARBON_H */
827 static inline BOOL
is_win9x(void)
829 return GetVersion() & 0x80000000;
832 This function builds an FT_Fixed from a double. It fails if the absolute
833 value of the float number is greater than 32768.
835 static inline FT_Fixed
FT_FixedFromFloat(double f
)
841 This function builds an FT_Fixed from a FIXED. It simply put f.value
842 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
844 static inline FT_Fixed
FT_FixedFromFIXED(FIXED f
)
846 return (FT_Fixed
)((int)f
.value
<< 16 | (unsigned int)f
.fract
);
850 static Face
*find_face_from_filename(const WCHAR
*file_name
, const WCHAR
*face_name
)
855 DWORD len
= WideCharToMultiByte(CP_UNIXCP
, 0, file_name
, -1, NULL
, 0, NULL
, NULL
);
856 char *file_nameA
= HeapAlloc(GetProcessHeap(), 0, len
);
858 WideCharToMultiByte(CP_UNIXCP
, 0, file_name
, -1, file_nameA
, len
, NULL
, NULL
);
859 TRACE("looking for file %s name %s\n", debugstr_a(file_nameA
), debugstr_w(face_name
));
861 LIST_FOR_EACH_ENTRY(family
, &font_list
, Family
, entry
)
863 if(face_name
&& strcmpiW(face_name
, family
->FamilyName
))
865 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
869 file
= strrchr(face
->file
, '/');
874 if(!strcasecmp(file
, file_nameA
))
876 HeapFree(GetProcessHeap(), 0, file_nameA
);
881 HeapFree(GetProcessHeap(), 0, file_nameA
);
885 static Family
*find_family_from_name(const WCHAR
*name
)
889 LIST_FOR_EACH_ENTRY(family
, &font_list
, Family
, entry
)
891 if(!strcmpiW(family
->FamilyName
, name
))
898 static void DumpSubstList(void)
902 LIST_FOR_EACH_ENTRY(psub
, &font_subst_list
, FontSubst
, entry
)
904 if(psub
->from
.charset
!= -1 || psub
->to
.charset
!= -1)
905 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub
->from
.name
),
906 psub
->from
.charset
, debugstr_w(psub
->to
.name
), psub
->to
.charset
);
908 TRACE("%s -> %s\n", debugstr_w(psub
->from
.name
),
909 debugstr_w(psub
->to
.name
));
914 static LPWSTR
strdupW(LPCWSTR p
)
917 DWORD len
= (strlenW(p
) + 1) * sizeof(WCHAR
);
918 ret
= HeapAlloc(GetProcessHeap(), 0, len
);
923 static LPSTR
strdupA(LPCSTR p
)
926 DWORD len
= (strlen(p
) + 1);
927 ret
= HeapAlloc(GetProcessHeap(), 0, len
);
932 static FontSubst
*get_font_subst(const struct list
*subst_list
, const WCHAR
*from_name
,
937 LIST_FOR_EACH_ENTRY(element
, subst_list
, FontSubst
, entry
)
939 if(!strcmpiW(element
->from
.name
, from_name
) &&
940 (element
->from
.charset
== from_charset
||
941 element
->from
.charset
== -1))
948 #define ADD_FONT_SUBST_FORCE 1
950 static BOOL
add_font_subst(struct list
*subst_list
, FontSubst
*subst
, INT flags
)
952 FontSubst
*from_exist
, *to_exist
;
954 from_exist
= get_font_subst(subst_list
, subst
->from
.name
, subst
->from
.charset
);
956 if(from_exist
&& (flags
& ADD_FONT_SUBST_FORCE
))
958 list_remove(&from_exist
->entry
);
959 HeapFree(GetProcessHeap(), 0, &from_exist
->from
.name
);
960 HeapFree(GetProcessHeap(), 0, &from_exist
->to
.name
);
961 HeapFree(GetProcessHeap(), 0, from_exist
);
967 to_exist
= get_font_subst(subst_list
, subst
->to
.name
, subst
->to
.charset
);
971 HeapFree(GetProcessHeap(), 0, subst
->to
.name
);
972 subst
->to
.name
= strdupW(to_exist
->to
.name
);
975 list_add_tail(subst_list
, &subst
->entry
);
980 HeapFree(GetProcessHeap(), 0, subst
->from
.name
);
981 HeapFree(GetProcessHeap(), 0, subst
->to
.name
);
982 HeapFree(GetProcessHeap(), 0, subst
);
986 static void split_subst_info(NameCs
*nc
, LPSTR str
)
988 CHAR
*p
= strrchr(str
, ',');
993 nc
->charset
= strtol(p
+1, NULL
, 10);
996 len
= MultiByteToWideChar(CP_ACP
, 0, str
, -1, NULL
, 0);
997 nc
->name
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
998 MultiByteToWideChar(CP_ACP
, 0, str
, -1, nc
->name
, len
);
1001 static void LoadSubstList(void)
1005 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
1009 if(RegOpenKeyA(HKEY_LOCAL_MACHINE
,
1010 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
1011 &hkey
) == ERROR_SUCCESS
) {
1013 RegQueryInfoKeyA(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
1014 &valuelen
, &datalen
, NULL
, NULL
);
1016 valuelen
++; /* returned value doesn't include room for '\0' */
1017 value
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(CHAR
));
1018 data
= HeapAlloc(GetProcessHeap(), 0, datalen
);
1022 while(RegEnumValueA(hkey
, i
++, value
, &vlen
, NULL
, &type
, data
,
1023 &dlen
) == ERROR_SUCCESS
) {
1024 TRACE("Got %s=%s\n", debugstr_a(value
), debugstr_a(data
));
1026 psub
= HeapAlloc(GetProcessHeap(), 0, sizeof(*psub
));
1027 split_subst_info(&psub
->from
, value
);
1028 split_subst_info(&psub
->to
, data
);
1030 /* Win 2000 doesn't allow mapping between different charsets
1031 or mapping of DEFAULT_CHARSET */
1032 if ((psub
->from
.charset
&& psub
->to
.charset
!= psub
->from
.charset
) ||
1033 psub
->to
.charset
== DEFAULT_CHARSET
) {
1034 HeapFree(GetProcessHeap(), 0, psub
->to
.name
);
1035 HeapFree(GetProcessHeap(), 0, psub
->from
.name
);
1036 HeapFree(GetProcessHeap(), 0, psub
);
1038 add_font_subst(&font_subst_list
, psub
, 0);
1040 /* reset dlen and vlen */
1044 HeapFree(GetProcessHeap(), 0, data
);
1045 HeapFree(GetProcessHeap(), 0, value
);
1051 /*****************************************************************
1052 * get_name_table_entry
1054 * Supply the platform, encoding, language and name ids in req
1055 * and if the name exists the function will fill in the string
1056 * and string_len members. The string is owned by FreeType so
1057 * don't free it. Returns TRUE if the name is found else FALSE.
1059 static BOOL
get_name_table_entry(FT_Face ft_face
, FT_SfntName
*req
)
1062 FT_UInt num_names
, name_index
;
1064 if(FT_IS_SFNT(ft_face
))
1066 num_names
= pFT_Get_Sfnt_Name_Count(ft_face
);
1068 for(name_index
= 0; name_index
< num_names
; name_index
++)
1070 if(!pFT_Get_Sfnt_Name(ft_face
, name_index
, &name
))
1072 if((name
.platform_id
== req
->platform_id
) &&
1073 (name
.encoding_id
== req
->encoding_id
) &&
1074 (name
.language_id
== req
->language_id
) &&
1075 (name
.name_id
== req
->name_id
))
1077 req
->string
= name
.string
;
1078 req
->string_len
= name
.string_len
;
1085 req
->string_len
= 0;
1089 static WCHAR
*get_familyname(FT_Face ft_face
)
1091 WCHAR
*family
= NULL
;
1094 name
.platform_id
= TT_PLATFORM_MICROSOFT
;
1095 name
.encoding_id
= TT_MS_ID_UNICODE_CS
;
1096 name
.language_id
= GetUserDefaultLCID();
1097 name
.name_id
= TT_NAME_ID_FONT_FAMILY
;
1099 if(get_name_table_entry(ft_face
, &name
))
1103 /* String is not nul terminated and string_len is a byte length. */
1104 family
= HeapAlloc(GetProcessHeap(), 0, name
.string_len
+ 2);
1105 for(i
= 0; i
< name
.string_len
/ 2; i
++)
1107 WORD
*tmp
= (WORD
*)&name
.string
[i
* 2];
1108 family
[i
] = GET_BE_WORD(*tmp
);
1111 TRACE("Got localised name %s\n", debugstr_w(family
));
1118 /*****************************************************************
1121 * Wrapper around FT_Load_Sfnt_Table to cope with older versions
1122 * of FreeType that don't export this function.
1125 static FT_Error
load_sfnt_table(FT_Face ft_face
, FT_ULong table
, FT_Long offset
, FT_Byte
*buf
, FT_ULong
*len
)
1130 /* If the FT_Load_Sfnt_Table function is there we'll use it */
1131 if(pFT_Load_Sfnt_Table
)
1133 err
= pFT_Load_Sfnt_Table(ft_face
, table
, offset
, buf
, len
);
1135 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
1136 else /* Do it the hard way */
1138 TT_Face tt_face
= (TT_Face
) ft_face
;
1139 SFNT_Interface
*sfnt
;
1140 if (FT_Version
.major
==2 && FT_Version
.minor
==0)
1143 sfnt
= *(SFNT_Interface
**)((char*)tt_face
+ 528);
1147 /* A field was added in the middle of the structure in 2.1.x */
1148 sfnt
= *(SFNT_Interface
**)((char*)tt_face
+ 532);
1150 err
= sfnt
->load_any(tt_face
, table
, offset
, buf
, len
);
1158 MESSAGE("This version of Wine was compiled with freetype headers later than 2.2.0\n"
1159 "but is being run with a freetype library without the FT_Load_Sfnt_Table function.\n"
1160 "Please upgrade your freetype library.\n");
1163 err
= FT_Err_Unimplemented_Feature
;
1169 static inline int TestStyles(DWORD flags
, DWORD styles
)
1171 return (flags
& styles
) == styles
;
1174 static int StyleOrdering(Face
*face
)
1176 if (TestStyles(face
->ntmFlags
, NTM_BOLD
| NTM_ITALIC
))
1178 if (TestStyles(face
->ntmFlags
, NTM_ITALIC
))
1180 if (TestStyles(face
->ntmFlags
, NTM_BOLD
))
1182 if (TestStyles(face
->ntmFlags
, NTM_REGULAR
))
1185 WARN("Don't know how to order font %s %s with flags 0x%08x\n",
1186 debugstr_w(face
->family
->FamilyName
),
1187 debugstr_w(face
->StyleName
),
1193 /* Add a style of face to a font family using an ordering of the list such
1194 that regular fonts come before bold and italic, and single styles come
1195 before compound styles. */
1196 static void AddFaceToFamily(Face
*face
, Family
*family
)
1200 LIST_FOR_EACH( entry
, &family
->faces
)
1202 Face
*ent
= LIST_ENTRY(entry
, Face
, entry
);
1203 if (StyleOrdering(face
) < StyleOrdering(ent
)) break;
1205 list_add_before( entry
, &face
->entry
);
1208 #define ADDFONT_EXTERNAL_FONT 0x01
1209 #define ADDFONT_FORCE_BITMAP 0x02
1210 static INT
AddFontToList(const char *file
, void *font_data_ptr
, DWORD font_data_size
, char *fake_family
, const WCHAR
*target_family
, DWORD flags
)
1214 TT_Header
*pHeader
= NULL
;
1215 WCHAR
*english_family
, *localised_family
, *StyleW
;
1219 struct list
*family_elem_ptr
, *face_elem_ptr
;
1221 FT_Long face_index
= 0, num_faces
;
1222 #ifdef HAVE_FREETYPE_FTWINFNT_H
1223 FT_WinFNT_HeaderRec winfnt_header
;
1225 int i
, bitmap_num
, internal_leading
;
1228 /* we always load external fonts from files - otherwise we would get a crash in update_reg_entries */
1229 assert(file
|| !(flags
& ADDFONT_EXTERNAL_FONT
));
1231 #ifdef HAVE_CARBON_CARBON_H
1232 if(file
&& !fake_family
)
1234 char **mac_list
= expand_mac_font(file
);
1237 BOOL had_one
= FALSE
;
1239 for(cursor
= mac_list
; *cursor
; cursor
++)
1242 AddFontToList(*cursor
, NULL
, 0, NULL
, NULL
, flags
);
1243 HeapFree(GetProcessHeap(), 0, *cursor
);
1245 HeapFree(GetProcessHeap(), 0, mac_list
);
1250 #endif /* HAVE_CARBON_CARBON_H */
1253 char *family_name
= fake_family
;
1257 TRACE("Loading font file %s index %ld\n", debugstr_a(file
), face_index
);
1258 err
= pFT_New_Face(library
, file
, face_index
, &ft_face
);
1261 TRACE("Loading font from ptr %p size %d, index %ld\n", font_data_ptr
, font_data_size
, face_index
);
1262 err
= pFT_New_Memory_Face(library
, font_data_ptr
, font_data_size
, face_index
, &ft_face
);
1266 WARN("Unable to load font %s/%p err = %x\n", debugstr_a(file
), font_data_ptr
, err
);
1270 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*/
1271 WARN("Ignoring font %s/%p\n", debugstr_a(file
), font_data_ptr
);
1272 pFT_Done_Face(ft_face
);
1276 /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1277 if(!FT_IS_SCALABLE(ft_face
) && FT_SimpleVersion
< ((2 << 16) | (1 << 8) | (9 << 0))) {
1278 WARN("FreeType version < 2.1.9, skipping bitmap font %s/%p\n", debugstr_a(file
), font_data_ptr
);
1279 pFT_Done_Face(ft_face
);
1283 if(FT_IS_SFNT(ft_face
))
1285 if(!(pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
)) ||
1286 !pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
) ||
1287 !(pHeader
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_head
)))
1289 TRACE("Font %s/%p lacks either an OS2, HHEA or HEAD table.\n"
1290 "Skipping this font.\n", debugstr_a(file
), font_data_ptr
);
1291 pFT_Done_Face(ft_face
);
1295 /* Wine uses ttfs as an intermediate step in building its bitmap fonts;
1296 we don't want to load these. */
1297 if(!memcmp(pOS2
->achVendID
, "Wine", sizeof(pOS2
->achVendID
)))
1301 if(!load_sfnt_table(ft_face
, FT_MAKE_TAG('E','B','S','C'), 0, NULL
, &len
))
1303 TRACE("Skipping Wine bitmap-only TrueType font %s\n", debugstr_a(file
));
1304 pFT_Done_Face(ft_face
);
1310 if(!ft_face
->family_name
|| !ft_face
->style_name
) {
1311 TRACE("Font %s/%p lacks either a family or style name\n", debugstr_a(file
), font_data_ptr
);
1312 pFT_Done_Face(ft_face
);
1316 if(ft_face
->family_name
[0] == '.') /* Ignore fonts with names beginning with a dot */
1318 TRACE("Ignoring %s since its family name begins with a dot\n", debugstr_a(file
));
1319 pFT_Done_Face(ft_face
);
1325 localised_family
= get_familyname(ft_face
);
1326 if (localised_family
&& strcmpiW(localised_family
,target_family
)!=0)
1328 TRACE("Skipping Index %i: Incorrect Family name for replacement\n",(INT
)face_index
);
1329 HeapFree(GetProcessHeap(), 0, localised_family
);
1330 num_faces
= ft_face
->num_faces
;
1331 pFT_Done_Face(ft_face
);
1334 HeapFree(GetProcessHeap(), 0, localised_family
);
1338 family_name
= ft_face
->family_name
;
1342 My_FT_Bitmap_Size
*size
= NULL
;
1345 if(!FT_IS_SCALABLE(ft_face
))
1346 size
= (My_FT_Bitmap_Size
*)ft_face
->available_sizes
+ bitmap_num
;
1348 len
= MultiByteToWideChar(CP_ACP
, 0, family_name
, -1, NULL
, 0);
1349 english_family
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1350 MultiByteToWideChar(CP_ACP
, 0, family_name
, -1, english_family
, len
);
1352 localised_family
= NULL
;
1354 localised_family
= get_familyname(ft_face
);
1355 if(localised_family
&& !strcmpiW(localised_family
, english_family
)) {
1356 HeapFree(GetProcessHeap(), 0, localised_family
);
1357 localised_family
= NULL
;
1362 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1363 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1364 if(!strcmpiW(family
->FamilyName
, localised_family
? localised_family
: english_family
))
1369 family
= HeapAlloc(GetProcessHeap(), 0, sizeof(*family
));
1370 family
->FamilyName
= strdupW(localised_family
? localised_family
: english_family
);
1371 list_init(&family
->faces
);
1372 list_add_tail(&font_list
, &family
->entry
);
1374 if(localised_family
) {
1375 FontSubst
*subst
= HeapAlloc(GetProcessHeap(), 0, sizeof(*subst
));
1376 subst
->from
.name
= strdupW(english_family
);
1377 subst
->from
.charset
= -1;
1378 subst
->to
.name
= strdupW(localised_family
);
1379 subst
->to
.charset
= -1;
1380 add_font_subst(&font_subst_list
, subst
, 0);
1383 HeapFree(GetProcessHeap(), 0, localised_family
);
1384 HeapFree(GetProcessHeap(), 0, english_family
);
1386 len
= MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, NULL
, 0);
1387 StyleW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1388 MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, StyleW
, len
);
1390 internal_leading
= 0;
1391 memset(&fs
, 0, sizeof(fs
));
1393 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
1395 fs
.fsCsb
[0] = pOS2
->ulCodePageRange1
;
1396 fs
.fsCsb
[1] = pOS2
->ulCodePageRange2
;
1397 fs
.fsUsb
[0] = pOS2
->ulUnicodeRange1
;
1398 fs
.fsUsb
[1] = pOS2
->ulUnicodeRange2
;
1399 fs
.fsUsb
[2] = pOS2
->ulUnicodeRange3
;
1400 fs
.fsUsb
[3] = pOS2
->ulUnicodeRange4
;
1401 if(pOS2
->version
== 0) {
1404 if(!pFT_Get_First_Char
|| (pFT_Get_First_Char( ft_face
, &dummy
) < 0x100))
1405 fs
.fsCsb
[0] |= FS_LATIN1
;
1407 fs
.fsCsb
[0] |= FS_SYMBOL
;
1410 #ifdef HAVE_FREETYPE_FTWINFNT_H
1411 else if(pFT_Get_WinFNT_Header
&& !pFT_Get_WinFNT_Header(ft_face
, &winfnt_header
)) {
1413 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header
.pixel_height
, winfnt_header
.charset
,
1414 winfnt_header
.vertical_resolution
,winfnt_header
.horizontal_resolution
, winfnt_header
.nominal_point_size
);
1415 if(TranslateCharsetInfo((DWORD
*)(UINT_PTR
)winfnt_header
.charset
, &csi
, TCI_SRCCHARSET
))
1417 internal_leading
= winfnt_header
.internal_leading
;
1421 face_elem_ptr
= list_head(&family
->faces
);
1422 while(face_elem_ptr
) {
1423 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1424 face_elem_ptr
= list_next(&family
->faces
, face_elem_ptr
);
1425 if(!strcmpiW(face
->StyleName
, StyleW
) &&
1426 (FT_IS_SCALABLE(ft_face
) || ((size
->y_ppem
== face
->size
.y_ppem
) && !memcmp(&fs
, &face
->fs
, sizeof(fs
)) ))) {
1427 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1428 debugstr_w(family
->FamilyName
), debugstr_w(StyleW
),
1429 face
->font_version
, pHeader
? pHeader
->Font_Revision
: 0);
1432 TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
1433 HeapFree(GetProcessHeap(), 0, StyleW
);
1434 pFT_Done_Face(ft_face
);
1437 if(!pHeader
|| pHeader
->Font_Revision
<= face
->font_version
) {
1438 TRACE("Original font is newer so skipping this one\n");
1439 HeapFree(GetProcessHeap(), 0, StyleW
);
1440 pFT_Done_Face(ft_face
);
1443 TRACE("Replacing original with this one\n");
1444 list_remove(&face
->entry
);
1445 HeapFree(GetProcessHeap(), 0, face
->file
);
1446 HeapFree(GetProcessHeap(), 0, face
->StyleName
);
1447 HeapFree(GetProcessHeap(), 0, face
);
1452 face
= HeapAlloc(GetProcessHeap(), 0, sizeof(*face
));
1453 face
->cached_enum_data
= NULL
;
1454 face
->StyleName
= StyleW
;
1457 face
->file
= strdupA(file
);
1458 face
->font_data_ptr
= NULL
;
1459 face
->font_data_size
= 0;
1464 face
->font_data_ptr
= font_data_ptr
;
1465 face
->font_data_size
= font_data_size
;
1467 face
->face_index
= face_index
;
1469 if (ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
)
1470 face
->ntmFlags
|= NTM_ITALIC
;
1471 if (ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
)
1472 face
->ntmFlags
|= NTM_BOLD
;
1473 if (face
->ntmFlags
== 0) face
->ntmFlags
= NTM_REGULAR
;
1474 face
->font_version
= pHeader
? pHeader
->Font_Revision
: 0;
1475 face
->family
= family
;
1476 face
->external
= (flags
& ADDFONT_EXTERNAL_FONT
) ? TRUE
: FALSE
;
1478 memset(&face
->fs_links
, 0, sizeof(face
->fs_links
));
1480 if(FT_IS_SCALABLE(ft_face
)) {
1481 memset(&face
->size
, 0, sizeof(face
->size
));
1482 face
->scalable
= TRUE
;
1484 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1485 size
->height
, size
->width
, size
->size
>> 6,
1486 size
->x_ppem
>> 6, size
->y_ppem
>> 6);
1487 face
->size
.height
= size
->height
;
1488 face
->size
.width
= size
->width
;
1489 face
->size
.size
= size
->size
;
1490 face
->size
.x_ppem
= size
->x_ppem
;
1491 face
->size
.y_ppem
= size
->y_ppem
;
1492 face
->size
.internal_leading
= internal_leading
;
1493 face
->scalable
= FALSE
;
1496 /* check for the presence of the 'CFF ' table to check if the font is Type1 */
1498 if (pFT_Load_Sfnt_Table
&& !pFT_Load_Sfnt_Table(ft_face
, FT_MAKE_TAG('C','F','F',' '), 0, NULL
, &tmp_size
))
1500 TRACE("Font %s/%p is OTF Type1\n", wine_dbgstr_a(file
), font_data_ptr
);
1501 face
->ntmFlags
|= NTM_PS_OPENTYPE
;
1504 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1505 face
->fs
.fsCsb
[0], face
->fs
.fsCsb
[1],
1506 face
->fs
.fsUsb
[0], face
->fs
.fsUsb
[1],
1507 face
->fs
.fsUsb
[2], face
->fs
.fsUsb
[3]);
1510 if(face
->fs
.fsCsb
[0] == 0) { /* let's see if we can find any interesting cmaps */
1511 for(i
= 0; i
< ft_face
->num_charmaps
; i
++) {
1512 switch(ft_face
->charmaps
[i
]->encoding
) {
1513 case FT_ENCODING_UNICODE
:
1514 case FT_ENCODING_APPLE_ROMAN
:
1515 face
->fs
.fsCsb
[0] |= FS_LATIN1
;
1517 case FT_ENCODING_MS_SYMBOL
:
1518 face
->fs
.fsCsb
[0] |= FS_SYMBOL
;
1526 if (!(face
->fs
.fsCsb
[0] & FS_SYMBOL
))
1527 have_installed_roman_font
= TRUE
;
1529 AddFaceToFamily(face
, family
);
1531 } while(!FT_IS_SCALABLE(ft_face
) && ++bitmap_num
< ft_face
->num_fixed_sizes
);
1533 num_faces
= ft_face
->num_faces
;
1534 pFT_Done_Face(ft_face
);
1535 TRACE("Added font %s %s\n", debugstr_w(family
->FamilyName
),
1536 debugstr_w(StyleW
));
1537 } while(num_faces
> ++face_index
);
1541 static INT
AddFontFileToList(const char *file
, char *fake_family
, const WCHAR
*target_family
, DWORD flags
)
1543 return AddFontToList(file
, NULL
, 0, fake_family
, target_family
, flags
);
1546 static void DumpFontList(void)
1550 struct list
*family_elem_ptr
, *face_elem_ptr
;
1552 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1553 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1554 TRACE("Family: %s\n", debugstr_w(family
->FamilyName
));
1555 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
1556 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1557 TRACE("\t%s\t%08x", debugstr_w(face
->StyleName
), face
->fs
.fsCsb
[0]);
1559 TRACE(" %d", face
->size
.height
);
1566 /***********************************************************
1567 * The replacement list is a way to map an entire font
1568 * family onto another family. For example adding
1570 * [HKCU\Software\Wine\Fonts\Replacements]
1571 * "Wingdings"="Winedings"
1573 * would enumerate the Winedings font both as Winedings and
1574 * Wingdings. However if a real Wingdings font is present the
1575 * replacement does not take place.
1578 static void LoadReplaceList(void)
1581 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
1586 struct list
*family_elem_ptr
, *face_elem_ptr
;
1589 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1590 if(RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts\\Replacements", &hkey
) == ERROR_SUCCESS
)
1592 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
1593 &valuelen
, &datalen
, NULL
, NULL
);
1595 valuelen
++; /* returned value doesn't include room for '\0' */
1596 value
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
1597 data
= HeapAlloc(GetProcessHeap(), 0, datalen
);
1601 while(RegEnumValueW(hkey
, i
++, value
, &vlen
, NULL
, &type
, data
,
1602 &dlen
) == ERROR_SUCCESS
) {
1603 TRACE("Got %s=%s\n", debugstr_w(value
), debugstr_w(data
));
1604 /* "NewName"="Oldname" */
1605 WideCharToMultiByte(CP_ACP
, 0, value
, -1, familyA
, sizeof(familyA
), NULL
, NULL
);
1607 /* Find the old family and hence all of the font files
1609 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1610 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1611 if(!strcmpiW(family
->FamilyName
, data
)) {
1612 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
1613 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1614 TRACE("mapping %s %s to %s\n", debugstr_w(family
->FamilyName
),
1615 debugstr_w(face
->StyleName
), familyA
);
1616 /* Now add a new entry with the new family name */
1617 AddFontToList(face
->file
, face
->font_data_ptr
, face
->font_data_size
, familyA
, family
->FamilyName
, ADDFONT_FORCE_BITMAP
| (face
->external
? ADDFONT_EXTERNAL_FONT
: 0));
1622 /* reset dlen and vlen */
1626 HeapFree(GetProcessHeap(), 0, data
);
1627 HeapFree(GetProcessHeap(), 0, value
);
1632 /*************************************************************
1635 static BOOL
init_system_links(void)
1639 DWORD type
, max_val
, max_data
, val_len
, data_len
, index
;
1640 WCHAR
*value
, *data
;
1641 WCHAR
*entry
, *next
;
1642 SYSTEM_LINKS
*font_link
, *system_font_link
;
1643 CHILD_FONT
*child_font
;
1644 static const WCHAR tahoma_ttf
[] = {'t','a','h','o','m','a','.','t','t','f',0};
1645 static const WCHAR System
[] = {'S','y','s','t','e','m',0};
1651 if(RegOpenKeyW(HKEY_LOCAL_MACHINE
, system_link
, &hkey
) == ERROR_SUCCESS
)
1653 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, &max_val
, &max_data
, NULL
, NULL
);
1654 value
= HeapAlloc(GetProcessHeap(), 0, (max_val
+ 1) * sizeof(WCHAR
));
1655 data
= HeapAlloc(GetProcessHeap(), 0, max_data
);
1656 val_len
= max_val
+ 1;
1657 data_len
= max_data
;
1659 while(RegEnumValueW(hkey
, index
++, value
, &val_len
, NULL
, &type
, (LPBYTE
)data
, &data_len
) == ERROR_SUCCESS
)
1661 memset(&fs
, 0, sizeof(fs
));
1662 psub
= get_font_subst(&font_subst_list
, value
, -1);
1663 /* Don't store fonts that are only substitutes for other fonts */
1666 TRACE("%s: SystemLink entry for substituted font, ignoring\n", debugstr_w(value
));
1669 font_link
= HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link
));
1670 font_link
->font_name
= strdupW(value
);
1671 list_init(&font_link
->links
);
1672 for(entry
= data
; (char*)entry
< (char*)data
+ data_len
&& *entry
!= 0; entry
= next
)
1675 CHILD_FONT
*child_font
;
1677 TRACE("%s: %s\n", debugstr_w(value
), debugstr_w(entry
));
1679 next
= entry
+ strlenW(entry
) + 1;
1681 face_name
= strchrW(entry
, ',');
1685 while(isspaceW(*face_name
))
1688 psub
= get_font_subst(&font_subst_list
, face_name
, -1);
1690 face_name
= psub
->to
.name
;
1692 face
= find_face_from_filename(entry
, face_name
);
1695 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry
), debugstr_w(face_name
));
1699 child_font
= HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font
));
1700 child_font
->face
= face
;
1701 child_font
->font
= NULL
;
1702 fs
.fsCsb
[0] |= face
->fs
.fsCsb
[0];
1703 fs
.fsCsb
[1] |= face
->fs
.fsCsb
[1];
1704 TRACE("Adding file %s index %ld\n", child_font
->face
->file
, child_font
->face
->face_index
);
1705 list_add_tail(&font_link
->links
, &child_font
->entry
);
1707 family
= find_family_from_name(font_link
->font_name
);
1710 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
1712 face
->fs_links
= fs
;
1715 list_add_tail(&system_links
, &font_link
->entry
);
1717 val_len
= max_val
+ 1;
1718 data_len
= max_data
;
1721 HeapFree(GetProcessHeap(), 0, value
);
1722 HeapFree(GetProcessHeap(), 0, data
);
1726 /* Explicitly add an entry for the system font, this links to Tahoma and any links
1729 system_font_link
= HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link
));
1730 system_font_link
->font_name
= strdupW(System
);
1731 list_init(&system_font_link
->links
);
1733 face
= find_face_from_filename(tahoma_ttf
, Tahoma
);
1736 child_font
= HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font
));
1737 child_font
->face
= face
;
1738 child_font
->font
= NULL
;
1739 TRACE("Found Tahoma in %s index %ld\n", child_font
->face
->file
, child_font
->face
->face_index
);
1740 list_add_tail(&system_font_link
->links
, &child_font
->entry
);
1742 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
1744 if(!strcmpiW(font_link
->font_name
, Tahoma
))
1746 CHILD_FONT
*font_link_entry
;
1747 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
1749 CHILD_FONT
*new_child
;
1750 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
1751 new_child
->face
= font_link_entry
->face
;
1752 new_child
->font
= NULL
;
1753 list_add_tail(&system_font_link
->links
, &new_child
->entry
);
1758 list_add_tail(&system_links
, &system_font_link
->entry
);
1762 static BOOL
ReadFontDir(const char *dirname
, BOOL external_fonts
)
1765 struct dirent
*dent
;
1766 char path
[MAX_PATH
];
1768 TRACE("Loading fonts from %s\n", debugstr_a(dirname
));
1770 dir
= opendir(dirname
);
1772 WARN("Can't open directory %s\n", debugstr_a(dirname
));
1775 while((dent
= readdir(dir
)) != NULL
) {
1776 struct stat statbuf
;
1778 if(!strcmp(dent
->d_name
, ".") || !strcmp(dent
->d_name
, ".."))
1781 TRACE("Found %s in %s\n", debugstr_a(dent
->d_name
), debugstr_a(dirname
));
1783 sprintf(path
, "%s/%s", dirname
, dent
->d_name
);
1785 if(stat(path
, &statbuf
) == -1)
1787 WARN("Can't stat %s\n", debugstr_a(path
));
1790 if(S_ISDIR(statbuf
.st_mode
))
1791 ReadFontDir(path
, external_fonts
);
1793 AddFontFileToList(path
, NULL
, NULL
, external_fonts
? ADDFONT_EXTERNAL_FONT
: 0);
1799 static void load_fontconfig_fonts(void)
1801 #ifdef SONAME_LIBFONTCONFIG
1802 void *fc_handle
= NULL
;
1811 fc_handle
= wine_dlopen(SONAME_LIBFONTCONFIG
, RTLD_NOW
, NULL
, 0);
1813 TRACE("Wine cannot find the fontconfig library (%s).\n",
1814 SONAME_LIBFONTCONFIG
);
1817 #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;}
1818 LOAD_FUNCPTR(FcConfigGetCurrent
);
1819 LOAD_FUNCPTR(FcFontList
);
1820 LOAD_FUNCPTR(FcFontSetDestroy
);
1821 LOAD_FUNCPTR(FcInit
);
1822 LOAD_FUNCPTR(FcObjectSetAdd
);
1823 LOAD_FUNCPTR(FcObjectSetCreate
);
1824 LOAD_FUNCPTR(FcObjectSetDestroy
);
1825 LOAD_FUNCPTR(FcPatternCreate
);
1826 LOAD_FUNCPTR(FcPatternDestroy
);
1827 LOAD_FUNCPTR(FcPatternGetBool
);
1828 LOAD_FUNCPTR(FcPatternGetString
);
1831 if(!pFcInit()) return;
1833 config
= pFcConfigGetCurrent();
1834 pat
= pFcPatternCreate();
1835 os
= pFcObjectSetCreate();
1836 pFcObjectSetAdd(os
, FC_FILE
);
1837 pFcObjectSetAdd(os
, FC_SCALABLE
);
1838 fontset
= pFcFontList(config
, pat
, os
);
1839 if(!fontset
) return;
1840 for(i
= 0; i
< fontset
->nfont
; i
++) {
1843 if(pFcPatternGetString(fontset
->fonts
[i
], FC_FILE
, 0, (FcChar8
**)&file
) != FcResultMatch
)
1845 TRACE("fontconfig: %s\n", file
);
1847 /* We're just interested in OT/TT fonts for now, so this hack just
1848 picks up the scalable fonts without extensions .pf[ab] to save time
1849 loading every other font */
1851 if(pFcPatternGetBool(fontset
->fonts
[i
], FC_SCALABLE
, 0, &scalable
) == FcResultMatch
&& !scalable
)
1853 TRACE("not scalable\n");
1857 len
= strlen( file
);
1858 if(len
< 4) continue;
1859 ext
= &file
[ len
- 3 ];
1860 if(strcasecmp(ext
, "pfa") && strcasecmp(ext
, "pfb"))
1861 AddFontFileToList(file
, NULL
, NULL
, ADDFONT_EXTERNAL_FONT
);
1863 pFcFontSetDestroy(fontset
);
1864 pFcObjectSetDestroy(os
);
1865 pFcPatternDestroy(pat
);
1871 static BOOL
load_font_from_data_dir(LPCWSTR file
)
1874 const char *data_dir
= wine_get_data_dir();
1876 if (!data_dir
) data_dir
= wine_get_build_dir();
1883 len
= WideCharToMultiByte(CP_UNIXCP
, 0, file
, -1, NULL
, 0, NULL
, NULL
);
1885 unix_name
= HeapAlloc(GetProcessHeap(), 0, strlen(data_dir
) + len
+ sizeof("/fonts/"));
1887 strcpy(unix_name
, data_dir
);
1888 strcat(unix_name
, "/fonts/");
1890 WideCharToMultiByte(CP_UNIXCP
, 0, file
, -1, unix_name
+ strlen(unix_name
), len
, NULL
, NULL
);
1892 EnterCriticalSection( &freetype_cs
);
1893 ret
= AddFontFileToList(unix_name
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
1894 LeaveCriticalSection( &freetype_cs
);
1895 HeapFree(GetProcessHeap(), 0, unix_name
);
1900 static BOOL
load_font_from_winfonts_dir(LPCWSTR file
)
1902 static const WCHAR slashW
[] = {'\\','\0'};
1904 WCHAR windowsdir
[MAX_PATH
];
1907 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
1908 strcatW(windowsdir
, fontsW
);
1909 strcatW(windowsdir
, slashW
);
1910 strcatW(windowsdir
, file
);
1911 if ((unixname
= wine_get_unix_file_name(windowsdir
))) {
1912 EnterCriticalSection( &freetype_cs
);
1913 ret
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
1914 LeaveCriticalSection( &freetype_cs
);
1915 HeapFree(GetProcessHeap(), 0, unixname
);
1920 static void load_system_fonts(void)
1923 WCHAR data
[MAX_PATH
], windowsdir
[MAX_PATH
], pathW
[MAX_PATH
];
1924 const WCHAR
* const *value
;
1926 static const WCHAR fmtW
[] = {'%','s','\\','%','s','\0'};
1929 if(RegOpenKeyW(HKEY_CURRENT_CONFIG
, system_fonts_reg_key
, &hkey
) == ERROR_SUCCESS
) {
1930 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
1931 strcatW(windowsdir
, fontsW
);
1932 for(value
= SystemFontValues
; *value
; value
++) {
1933 dlen
= sizeof(data
);
1934 if(RegQueryValueExW(hkey
, *value
, 0, &type
, (void*)data
, &dlen
) == ERROR_SUCCESS
&&
1938 sprintfW(pathW
, fmtW
, windowsdir
, data
);
1939 if((unixname
= wine_get_unix_file_name(pathW
))) {
1940 added
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
1941 HeapFree(GetProcessHeap(), 0, unixname
);
1944 load_font_from_data_dir(data
);
1951 /*************************************************************
1953 * This adds registry entries for any externally loaded fonts
1954 * (fonts from fontconfig or FontDirs). It also deletes entries
1955 * of no longer existing fonts.
1958 static void update_reg_entries(void)
1960 HKEY winnt_key
= 0, win9x_key
= 0, external_key
= 0;
1965 struct list
*family_elem_ptr
, *face_elem_ptr
;
1967 static const WCHAR TrueType
[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
1968 static const WCHAR spaceW
[] = {' ', '\0'};
1971 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
,
1972 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &winnt_key
, NULL
) != ERROR_SUCCESS
) {
1973 ERR("Can't create Windows font reg key\n");
1977 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
,
1978 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &win9x_key
, NULL
) != ERROR_SUCCESS
) {
1979 ERR("Can't create Windows font reg key\n");
1983 if(RegCreateKeyExW(HKEY_CURRENT_USER
, external_fonts_reg_key
,
1984 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &external_key
, NULL
) != ERROR_SUCCESS
) {
1985 ERR("Can't create external font reg key\n");
1989 /* enumerate the fonts and add external ones to the two keys */
1991 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1992 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1993 len_fam
= strlenW(family
->FamilyName
) + sizeof(TrueType
) / sizeof(WCHAR
) + 1;
1994 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
1995 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1996 if(!face
->external
) continue;
1998 if (!(face
->ntmFlags
& NTM_REGULAR
))
1999 len
= len_fam
+ strlenW(face
->StyleName
) + 1;
2000 valueW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2001 strcpyW(valueW
, family
->FamilyName
);
2002 if(len
!= len_fam
) {
2003 strcatW(valueW
, spaceW
);
2004 strcatW(valueW
, face
->StyleName
);
2006 strcatW(valueW
, TrueType
);
2008 file
= wine_get_dos_file_name(face
->file
);
2010 len
= strlenW(file
) + 1;
2013 if((path
= strrchr(face
->file
, '/')) == NULL
)
2017 len
= MultiByteToWideChar(CP_ACP
, 0, path
, -1, NULL
, 0);
2019 file
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2020 MultiByteToWideChar(CP_ACP
, 0, path
, -1, file
, len
);
2022 RegSetValueExW(winnt_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2023 RegSetValueExW(win9x_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2024 RegSetValueExW(external_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2026 HeapFree(GetProcessHeap(), 0, file
);
2027 HeapFree(GetProcessHeap(), 0, valueW
);
2031 if(external_key
) RegCloseKey(external_key
);
2032 if(win9x_key
) RegCloseKey(win9x_key
);
2033 if(winnt_key
) RegCloseKey(winnt_key
);
2037 static void delete_external_font_keys(void)
2039 HKEY winnt_key
= 0, win9x_key
= 0, external_key
= 0;
2040 DWORD dlen
, vlen
, datalen
, valuelen
, i
, type
;
2044 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
,
2045 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &winnt_key
, NULL
) != ERROR_SUCCESS
) {
2046 ERR("Can't create Windows font reg key\n");
2050 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
,
2051 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &win9x_key
, NULL
) != ERROR_SUCCESS
) {
2052 ERR("Can't create Windows font reg key\n");
2056 if(RegCreateKeyW(HKEY_CURRENT_USER
, external_fonts_reg_key
, &external_key
) != ERROR_SUCCESS
) {
2057 ERR("Can't create external font reg key\n");
2061 /* Delete all external fonts added last time */
2063 RegQueryInfoKeyW(external_key
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2064 &valuelen
, &datalen
, NULL
, NULL
);
2065 valuelen
++; /* returned value doesn't include room for '\0' */
2066 valueW
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
2067 data
= HeapAlloc(GetProcessHeap(), 0, datalen
* sizeof(WCHAR
));
2069 dlen
= datalen
* sizeof(WCHAR
);
2072 while(RegEnumValueW(external_key
, i
++, valueW
, &vlen
, NULL
, &type
, data
,
2073 &dlen
) == ERROR_SUCCESS
) {
2075 RegDeleteValueW(winnt_key
, valueW
);
2076 RegDeleteValueW(win9x_key
, valueW
);
2077 /* reset dlen and vlen */
2081 HeapFree(GetProcessHeap(), 0, data
);
2082 HeapFree(GetProcessHeap(), 0, valueW
);
2084 /* Delete the old external fonts key */
2085 RegCloseKey(external_key
);
2086 RegDeleteKeyW(HKEY_CURRENT_USER
, external_fonts_reg_key
);
2089 if(win9x_key
) RegCloseKey(win9x_key
);
2090 if(winnt_key
) RegCloseKey(winnt_key
);
2093 /*************************************************************
2094 * WineEngAddFontResourceEx
2097 INT
WineEngAddFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
2103 if (ft_handle
) /* do it only if we have freetype up and running */
2108 FIXME("Ignoring flags %x\n", flags
);
2110 if((unixname
= wine_get_unix_file_name(file
)))
2112 EnterCriticalSection( &freetype_cs
);
2113 ret
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2114 LeaveCriticalSection( &freetype_cs
);
2115 HeapFree(GetProcessHeap(), 0, unixname
);
2117 if (!ret
&& !strchrW(file
, '\\')) {
2118 /* Try in %WINDIR%/fonts, needed for Fotobuch Designer */
2119 ret
= load_font_from_winfonts_dir(file
);
2121 /* Try in datadir/fonts (or builddir/fonts),
2122 * needed for Magic the Gathering Online
2124 ret
= load_font_from_data_dir(file
);
2131 /*************************************************************
2132 * WineEngAddFontMemResourceEx
2135 HANDLE
WineEngAddFontMemResourceEx(PVOID pbFont
, DWORD cbFont
, PVOID pdv
, DWORD
*pcFonts
)
2139 if (ft_handle
) /* do it only if we have freetype up and running */
2141 PVOID pFontCopy
= HeapAlloc(GetProcessHeap(), 0, cbFont
);
2143 TRACE("Copying %d bytes of data from %p to %p\n", cbFont
, pbFont
, pFontCopy
);
2144 memcpy(pFontCopy
, pbFont
, cbFont
);
2146 EnterCriticalSection( &freetype_cs
);
2147 *pcFonts
= AddFontToList(NULL
, pFontCopy
, cbFont
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2148 LeaveCriticalSection( &freetype_cs
);
2152 TRACE("AddFontToList failed\n");
2153 HeapFree(GetProcessHeap(), 0, pFontCopy
);
2156 /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
2157 * For now return something unique but quite random
2159 TRACE("Returning handle %lx\n", ((INT_PTR
)pFontCopy
)^0x87654321);
2160 return (HANDLE
)(((INT_PTR
)pFontCopy
)^0x87654321);
2167 /*************************************************************
2168 * WineEngRemoveFontResourceEx
2171 BOOL
WineEngRemoveFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
2174 FIXME("(%s, %x, %p): stub\n", debugstr_w(file
), flags
, pdv
);
2178 static const struct nls_update_font_list
2180 UINT ansi_cp
, oem_cp
;
2181 const char *oem
, *fixed
, *system
;
2182 const char *courier
, *serif
, *small
, *sserif
;
2183 /* these are for font substitutes */
2184 const char *shelldlg
, *tmsrmn
;
2185 const char *fixed_0
, *system_0
, *courier_0
, *serif_0
, *small_0
, *sserif_0
,
2189 const char *from
, *to
;
2190 } arial_0
, courier_new_0
, times_new_roman_0
;
2191 } nls_update_font_list
[] =
2193 /* Latin 1 (United States) */
2194 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
2195 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2196 "Tahoma","Times New Roman",
2197 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2200 /* Latin 1 (Multilingual) */
2201 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
2202 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2203 "Tahoma","Times New Roman", /* FIXME unverified */
2204 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2207 /* Eastern Europe */
2208 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
2209 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
2210 "Tahoma","Times New Roman", /* FIXME unverified */
2211 "Fixedsys,238", "System,238",
2212 "Courier New,238", "MS Serif,238", "Small Fonts,238",
2213 "MS Sans Serif,238", "MS Sans Serif,238", "MS Serif,238",
2214 { "Arial CE,0", "Arial,238" },
2215 { "Courier New CE,0", "Courier New,238" },
2216 { "Times New Roman CE,0", "Times New Roman,238" }
2219 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
2220 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
2221 "Tahoma","Times New Roman", /* FIXME unverified */
2222 "Fixedsys,204", "System,204",
2223 "Courier New,204", "MS Serif,204", "Small Fonts,204",
2224 "MS Sans Serif,204", "MS Sans Serif,204", "MS Serif,204",
2225 { "Arial Cyr,0", "Arial,204" },
2226 { "Courier New Cyr,0", "Courier New,204" },
2227 { "Times New Roman Cyr,0", "Times New Roman,204" }
2230 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
2231 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
2232 "Tahoma","Times New Roman", /* FIXME unverified */
2233 "Fixedsys,161", "System,161",
2234 "Courier New,161", "MS Serif,161", "Small Fonts,161",
2235 "MS Sans Serif,161", "MS Sans Serif,161", "MS Serif,161",
2236 { "Arial Greek,0", "Arial,161" },
2237 { "Courier New Greek,0", "Courier New,161" },
2238 { "Times New Roman Greek,0", "Times New Roman,161" }
2241 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
2242 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
2243 "Tahoma","Times New Roman", /* FIXME unverified */
2244 "Fixedsys,162", "System,162",
2245 "Courier New,162", "MS Serif,162", "Small Fonts,162",
2246 "MS Sans Serif,162", "MS Sans Serif,162", "MS Serif,162",
2247 { "Arial Tur,0", "Arial,162" },
2248 { "Courier New Tur,0", "Courier New,162" },
2249 { "Times New Roman Tur,0", "Times New Roman,162" }
2252 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
2253 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
2254 "Tahoma","Times New Roman", /* FIXME unverified */
2255 "Fixedsys,177", "System,177",
2256 "Courier New,177", "MS Serif,177", "Small Fonts,177",
2257 "MS Sans Serif,177", "MS Sans Serif,177", "MS Serif,177",
2261 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
2262 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
2263 "Tahoma","Times New Roman", /* FIXME unverified */
2264 "Fixedsys,178", "System,178",
2265 "Courier New,178", "MS Serif,178", "Small Fonts,178",
2266 "MS Sans Serif,178", "MS Sans Serif,178", "MS Serif,178",
2270 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
2271 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
2272 "Tahoma","Times New Roman", /* FIXME unverified */
2273 "Fixedsys,186", "System,186",
2274 "Courier New,186", "MS Serif,186", "Small Fonts,186",
2275 "MS Sans Serif,186", "MS Sans Serif,186", "MS Serif,186",
2276 { "Arial Baltic,0", "Arial,186" },
2277 { "Courier New Baltic,0", "Courier New,186" },
2278 { "Times New Roman Baltic,0", "Times New Roman,186" }
2281 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
2282 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2283 "Tahoma","Times New Roman", /* FIXME unverified */
2284 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2288 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
2289 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
2290 "Tahoma","Times New Roman", /* FIXME unverified */
2291 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2295 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
2296 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
2297 "MS UI Gothic","MS Serif",
2298 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2301 /* Chinese Simplified */
2302 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
2303 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2304 "SimSun", "NSimSun",
2305 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2309 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
2310 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2312 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2315 /* Chinese Traditional */
2316 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
2317 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2318 "PMingLiU", "MingLiU",
2319 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2324 static const WCHAR
*font_links_list
[] =
2326 Lucida_Sans_Unicode
,
2327 Microsoft_Sans_Serif
,
2331 static const struct font_links_defaults_list
2333 /* Keyed off substitution for "MS Shell Dlg" */
2334 const WCHAR
*shelldlg
;
2335 /* Maximum of four substitutes, plus terminating NULL pointer */
2336 const WCHAR
*substitutes
[5];
2337 } font_links_defaults_list
[] =
2339 /* Non East-Asian */
2340 { Tahoma
, /* FIXME unverified ordering */
2341 { MS_UI_Gothic
, SimSun
, Gulim
, PMingLiU
, NULL
}
2343 /* Below lists are courtesy of
2344 * http://blogs.msdn.com/michkap/archive/2005/06/18/430507.aspx
2348 { MS_UI_Gothic
, PMingLiU
, SimSun
, Gulim
, NULL
}
2350 /* Chinese Simplified */
2352 { SimSun
, PMingLiU
, MS_UI_Gothic
, Batang
, NULL
}
2356 { Gulim
, PMingLiU
, MS_UI_Gothic
, SimSun
, NULL
}
2358 /* Chinese Traditional */
2360 { PMingLiU
, SimSun
, MS_UI_Gothic
, Batang
, NULL
}
2364 static inline BOOL
is_dbcs_ansi_cp(UINT ansi_cp
)
2366 return ( ansi_cp
== 932 /* CP932 for Japanese */
2367 || ansi_cp
== 936 /* CP936 for Chinese Simplified */
2368 || ansi_cp
== 949 /* CP949 for Korean */
2369 || ansi_cp
== 950 ); /* CP950 for Chinese Traditional */
2372 static inline HKEY
create_fonts_NT_registry_key(void)
2376 RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
, 0, NULL
,
2377 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2381 static inline HKEY
create_fonts_9x_registry_key(void)
2385 RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
, 0, NULL
,
2386 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2390 static inline HKEY
create_config_fonts_registry_key(void)
2394 RegCreateKeyExW(HKEY_CURRENT_CONFIG
, system_fonts_reg_key
, 0, NULL
,
2395 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2399 static void add_font_list(HKEY hkey
, const struct nls_update_font_list
*fl
)
2401 RegSetValueExA(hkey
, "Courier", 0, REG_SZ
, (const BYTE
*)fl
->courier
, strlen(fl
->courier
)+1);
2402 RegSetValueExA(hkey
, "MS Serif", 0, REG_SZ
, (const BYTE
*)fl
->serif
, strlen(fl
->serif
)+1);
2403 RegSetValueExA(hkey
, "MS Sans Serif", 0, REG_SZ
, (const BYTE
*)fl
->sserif
, strlen(fl
->sserif
)+1);
2404 RegSetValueExA(hkey
, "Small Fonts", 0, REG_SZ
, (const BYTE
*)fl
->small
, strlen(fl
->small
)+1);
2407 static void set_value_key(HKEY hkey
, const char *name
, const char *value
)
2410 RegSetValueExA(hkey
, name
, 0, REG_SZ
, (const BYTE
*)value
, strlen(value
) + 1);
2412 RegDeleteValueA(hkey
, name
);
2415 static void update_font_info(void)
2417 char buf
[40], cpbuf
[40];
2420 UINT i
, ansi_cp
= 0, oem_cp
= 0;
2423 if (RegCreateKeyExA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts", 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
) != ERROR_SUCCESS
)
2426 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_IDEFAULTANSICODEPAGE
|LOCALE_RETURN_NUMBER
|LOCALE_NOUSEROVERRIDE
,
2427 (WCHAR
*)&ansi_cp
, sizeof(ansi_cp
)/sizeof(WCHAR
));
2428 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_IDEFAULTCODEPAGE
|LOCALE_RETURN_NUMBER
|LOCALE_NOUSEROVERRIDE
,
2429 (WCHAR
*)&oem_cp
, sizeof(oem_cp
)/sizeof(WCHAR
));
2430 sprintf( cpbuf
, "%u,%u", ansi_cp
, oem_cp
);
2432 /* Setup Default_Fallback usage for DBCS ANSI codepages */
2433 if (is_dbcs_ansi_cp(ansi_cp
))
2434 use_default_fallback
= TRUE
;
2437 if (RegQueryValueExA(hkey
, "Codepages", 0, &type
, (BYTE
*)buf
, &len
) == ERROR_SUCCESS
&& type
== REG_SZ
)
2439 if (!strcmp( buf
, cpbuf
)) /* already set correctly */
2444 TRACE("updating registry, codepages changed %s -> %u,%u\n", buf
, ansi_cp
, oem_cp
);
2446 else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp
, oem_cp
);
2448 RegSetValueExA(hkey
, "Codepages", 0, REG_SZ
, (const BYTE
*)cpbuf
, strlen(cpbuf
)+1);
2451 for (i
= 0; i
< sizeof(nls_update_font_list
)/sizeof(nls_update_font_list
[0]); i
++)
2455 if (nls_update_font_list
[i
].ansi_cp
== ansi_cp
&&
2456 nls_update_font_list
[i
].oem_cp
== oem_cp
)
2458 hkey
= create_config_fonts_registry_key();
2459 RegSetValueExA(hkey
, "OEMFONT.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].oem
, strlen(nls_update_font_list
[i
].oem
)+1);
2460 RegSetValueExA(hkey
, "FIXEDFON.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].fixed
, strlen(nls_update_font_list
[i
].fixed
)+1);
2461 RegSetValueExA(hkey
, "FONTS.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].system
, strlen(nls_update_font_list
[i
].system
)+1);
2464 hkey
= create_fonts_NT_registry_key();
2465 add_font_list(hkey
, &nls_update_font_list
[i
]);
2468 hkey
= create_fonts_9x_registry_key();
2469 add_font_list(hkey
, &nls_update_font_list
[i
]);
2472 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey
))
2474 RegSetValueExA(hkey
, "MS Shell Dlg", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].shelldlg
,
2475 strlen(nls_update_font_list
[i
].shelldlg
)+1);
2476 RegSetValueExA(hkey
, "Tms Rmn", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].tmsrmn
,
2477 strlen(nls_update_font_list
[i
].tmsrmn
)+1);
2479 set_value_key(hkey
, "Fixedsys,0", nls_update_font_list
[i
].fixed_0
);
2480 set_value_key(hkey
, "System,0", nls_update_font_list
[i
].system_0
);
2481 set_value_key(hkey
, "Courier,0", nls_update_font_list
[i
].courier_0
);
2482 set_value_key(hkey
, "MS Serif,0", nls_update_font_list
[i
].serif_0
);
2483 set_value_key(hkey
, "Small Fonts,0", nls_update_font_list
[i
].small_0
);
2484 set_value_key(hkey
, "MS Sans Serif,0", nls_update_font_list
[i
].sserif_0
);
2485 set_value_key(hkey
, "Helv,0", nls_update_font_list
[i
].helv_0
);
2486 set_value_key(hkey
, "Tms Rmn,0", nls_update_font_list
[i
].tmsrmn_0
);
2488 set_value_key(hkey
, nls_update_font_list
[i
].arial_0
.from
, nls_update_font_list
[i
].arial_0
.to
);
2489 set_value_key(hkey
, nls_update_font_list
[i
].courier_new_0
.from
, nls_update_font_list
[i
].courier_new_0
.to
);
2490 set_value_key(hkey
, nls_update_font_list
[i
].times_new_roman_0
.from
, nls_update_font_list
[i
].times_new_roman_0
.to
);
2498 /* Delete the FontSubstitutes from other locales */
2499 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey
))
2501 set_value_key(hkey
, nls_update_font_list
[i
].arial_0
.from
, NULL
);
2502 set_value_key(hkey
, nls_update_font_list
[i
].courier_new_0
.from
, NULL
);
2503 set_value_key(hkey
, nls_update_font_list
[i
].times_new_roman_0
.from
, NULL
);
2509 FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp
, oem_cp
);
2511 /* Clear out system links */
2512 RegDeleteKeyW(HKEY_LOCAL_MACHINE
, system_link
);
2515 static void populate_system_links(HKEY hkey
, const WCHAR
*name
, const WCHAR
*const *values
)
2525 WCHAR buff
[MAX_PATH
];
2529 static const WCHAR comma
[] = {',',0};
2531 RegDeleteValueW(hkey
, name
);
2536 for (i
= 0; values
[i
] != NULL
; i
++)
2539 if (!strcmpiW(name
,value
))
2541 psub
= get_font_subst(&font_subst_list
, value
, -1);
2543 value
= psub
->to
.name
;
2544 family
= find_family_from_name(value
);
2548 /* Use first extant filename for this Family */
2549 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
2553 file
= strrchr(face
->file
, '/');
2562 fileLen
= MultiByteToWideChar(CP_UNIXCP
, 0, file
, -1, NULL
, 0);
2563 fileW
= HeapAlloc(GetProcessHeap(), 0, fileLen
* sizeof(WCHAR
));
2564 MultiByteToWideChar(CP_UNIXCP
, 0, file
, -1, fileW
, fileLen
);
2565 entryLen
= strlenW(fileW
) + 1 + strlenW(value
) + 1;
2566 if (sizeof(buff
)-(data
-buff
) < entryLen
+ 1)
2568 WARN("creating SystemLink for %s, ran out of buffer space\n", debugstr_w(name
));
2569 HeapFree(GetProcessHeap(), 0, fileW
);
2572 strcpyW(data
, fileW
);
2573 strcatW(data
, comma
);
2574 strcatW(data
, value
);
2576 TRACE("added SystemLink for %s to %s in %s\n", debugstr_w(name
), debugstr_w(value
),debugstr_w(fileW
));
2577 HeapFree(GetProcessHeap(), 0, fileW
);
2583 RegSetValueExW(hkey
, name
, 0, REG_MULTI_SZ
, (BYTE
*)buff
, (data
-buff
) * sizeof(WCHAR
));
2585 TRACE("no SystemLink fonts found for %s\n", debugstr_w(name
));
2587 TRACE("removed SystemLink for %s\n", debugstr_w(name
));
2590 static void update_system_links(void)
2598 static const WCHAR MS_Shell_Dlg
[] = {'M','S',' ','S','h','e','l','l',' ','D','l','g',0};
2600 if (!RegCreateKeyExW(HKEY_LOCAL_MACHINE
, system_link
, 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &hkey
, &disposition
))
2602 if (disposition
== REG_OPENED_EXISTING_KEY
)
2604 TRACE("SystemLink key already exists, doing nothing\n");
2609 psub
= get_font_subst(&font_subst_list
, MS_Shell_Dlg
, -1);
2611 WARN("could not find FontSubstitute for MS Shell Dlg\n");
2616 for (i
= 0; i
< sizeof(font_links_defaults_list
)/sizeof(font_links_defaults_list
[0]); i
++)
2618 if (!strcmpiW(font_links_defaults_list
[i
].shelldlg
, psub
->to
.name
))
2620 for (j
= 0; j
< sizeof(font_links_list
)/sizeof(font_links_list
[0]); j
++)
2621 populate_system_links(hkey
, font_links_list
[j
], font_links_defaults_list
[i
].substitutes
);
2623 if (!strcmpiW(psub
->to
.name
, font_links_defaults_list
[i
].substitutes
[0]))
2624 populate_system_links(hkey
, psub
->to
.name
, font_links_defaults_list
[i
].substitutes
);
2627 else if (strcmpiW(psub
->to
.name
, font_links_defaults_list
[i
].substitutes
[0]))
2629 populate_system_links(hkey
, font_links_defaults_list
[i
].substitutes
[0], NULL
);
2634 WARN("there is no SystemLink default list for MS Shell Dlg %s\n", debugstr_w(psub
->to
.name
));
2636 WARN("failed to create SystemLink key\n");
2640 static BOOL
init_freetype(void)
2642 ft_handle
= wine_dlopen(SONAME_LIBFREETYPE
, RTLD_NOW
, NULL
, 0);
2645 "Wine cannot find the FreeType font library. To enable Wine to\n"
2646 "use TrueType fonts please install a version of FreeType greater than\n"
2647 "or equal to 2.0.5.\n"
2648 "http://www.freetype.org\n");
2652 #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;}
2654 LOAD_FUNCPTR(FT_Vector_Unit
)
2655 LOAD_FUNCPTR(FT_Done_Face
)
2656 LOAD_FUNCPTR(FT_Get_Char_Index
)
2657 LOAD_FUNCPTR(FT_Get_Module
)
2658 LOAD_FUNCPTR(FT_Get_Sfnt_Name
)
2659 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count
)
2660 LOAD_FUNCPTR(FT_Get_Sfnt_Table
)
2661 LOAD_FUNCPTR(FT_Init_FreeType
)
2662 LOAD_FUNCPTR(FT_Load_Glyph
)
2663 LOAD_FUNCPTR(FT_Matrix_Multiply
)
2664 #ifndef FT_MULFIX_INLINED
2665 LOAD_FUNCPTR(FT_MulFix
)
2667 LOAD_FUNCPTR(FT_New_Face
)
2668 LOAD_FUNCPTR(FT_New_Memory_Face
)
2669 LOAD_FUNCPTR(FT_Outline_Get_Bitmap
)
2670 LOAD_FUNCPTR(FT_Outline_Transform
)
2671 LOAD_FUNCPTR(FT_Outline_Translate
)
2672 LOAD_FUNCPTR(FT_Select_Charmap
)
2673 LOAD_FUNCPTR(FT_Set_Charmap
)
2674 LOAD_FUNCPTR(FT_Set_Pixel_Sizes
)
2675 LOAD_FUNCPTR(FT_Vector_Transform
)
2676 LOAD_FUNCPTR(FT_Render_Glyph
)
2679 /* Don't warn if these ones are missing */
2680 pFT_Library_Version
= wine_dlsym(ft_handle
, "FT_Library_Version", NULL
, 0);
2681 pFT_Load_Sfnt_Table
= wine_dlsym(ft_handle
, "FT_Load_Sfnt_Table", NULL
, 0);
2682 pFT_Get_First_Char
= wine_dlsym(ft_handle
, "FT_Get_First_Char", NULL
, 0);
2683 pFT_Get_Next_Char
= wine_dlsym(ft_handle
, "FT_Get_Next_Char", NULL
, 0);
2684 pFT_Get_TrueType_Engine_Type
= wine_dlsym(ft_handle
, "FT_Get_TrueType_Engine_Type", NULL
, 0);
2685 #ifdef HAVE_FREETYPE_FTLCDFIL_H
2686 pFT_Library_SetLcdFilter
= wine_dlsym(ft_handle
, "FT_Library_SetLcdFilter", NULL
, 0);
2688 #ifdef HAVE_FREETYPE_FTWINFNT_H
2689 pFT_Get_WinFNT_Header
= wine_dlsym(ft_handle
, "FT_Get_WinFNT_Header", NULL
, 0);
2691 if(!wine_dlsym(ft_handle
, "FT_Get_Postscript_Name", NULL
, 0) &&
2692 !wine_dlsym(ft_handle
, "FT_Sqrt64", NULL
, 0)) {
2693 /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
2694 <= 2.0.3 has FT_Sqrt64 */
2698 if(pFT_Init_FreeType(&library
) != 0) {
2699 ERR("Can't init FreeType library\n");
2700 wine_dlclose(ft_handle
, NULL
, 0);
2704 FT_Version
.major
= FT_Version
.minor
= FT_Version
.patch
= -1;
2705 if (pFT_Library_Version
)
2706 pFT_Library_Version(library
,&FT_Version
.major
,&FT_Version
.minor
,&FT_Version
.patch
);
2708 if (FT_Version
.major
<=0)
2714 TRACE("FreeType version is %d.%d.%d\n",FT_Version
.major
,FT_Version
.minor
,FT_Version
.patch
);
2715 FT_SimpleVersion
= ((FT_Version
.major
<< 16) & 0xff0000) |
2716 ((FT_Version
.minor
<< 8) & 0x00ff00) |
2717 ((FT_Version
.patch
) & 0x0000ff);
2723 "Wine cannot find certain functions that it needs inside the FreeType\n"
2724 "font library. To enable Wine to use TrueType fonts please upgrade\n"
2725 "FreeType to at least version 2.0.5.\n"
2726 "http://www.freetype.org\n");
2727 wine_dlclose(ft_handle
, NULL
, 0);
2732 /*************************************************************
2735 * Initialize FreeType library and create a list of available faces
2737 BOOL
WineEngInit(void)
2739 static const WCHAR dot_fonW
[] = {'.','f','o','n','\0'};
2740 static const WCHAR pathW
[] = {'P','a','t','h',0};
2742 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
2743 WCHAR windowsdir
[MAX_PATH
];
2746 const char *data_dir
;
2750 /* update locale dependent font info in registry */
2753 if(!init_freetype()) return FALSE
;
2755 if((font_mutex
= CreateMutexW(NULL
, FALSE
, font_mutex_nameW
)) == NULL
) {
2756 ERR("Failed to create font mutex\n");
2759 WaitForSingleObject(font_mutex
, INFINITE
);
2761 delete_external_font_keys();
2763 /* load the system bitmap fonts */
2764 load_system_fonts();
2766 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
2767 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
2768 strcatW(windowsdir
, fontsW
);
2769 if((unixname
= wine_get_unix_file_name(windowsdir
)))
2771 ReadFontDir(unixname
, FALSE
);
2772 HeapFree(GetProcessHeap(), 0, unixname
);
2775 /* load the system truetype fonts */
2776 data_dir
= wine_get_data_dir();
2777 if (!data_dir
) data_dir
= wine_get_build_dir();
2778 if (data_dir
&& (unixname
= HeapAlloc(GetProcessHeap(), 0, strlen(data_dir
) + sizeof("/fonts/")))) {
2779 strcpy(unixname
, data_dir
);
2780 strcat(unixname
, "/fonts/");
2781 ReadFontDir(unixname
, TRUE
);
2782 HeapFree(GetProcessHeap(), 0, unixname
);
2785 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
2786 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
2787 full path as the entry. Also look for any .fon fonts, since ReadFontDir
2789 if(RegOpenKeyW(HKEY_LOCAL_MACHINE
,
2790 is_win9x() ? win9x_font_reg_key
: winnt_font_reg_key
,
2791 &hkey
) == ERROR_SUCCESS
) {
2792 LPWSTR data
, valueW
;
2793 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2794 &valuelen
, &datalen
, NULL
, NULL
);
2796 valuelen
++; /* returned value doesn't include room for '\0' */
2797 valueW
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
2798 data
= HeapAlloc(GetProcessHeap(), 0, datalen
* sizeof(WCHAR
));
2801 dlen
= datalen
* sizeof(WCHAR
);
2803 while(RegEnumValueW(hkey
, i
++, valueW
, &vlen
, NULL
, &type
, (LPBYTE
)data
,
2804 &dlen
) == ERROR_SUCCESS
) {
2805 if(data
[0] && (data
[1] == ':'))
2807 if((unixname
= wine_get_unix_file_name(data
)))
2809 AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2810 HeapFree(GetProcessHeap(), 0, unixname
);
2813 else if(dlen
/ 2 >= 6 && !strcmpiW(data
+ dlen
/ 2 - 5, dot_fonW
))
2815 WCHAR pathW
[MAX_PATH
];
2816 static const WCHAR fmtW
[] = {'%','s','\\','%','s','\0'};
2819 sprintfW(pathW
, fmtW
, windowsdir
, data
);
2820 if((unixname
= wine_get_unix_file_name(pathW
)))
2822 added
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2823 HeapFree(GetProcessHeap(), 0, unixname
);
2826 load_font_from_data_dir(data
);
2828 /* reset dlen and vlen */
2833 HeapFree(GetProcessHeap(), 0, data
);
2834 HeapFree(GetProcessHeap(), 0, valueW
);
2838 load_fontconfig_fonts();
2840 /* then look in any directories that we've specified in the config file */
2841 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
2842 if(RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts", &hkey
) == ERROR_SUCCESS
)
2848 if (RegQueryValueExW( hkey
, pathW
, NULL
, NULL
, NULL
, &len
) == ERROR_SUCCESS
)
2850 len
+= sizeof(WCHAR
);
2851 valueW
= HeapAlloc( GetProcessHeap(), 0, len
);
2852 if (RegQueryValueExW( hkey
, pathW
, NULL
, NULL
, (LPBYTE
)valueW
, &len
) == ERROR_SUCCESS
)
2854 len
= WideCharToMultiByte( CP_UNIXCP
, 0, valueW
, -1, NULL
, 0, NULL
, NULL
);
2855 valueA
= HeapAlloc( GetProcessHeap(), 0, len
);
2856 WideCharToMultiByte( CP_UNIXCP
, 0, valueW
, -1, valueA
, len
, NULL
, NULL
);
2857 TRACE( "got font path %s\n", debugstr_a(valueA
) );
2861 LPSTR next
= strchr( ptr
, ':' );
2862 if (next
) *next
++ = 0;
2863 ReadFontDir( ptr
, TRUE
);
2866 HeapFree( GetProcessHeap(), 0, valueA
);
2868 HeapFree( GetProcessHeap(), 0, valueW
);
2877 update_reg_entries();
2879 update_system_links();
2880 init_system_links();
2882 ReleaseMutex(font_mutex
);
2887 static LONG
calc_ppem_for_height(FT_Face ft_face
, LONG height
)
2890 TT_HoriHeader
*pHori
;
2894 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
2895 pHori
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
);
2897 if(height
== 0) height
= 16;
2899 /* Calc. height of EM square:
2901 * For +ve lfHeight we have
2902 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
2903 * Re-arranging gives:
2904 * ppem = units_per_em * lfheight / (winAscent + winDescent)
2906 * For -ve lfHeight we have
2908 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
2909 * with il = winAscent + winDescent - units_per_em]
2914 if(pOS2
->usWinAscent
+ pOS2
->usWinDescent
== 0)
2915 ppem
= MulDiv(ft_face
->units_per_EM
, height
,
2916 pHori
->Ascender
- pHori
->Descender
);
2918 ppem
= MulDiv(ft_face
->units_per_EM
, height
,
2919 pOS2
->usWinAscent
+ pOS2
->usWinDescent
);
2927 static struct font_mapping
*map_font_file( const char *name
)
2929 struct font_mapping
*mapping
;
2933 if ((fd
= open( name
, O_RDONLY
)) == -1) return NULL
;
2934 if (fstat( fd
, &st
) == -1) goto error
;
2936 LIST_FOR_EACH_ENTRY( mapping
, &mappings_list
, struct font_mapping
, entry
)
2938 if (mapping
->dev
== st
.st_dev
&& mapping
->ino
== st
.st_ino
)
2940 mapping
->refcount
++;
2945 if (!(mapping
= HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping
) )))
2948 mapping
->data
= mmap( NULL
, st
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0 );
2951 if (mapping
->data
== MAP_FAILED
)
2953 HeapFree( GetProcessHeap(), 0, mapping
);
2956 mapping
->refcount
= 1;
2957 mapping
->dev
= st
.st_dev
;
2958 mapping
->ino
= st
.st_ino
;
2959 mapping
->size
= st
.st_size
;
2960 list_add_tail( &mappings_list
, &mapping
->entry
);
2968 static void unmap_font_file( struct font_mapping
*mapping
)
2970 if (!--mapping
->refcount
)
2972 list_remove( &mapping
->entry
);
2973 munmap( mapping
->data
, mapping
->size
);
2974 HeapFree( GetProcessHeap(), 0, mapping
);
2978 static LONG
load_VDMX(GdiFont
*, LONG
);
2980 static FT_Face
OpenFontFace(GdiFont
*font
, Face
*face
, LONG width
, LONG height
)
2987 TRACE("%s/%p, %ld, %d x %d\n", debugstr_a(face
->file
), face
->font_data_ptr
, face
->face_index
, width
, height
);
2991 if (!(font
->mapping
= map_font_file( face
->file
)))
2993 WARN("failed to map %s\n", debugstr_a(face
->file
));
2996 data_ptr
= font
->mapping
->data
;
2997 data_size
= font
->mapping
->size
;
3001 data_ptr
= face
->font_data_ptr
;
3002 data_size
= face
->font_data_size
;
3005 err
= pFT_New_Memory_Face(library
, data_ptr
, data_size
, face
->face_index
, &ft_face
);
3007 ERR("FT_New_Face rets %d\n", err
);
3011 /* set it here, as load_VDMX needs it */
3012 font
->ft_face
= ft_face
;
3014 if(FT_IS_SCALABLE(ft_face
)) {
3015 /* load the VDMX table if we have one */
3016 font
->ppem
= load_VDMX(font
, height
);
3018 font
->ppem
= calc_ppem_for_height(ft_face
, height
);
3019 TRACE("height %d => ppem %d\n", height
, font
->ppem
);
3021 if((err
= pFT_Set_Pixel_Sizes(ft_face
, 0, font
->ppem
)) != 0)
3022 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font
->ppem
, err
);
3024 font
->ppem
= height
;
3025 if((err
= pFT_Set_Pixel_Sizes(ft_face
, width
, height
)) != 0)
3026 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width
, height
, err
);
3032 static int get_nearest_charset(Face
*face
, int *cp
)
3034 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
3035 a single face with the requested charset. The idea is to check if
3036 the selected font supports the current ANSI codepage, if it does
3037 return the corresponding charset, else return the first charset */
3040 int acp
= GetACP(), i
;
3044 if(TranslateCharsetInfo((DWORD
*)(INT_PTR
)acp
, &csi
, TCI_SRCCODEPAGE
))
3045 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]))
3046 return csi
.ciCharset
;
3048 for(i
= 0; i
< 32; i
++) {
3050 if(face
->fs
.fsCsb
[0] & fs0
) {
3051 if(TranslateCharsetInfo(&fs0
, &csi
, TCI_SRCFONTSIG
)) {
3053 return csi
.ciCharset
;
3056 FIXME("TCI failing on %x\n", fs0
);
3060 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
3061 face
->fs
.fsCsb
[0], face
->file
);
3063 return DEFAULT_CHARSET
;
3066 static GdiFont
*alloc_font(void)
3068 GdiFont
*ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*ret
));
3070 ret
->gm
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(GM
*));
3071 ret
->gm
[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(GM
) * GM_BLOCK_SIZE
);
3073 ret
->font_desc
.matrix
.eM11
= ret
->font_desc
.matrix
.eM22
= 1.0;
3074 ret
->total_kern_pairs
= (DWORD
)-1;
3075 ret
->kern_pairs
= NULL
;
3076 list_init(&ret
->hfontlist
);
3077 list_init(&ret
->child_fonts
);
3081 static void free_font(GdiFont
*font
)
3083 struct list
*cursor
, *cursor2
;
3086 LIST_FOR_EACH_SAFE(cursor
, cursor2
, &font
->child_fonts
)
3088 CHILD_FONT
*child
= LIST_ENTRY(cursor
, CHILD_FONT
, entry
);
3089 struct list
*first_hfont
;
3090 HFONTLIST
*hfontlist
;
3091 list_remove(cursor
);
3094 first_hfont
= list_head(&child
->font
->hfontlist
);
3095 hfontlist
= LIST_ENTRY(first_hfont
, HFONTLIST
, entry
);
3096 DeleteObject(hfontlist
->hfont
);
3097 HeapFree(GetProcessHeap(), 0, hfontlist
);
3098 free_font(child
->font
);
3100 HeapFree(GetProcessHeap(), 0, child
);
3103 if (font
->ft_face
) pFT_Done_Face(font
->ft_face
);
3104 if (font
->mapping
) unmap_font_file( font
->mapping
);
3105 HeapFree(GetProcessHeap(), 0, font
->kern_pairs
);
3106 HeapFree(GetProcessHeap(), 0, font
->potm
);
3107 HeapFree(GetProcessHeap(), 0, font
->name
);
3108 for (i
= 0; i
< font
->gmsize
; i
++)
3109 HeapFree(GetProcessHeap(),0,font
->gm
[i
]);
3110 HeapFree(GetProcessHeap(), 0, font
->gm
);
3111 HeapFree(GetProcessHeap(), 0, font
->GSUB_Table
);
3112 HeapFree(GetProcessHeap(), 0, font
);
3116 /*************************************************************
3119 * load the vdmx entry for the specified height
3122 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
3123 ( ( (FT_ULong)_x4 << 24 ) | \
3124 ( (FT_ULong)_x3 << 16 ) | \
3125 ( (FT_ULong)_x2 << 8 ) | \
3128 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
3143 static LONG
load_VDMX(GdiFont
*font
, LONG height
)
3147 BYTE devXRatio
, devYRatio
;
3148 USHORT numRecs
, numRatios
;
3149 DWORD result
, offset
= -1;
3153 result
= WineEngGetFontData(font
, MS_VDMX_TAG
, 0, hdr
, 6);
3155 if(result
== GDI_ERROR
) /* no vdmx table present, use linear scaling */
3158 /* FIXME: need the real device aspect ratio */
3162 numRecs
= GET_BE_WORD(hdr
[1]);
3163 numRatios
= GET_BE_WORD(hdr
[2]);
3165 TRACE("numRecs = %d numRatios = %d\n", numRecs
, numRatios
);
3166 for(i
= 0; i
< numRatios
; i
++) {
3169 offset
= (3 * 2) + (i
* sizeof(Ratios
));
3170 WineEngGetFontData(font
, MS_VDMX_TAG
, offset
, &ratio
, sizeof(Ratios
));
3173 TRACE("Ratios[%d] %d %d : %d -> %d\n", i
, ratio
.bCharSet
, ratio
.xRatio
, ratio
.yStartRatio
, ratio
.yEndRatio
);
3175 if((ratio
.xRatio
== 0 &&
3176 ratio
.yStartRatio
== 0 &&
3177 ratio
.yEndRatio
== 0) ||
3178 (devXRatio
== ratio
.xRatio
&&
3179 devYRatio
>= ratio
.yStartRatio
&&
3180 devYRatio
<= ratio
.yEndRatio
))
3182 offset
= (3 * 2) + (numRatios
* 4) + (i
* 2);
3183 WineEngGetFontData(font
, MS_VDMX_TAG
, offset
, &tmp
, 2);
3184 offset
= GET_BE_WORD(tmp
);
3190 FIXME("No suitable ratio found\n");
3194 if(WineEngGetFontData(font
, MS_VDMX_TAG
, offset
, &group
, 4) != GDI_ERROR
) {
3196 BYTE startsz
, endsz
;
3199 recs
= GET_BE_WORD(group
.recs
);
3200 startsz
= group
.startsz
;
3201 endsz
= group
.endsz
;
3203 TRACE("recs=%d startsz=%d endsz=%d\n", recs
, startsz
, endsz
);
3205 vTable
= HeapAlloc(GetProcessHeap(), 0, recs
* 6);
3206 result
= WineEngGetFontData(font
, MS_VDMX_TAG
, offset
+ 4, vTable
, recs
* 6);
3207 if(result
== GDI_ERROR
) {
3208 FIXME("Failed to retrieve vTable\n");
3213 for(i
= 0; i
< recs
; i
++) {
3214 SHORT yMax
= GET_BE_WORD(vTable
[(i
* 3) + 1]);
3215 SHORT yMin
= GET_BE_WORD(vTable
[(i
* 3) + 2]);
3216 ppem
= GET_BE_WORD(vTable
[i
* 3]);
3218 if(yMax
+ -yMin
== height
) {
3221 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem
, height
, font
->yMax
, font
->yMin
);
3224 if(yMax
+ -yMin
> height
) {
3227 goto end
; /* failed */
3229 font
->yMax
= GET_BE_WORD(vTable
[(i
* 3) + 1]);
3230 font
->yMin
= GET_BE_WORD(vTable
[(i
* 3) + 2]);
3231 ppem
= GET_BE_WORD(vTable
[i
* 3]);
3232 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem
, height
, font
->yMax
, font
->yMin
);
3238 TRACE("ppem not found for height %d\n", height
);
3242 if(ppem
< startsz
|| ppem
> endsz
)
3245 for(i
= 0; i
< recs
; i
++) {
3247 yPelHeight
= GET_BE_WORD(vTable
[i
* 3]);
3249 if(yPelHeight
> ppem
)
3252 if(yPelHeight
== ppem
) {
3253 font
->yMax
= GET_BE_WORD(vTable
[(i
* 3) + 1]);
3254 font
->yMin
= GET_BE_WORD(vTable
[(i
* 3) + 2]);
3255 TRACE("ppem %d found; yMax=%d yMin=%d\n", ppem
, font
->yMax
, font
->yMin
);
3261 HeapFree(GetProcessHeap(), 0, vTable
);
3267 static BOOL
fontcmp(const GdiFont
*font
, FONT_DESC
*fd
)
3269 if(font
->font_desc
.hash
!= fd
->hash
) return TRUE
;
3270 if(memcmp(&font
->font_desc
.matrix
, &fd
->matrix
, sizeof(fd
->matrix
))) return TRUE
;
3271 if(memcmp(&font
->font_desc
.lf
, &fd
->lf
, offsetof(LOGFONTW
, lfFaceName
))) return TRUE
;
3272 if(!font
->font_desc
.can_use_bitmap
!= !fd
->can_use_bitmap
) return TRUE
;
3273 return strcmpiW(font
->font_desc
.lf
.lfFaceName
, fd
->lf
.lfFaceName
);
3276 static void calc_hash(FONT_DESC
*pfd
)
3278 DWORD hash
= 0, *ptr
, two_chars
;
3282 for(i
= 0, ptr
= (DWORD
*)&pfd
->matrix
; i
< sizeof(FMAT2
)/sizeof(DWORD
); i
++, ptr
++)
3284 for(i
= 0, ptr
= (DWORD
*)&pfd
->lf
; i
< 7; i
++, ptr
++)
3286 for(i
= 0, ptr
= (DWORD
*)pfd
->lf
.lfFaceName
; i
< LF_FACESIZE
/2; i
++, ptr
++) {
3288 pwc
= (WCHAR
*)&two_chars
;
3290 *pwc
= toupperW(*pwc
);
3292 *pwc
= toupperW(*pwc
);
3296 hash
^= !pfd
->can_use_bitmap
;
3301 static GdiFont
*find_in_cache(HFONT hfont
, const LOGFONTW
*plf
, const FMAT2
*pmat
, BOOL can_use_bitmap
)
3306 struct list
*font_elem_ptr
, *hfontlist_elem_ptr
;
3310 fd
.can_use_bitmap
= can_use_bitmap
;
3313 /* try the child list */
3314 LIST_FOR_EACH(font_elem_ptr
, &child_font_list
) {
3315 ret
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3316 if(!fontcmp(ret
, &fd
)) {
3317 if(!can_use_bitmap
&& !FT_IS_SCALABLE(ret
->ft_face
)) continue;
3318 LIST_FOR_EACH(hfontlist_elem_ptr
, &ret
->hfontlist
) {
3319 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
3320 if(hflist
->hfont
== hfont
)
3326 /* try the in-use list */
3327 LIST_FOR_EACH(font_elem_ptr
, &gdi_font_list
) {
3328 ret
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3329 if(!fontcmp(ret
, &fd
)) {
3330 if(!can_use_bitmap
&& !FT_IS_SCALABLE(ret
->ft_face
)) continue;
3331 LIST_FOR_EACH(hfontlist_elem_ptr
, &ret
->hfontlist
) {
3332 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
3333 if(hflist
->hfont
== hfont
)
3336 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3337 hflist
->hfont
= hfont
;
3338 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3343 /* then the unused list */
3344 font_elem_ptr
= list_head(&unused_gdi_font_list
);
3345 while(font_elem_ptr
) {
3346 ret
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3347 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
3348 if(!fontcmp(ret
, &fd
)) {
3349 if(!can_use_bitmap
&& !FT_IS_SCALABLE(ret
->ft_face
)) continue;
3350 assert(list_empty(&ret
->hfontlist
));
3351 TRACE("Found %p in unused list\n", ret
);
3352 list_remove(&ret
->entry
);
3353 list_add_head(&gdi_font_list
, &ret
->entry
);
3354 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3355 hflist
->hfont
= hfont
;
3356 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3363 static void add_to_cache(GdiFont
*font
)
3365 static DWORD cache_num
= 1;
3367 font
->cache_num
= cache_num
++;
3368 list_add_head(&gdi_font_list
, &font
->entry
);
3371 /*************************************************************
3372 * create_child_font_list
3374 static BOOL
create_child_font_list(GdiFont
*font
)
3377 SYSTEM_LINKS
*font_link
;
3378 CHILD_FONT
*font_link_entry
, *new_child
;
3382 psub
= get_font_subst(&font_subst_list
, font
->name
, -1);
3383 font_name
= psub
? psub
->to
.name
: font
->name
;
3384 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3386 if(!strcmpiW(font_link
->font_name
, font_name
))
3388 TRACE("found entry in system list\n");
3389 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3391 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
3392 new_child
->face
= font_link_entry
->face
;
3393 new_child
->font
= NULL
;
3394 list_add_tail(&font
->child_fonts
, &new_child
->entry
);
3395 TRACE("font %s %ld\n", debugstr_a(new_child
->face
->file
), new_child
->face
->face_index
);
3402 * if not SYMBOL or OEM then we also get all the fonts for Microsoft
3403 * Sans Serif. This is how asian windows get default fallbacks for fonts
3405 if (use_default_fallback
&& font
->charset
!= SYMBOL_CHARSET
&&
3406 font
->charset
!= OEM_CHARSET
&&
3407 strcmpiW(font_name
,szDefaultFallbackLink
) != 0)
3408 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3410 if(!strcmpiW(font_link
->font_name
,szDefaultFallbackLink
))
3412 TRACE("found entry in default fallback list\n");
3413 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3415 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
3416 new_child
->face
= font_link_entry
->face
;
3417 new_child
->font
= NULL
;
3418 list_add_tail(&font
->child_fonts
, &new_child
->entry
);
3419 TRACE("font %s %ld\n", debugstr_a(new_child
->face
->file
), new_child
->face
->face_index
);
3429 static BOOL
select_charmap(FT_Face ft_face
, FT_Encoding encoding
)
3431 FT_Error ft_err
= FT_Err_Invalid_CharMap_Handle
;
3433 if (pFT_Set_Charmap
)
3436 FT_CharMap cmap0
, cmap1
, cmap2
, cmap3
, cmap_def
;
3438 cmap0
= cmap1
= cmap2
= cmap3
= cmap_def
= NULL
;
3440 for (i
= 0; i
< ft_face
->num_charmaps
; i
++)
3442 if (ft_face
->charmaps
[i
]->encoding
== encoding
)
3444 TRACE("found cmap with platform_id %u, encoding_id %u\n",
3445 ft_face
->charmaps
[i
]->platform_id
, ft_face
->charmaps
[i
]->encoding_id
);
3447 switch (ft_face
->charmaps
[i
]->platform_id
)
3450 cmap_def
= ft_face
->charmaps
[i
];
3452 case 0: /* Apple Unicode */
3453 cmap0
= ft_face
->charmaps
[i
];
3455 case 1: /* Macintosh */
3456 cmap1
= ft_face
->charmaps
[i
];
3459 cmap2
= ft_face
->charmaps
[i
];
3461 case 3: /* Microsoft */
3462 cmap3
= ft_face
->charmaps
[i
];
3467 if (cmap3
) /* prefer Microsoft cmap table */
3468 ft_err
= pFT_Set_Charmap(ft_face
, cmap3
);
3470 ft_err
= pFT_Set_Charmap(ft_face
, cmap1
);
3472 ft_err
= pFT_Set_Charmap(ft_face
, cmap2
);
3474 ft_err
= pFT_Set_Charmap(ft_face
, cmap0
);
3476 ft_err
= pFT_Set_Charmap(ft_face
, cmap_def
);
3478 return ft_err
== FT_Err_Ok
;
3481 return pFT_Select_Charmap(ft_face
, encoding
) == FT_Err_Ok
;
3484 /*************************************************************
3485 * WineEngCreateFontInstance
3488 GdiFont
*WineEngCreateFontInstance(DC
*dc
, HFONT hfont
)
3491 Face
*face
, *best
, *best_bitmap
;
3492 Family
*family
, *last_resort_family
;
3493 struct list
*family_elem_ptr
, *face_elem_ptr
;
3494 INT height
, width
= 0;
3495 unsigned int score
= 0, new_score
;
3496 signed int diff
= 0, newdiff
;
3497 BOOL bd
, it
, can_use_bitmap
;
3502 FontSubst
*psub
= NULL
;
3504 if (!GetObjectW( hfont
, sizeof(lf
), &lf
)) return NULL
;
3505 lf
.lfWidth
= abs(lf
.lfWidth
);
3507 can_use_bitmap
= GetDeviceCaps(dc
->hSelf
, TEXTCAPS
) & TC_RA_ABLE
;
3509 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
3510 debugstr_w(lf
.lfFaceName
), lf
.lfHeight
, lf
.lfItalic
,
3511 lf
.lfWeight
, lf
.lfPitchAndFamily
, lf
.lfCharSet
, lf
.lfOrientation
,
3514 if(dc
->GraphicsMode
== GM_ADVANCED
)
3515 memcpy(&dcmat
, &dc
->xformWorld2Vport
, sizeof(FMAT2
));
3518 /* Windows 3.1 compatibility mode GM_COMPATIBLE has only limited
3519 font scaling abilities. */
3520 dcmat
.eM11
= dcmat
.eM22
= dc
->vport2WorldValid
? fabs(dc
->xformWorld2Vport
.eM22
) : 1.0;
3521 dcmat
.eM21
= dcmat
.eM12
= 0;
3524 /* Try to avoid not necessary glyph transformations */
3525 if (dcmat
.eM21
== 0.0 && dcmat
.eM12
== 0.0 && dcmat
.eM11
== dcmat
.eM22
)
3527 lf
.lfHeight
*= fabs(dcmat
.eM11
);
3528 lf
.lfWidth
*= fabs(dcmat
.eM11
);
3529 dcmat
.eM11
= dcmat
.eM22
= 1.0;
3532 TRACE("DC transform %f %f %f %f\n", dcmat
.eM11
, dcmat
.eM12
,
3533 dcmat
.eM21
, dcmat
.eM22
);
3536 EnterCriticalSection( &freetype_cs
);
3538 /* check the cache first */
3539 if((ret
= find_in_cache(hfont
, &lf
, &dcmat
, can_use_bitmap
)) != NULL
) {
3540 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret
, hfont
);
3541 LeaveCriticalSection( &freetype_cs
);
3545 TRACE("not in cache\n");
3546 if(list_empty(&font_list
)) /* No fonts installed */
3548 TRACE("No fonts installed\n");
3549 LeaveCriticalSection( &freetype_cs
);
3552 if(!have_installed_roman_font
)
3554 TRACE("No roman font installed\n");
3555 LeaveCriticalSection( &freetype_cs
);
3561 ret
->font_desc
.matrix
= dcmat
;
3562 ret
->font_desc
.lf
= lf
;
3563 ret
->font_desc
.can_use_bitmap
= can_use_bitmap
;
3564 calc_hash(&ret
->font_desc
);
3565 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3566 hflist
->hfont
= hfont
;
3567 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3569 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
3570 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
3571 original value lfCharSet. Note this is a special case for
3572 Symbol and doesn't happen at least for "Wingdings*" */
3574 if(!strcmpiW(lf
.lfFaceName
, SymbolW
))
3575 lf
.lfCharSet
= SYMBOL_CHARSET
;
3577 if(!TranslateCharsetInfo((DWORD
*)(INT_PTR
)lf
.lfCharSet
, &csi
, TCI_SRCCHARSET
)) {
3578 switch(lf
.lfCharSet
) {
3579 case DEFAULT_CHARSET
:
3580 csi
.fs
.fsCsb
[0] = 0;
3583 FIXME("Untranslated charset %d\n", lf
.lfCharSet
);
3584 csi
.fs
.fsCsb
[0] = 0;
3590 if(lf
.lfFaceName
[0] != '\0') {
3591 SYSTEM_LINKS
*font_link
;
3592 CHILD_FONT
*font_link_entry
;
3593 LPWSTR FaceName
= lf
.lfFaceName
;
3596 * Check for a leading '@' this signals that the font is being
3597 * requested in tategaki mode (vertical writing substitution) but
3598 * does not affect the fontface that is to be selected.
3600 if (lf
.lfFaceName
[0]=='@')
3601 FaceName
= &lf
.lfFaceName
[1];
3603 psub
= get_font_subst(&font_subst_list
, FaceName
, lf
.lfCharSet
);
3606 TRACE("substituting %s,%d -> %s,%d\n", debugstr_w(FaceName
), lf
.lfCharSet
,
3607 debugstr_w(psub
->to
.name
), (psub
->to
.charset
!= -1) ? psub
->to
.charset
: lf
.lfCharSet
);
3608 if (psub
->to
.charset
!= -1)
3609 lf
.lfCharSet
= psub
->to
.charset
;
3612 /* We want a match on name and charset or just name if
3613 charset was DEFAULT_CHARSET. If the latter then
3614 we fixup the returned charset later in get_nearest_charset
3615 where we'll either use the charset of the current ansi codepage
3616 or if that's unavailable the first charset that the font supports.
3618 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3619 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3620 if (!strcmpiW(family
->FamilyName
, FaceName
) ||
3621 (psub
&& !strcmpiW(family
->FamilyName
, psub
->to
.name
)))
3623 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3624 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3625 if((csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) || !csi
.fs
.fsCsb
[0])
3626 if(face
->scalable
|| can_use_bitmap
)
3633 * Try check the SystemLink list first for a replacement font.
3634 * We may find good replacements there.
3636 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3638 if(!strcmpiW(font_link
->font_name
, FaceName
) ||
3639 (psub
&& !strcmpiW(font_link
->font_name
,psub
->to
.name
)))
3641 TRACE("found entry in system list\n");
3642 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3644 face
= font_link_entry
->face
;
3645 family
= face
->family
;
3646 if(csi
.fs
.fsCsb
[0] &
3647 (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]) || !csi
.fs
.fsCsb
[0])
3649 if(face
->scalable
|| can_use_bitmap
)
3657 psub
= NULL
; /* substitution is no more relevant */
3659 /* If requested charset was DEFAULT_CHARSET then try using charset
3660 corresponding to the current ansi codepage */
3661 if (!csi
.fs
.fsCsb
[0])
3664 if(!TranslateCharsetInfo((DWORD
*)(INT_PTR
)acp
, &csi
, TCI_SRCCODEPAGE
)) {
3665 FIXME("TCI failed on codepage %d\n", acp
);
3666 csi
.fs
.fsCsb
[0] = 0;
3668 lf
.lfCharSet
= csi
.ciCharset
;
3671 /* Face families are in the top 4 bits of lfPitchAndFamily,
3672 so mask with 0xF0 before testing */
3674 if((lf
.lfPitchAndFamily
& FIXED_PITCH
) ||
3675 (lf
.lfPitchAndFamily
& 0xF0) == FF_MODERN
)
3676 strcpyW(lf
.lfFaceName
, defFixed
);
3677 else if((lf
.lfPitchAndFamily
& 0xF0) == FF_ROMAN
)
3678 strcpyW(lf
.lfFaceName
, defSerif
);
3679 else if((lf
.lfPitchAndFamily
& 0xF0) == FF_SWISS
)
3680 strcpyW(lf
.lfFaceName
, defSans
);
3682 strcpyW(lf
.lfFaceName
, defSans
);
3683 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3684 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3685 if(!strcmpiW(family
->FamilyName
, lf
.lfFaceName
)) {
3686 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3687 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3688 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]))
3689 if(face
->scalable
|| can_use_bitmap
)
3695 last_resort_family
= NULL
;
3696 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3697 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3698 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3699 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3700 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) {
3703 if(can_use_bitmap
&& !last_resort_family
)
3704 last_resort_family
= family
;
3709 if(last_resort_family
) {
3710 family
= last_resort_family
;
3711 csi
.fs
.fsCsb
[0] = 0;
3715 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3716 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3717 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3718 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3719 if(face
->scalable
) {
3720 csi
.fs
.fsCsb
[0] = 0;
3721 WARN("just using first face for now\n");
3724 if(can_use_bitmap
&& !last_resort_family
)
3725 last_resort_family
= family
;
3728 if(!last_resort_family
) {
3729 FIXME("can't find a single appropriate font - bailing\n");
3731 LeaveCriticalSection( &freetype_cs
);
3735 WARN("could only find a bitmap font - this will probably look awful!\n");
3736 family
= last_resort_family
;
3737 csi
.fs
.fsCsb
[0] = 0;
3740 it
= lf
.lfItalic
? 1 : 0;
3741 bd
= lf
.lfWeight
> 550 ? 1 : 0;
3743 height
= lf
.lfHeight
;
3745 face
= best
= best_bitmap
= NULL
;
3746 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
3748 if((csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) || !csi
.fs
.fsCsb
[0])
3752 italic
= (face
->ntmFlags
& NTM_ITALIC
) ? 1 : 0;
3753 bold
= (face
->ntmFlags
& NTM_BOLD
) ? 1 : 0;
3754 new_score
= (italic
^ it
) + (bold
^ bd
);
3755 if(!best
|| new_score
<= score
)
3757 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
3758 italic
, bold
, it
, bd
);
3761 if(best
->scalable
&& score
== 0) break;
3765 newdiff
= height
- (signed int)(best
->size
.height
);
3767 newdiff
= -height
- ((signed int)(best
->size
.height
) - best
->size
.internal_leading
);
3768 if(!best_bitmap
|| new_score
< score
||
3769 (diff
> 0 && newdiff
< diff
&& newdiff
>= 0) || (diff
< 0 && newdiff
> diff
))
3771 TRACE("%d is better for %d diff was %d\n", best
->size
.height
, height
, diff
);
3774 if(score
== 0 && diff
== 0) break;
3781 face
= best
->scalable
? best
: best_bitmap
;
3782 ret
->fake_italic
= (it
&& !(face
->ntmFlags
& NTM_ITALIC
));
3783 ret
->fake_bold
= (bd
&& !(face
->ntmFlags
& NTM_BOLD
));
3787 if(csi
.fs
.fsCsb
[0]) {
3788 ret
->charset
= lf
.lfCharSet
;
3789 ret
->codepage
= csi
.ciACP
;
3792 ret
->charset
= get_nearest_charset(face
, &ret
->codepage
);
3794 TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family
->FamilyName
),
3795 debugstr_w(face
->StyleName
), face
->file
, face
->font_data_ptr
, face
->face_index
);
3797 ret
->aveWidth
= height
? lf
.lfWidth
: 0;
3799 if(!face
->scalable
) {
3800 /* Windows uses integer scaling factors for bitmap fonts */
3801 INT scale
, scaled_height
;
3803 /* FIXME: rotation of bitmap fonts is ignored */
3804 height
= abs(GDI_ROUND( (double)height
* ret
->font_desc
.matrix
.eM22
));
3806 ret
->aveWidth
= (double)ret
->aveWidth
* ret
->font_desc
.matrix
.eM11
;
3807 ret
->font_desc
.matrix
.eM11
= ret
->font_desc
.matrix
.eM22
= 1.0;
3809 if (height
!= 0) height
= diff
;
3810 height
+= face
->size
.height
;
3812 scale
= (height
+ face
->size
.height
- 1) / face
->size
.height
;
3813 scaled_height
= scale
* face
->size
.height
;
3814 /* Only jump to the next height if the difference <= 25% original height */
3815 if (scale
> 2 && scaled_height
- height
> face
->size
.height
/ 4) scale
--;
3816 /* The jump between unscaled and doubled is delayed by 1 */
3817 else if (scale
== 2 && scaled_height
- height
> (face
->size
.height
/ 4 - 1)) scale
--;
3818 ret
->scale_y
= scale
;
3820 width
= face
->size
.x_ppem
>> 6;
3821 height
= face
->size
.y_ppem
>> 6;
3825 TRACE("font scale y: %f\n", ret
->scale_y
);
3827 ret
->ft_face
= OpenFontFace(ret
, face
, width
, height
);
3832 LeaveCriticalSection( &freetype_cs
);
3836 ret
->ntmFlags
= face
->ntmFlags
;
3838 if (ret
->charset
== SYMBOL_CHARSET
&&
3839 select_charmap(ret
->ft_face
, FT_ENCODING_MS_SYMBOL
)) {
3842 else if (select_charmap(ret
->ft_face
, FT_ENCODING_UNICODE
)) {
3846 select_charmap(ret
->ft_face
, FT_ENCODING_APPLE_ROMAN
);
3849 ret
->orientation
= FT_IS_SCALABLE(ret
->ft_face
) ? lf
.lfOrientation
: 0;
3850 ret
->name
= psub
? strdupW(psub
->from
.name
) : strdupW(family
->FamilyName
);
3851 ret
->underline
= lf
.lfUnderline
? 0xff : 0;
3852 ret
->strikeout
= lf
.lfStrikeOut
? 0xff : 0;
3853 create_child_font_list(ret
);
3855 if (lf
.lfFaceName
[0]=='@') /* We need to try to load the GSUB table */
3857 int length
= WineEngGetFontData (ret
, GSUB_TAG
, 0, NULL
, 0);
3858 if (length
!= GDI_ERROR
)
3860 ret
->GSUB_Table
= HeapAlloc(GetProcessHeap(),0,length
);
3861 WineEngGetFontData(ret
, GSUB_TAG
, 0, ret
->GSUB_Table
, length
);
3862 TRACE("Loaded GSUB table of %i bytes\n",length
);
3866 TRACE("caching: gdiFont=%p hfont=%p\n", ret
, hfont
);
3869 LeaveCriticalSection( &freetype_cs
);
3873 static void dump_gdi_font_list(void)
3876 struct list
*elem_ptr
;
3878 TRACE("---------- gdiFont Cache ----------\n");
3879 LIST_FOR_EACH(elem_ptr
, &gdi_font_list
) {
3880 gdiFont
= LIST_ENTRY(elem_ptr
, struct tagGdiFont
, entry
);
3881 TRACE("gdiFont=%p %s %d\n",
3882 gdiFont
, debugstr_w(gdiFont
->font_desc
.lf
.lfFaceName
), gdiFont
->font_desc
.lf
.lfHeight
);
3885 TRACE("---------- Unused gdiFont Cache ----------\n");
3886 LIST_FOR_EACH(elem_ptr
, &unused_gdi_font_list
) {
3887 gdiFont
= LIST_ENTRY(elem_ptr
, struct tagGdiFont
, entry
);
3888 TRACE("gdiFont=%p %s %d\n",
3889 gdiFont
, debugstr_w(gdiFont
->font_desc
.lf
.lfFaceName
), gdiFont
->font_desc
.lf
.lfHeight
);
3893 /*************************************************************
3894 * WineEngDestroyFontInstance
3896 * free the gdiFont associated with this handle
3899 BOOL
WineEngDestroyFontInstance(HFONT handle
)
3904 struct list
*font_elem_ptr
, *hfontlist_elem_ptr
;
3908 EnterCriticalSection( &freetype_cs
);
3910 LIST_FOR_EACH_ENTRY(gdiFont
, &child_font_list
, struct tagGdiFont
, entry
)
3912 struct list
*first_hfont
= list_head(&gdiFont
->hfontlist
);
3913 hflist
= LIST_ENTRY(first_hfont
, HFONTLIST
, entry
);
3914 if(hflist
->hfont
== handle
)
3916 TRACE("removing child font %p from child list\n", gdiFont
);
3917 list_remove(&gdiFont
->entry
);
3918 LeaveCriticalSection( &freetype_cs
);
3923 TRACE("destroying hfont=%p\n", handle
);
3925 dump_gdi_font_list();
3927 font_elem_ptr
= list_head(&gdi_font_list
);
3928 while(font_elem_ptr
) {
3929 gdiFont
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3930 font_elem_ptr
= list_next(&gdi_font_list
, font_elem_ptr
);
3932 hfontlist_elem_ptr
= list_head(&gdiFont
->hfontlist
);
3933 while(hfontlist_elem_ptr
) {
3934 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
3935 hfontlist_elem_ptr
= list_next(&gdiFont
->hfontlist
, hfontlist_elem_ptr
);
3936 if(hflist
->hfont
== handle
) {
3937 list_remove(&hflist
->entry
);
3938 HeapFree(GetProcessHeap(), 0, hflist
);
3942 if(list_empty(&gdiFont
->hfontlist
)) {
3943 TRACE("Moving to Unused list\n");
3944 list_remove(&gdiFont
->entry
);
3945 list_add_head(&unused_gdi_font_list
, &gdiFont
->entry
);
3950 font_elem_ptr
= list_head(&unused_gdi_font_list
);
3951 while(font_elem_ptr
&& i
++ < UNUSED_CACHE_SIZE
)
3952 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
3953 while(font_elem_ptr
) {
3954 gdiFont
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3955 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
3956 TRACE("freeing %p\n", gdiFont
);
3957 list_remove(&gdiFont
->entry
);
3960 LeaveCriticalSection( &freetype_cs
);
3964 static void GetEnumStructs(Face
*face
, LPENUMLOGFONTEXW pelf
,
3965 NEWTEXTMETRICEXW
*pntm
, LPDWORD ptype
)
3970 if (face
->cached_enum_data
)
3973 *pelf
= face
->cached_enum_data
->elf
;
3974 *pntm
= face
->cached_enum_data
->ntm
;
3975 *ptype
= face
->cached_enum_data
->type
;
3979 font
= alloc_font();
3981 if(face
->scalable
) {
3982 height
= -2048; /* 2048 is the most common em size */
3985 height
= face
->size
.y_ppem
>> 6;
3986 width
= face
->size
.x_ppem
>> 6;
3988 font
->scale_y
= 1.0;
3990 if (!(font
->ft_face
= OpenFontFace(font
, face
, width
, height
)))
3996 font
->name
= strdupW(face
->family
->FamilyName
);
3997 font
->ntmFlags
= face
->ntmFlags
;
3999 if (WineEngGetOutlineTextMetrics(font
, 0, NULL
))
4001 memcpy(&pntm
->ntmTm
, &font
->potm
->otmTextMetrics
, sizeof(TEXTMETRICW
));
4003 pntm
->ntmTm
.ntmSizeEM
= font
->potm
->otmEMSquare
;
4005 lstrcpynW(pelf
->elfLogFont
.lfFaceName
,
4006 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpFamilyName
),
4008 lstrcpynW(pelf
->elfFullName
,
4009 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpFaceName
),
4011 lstrcpynW(pelf
->elfStyle
,
4012 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpStyleName
),
4017 WineEngGetTextMetrics(font
, (TEXTMETRICW
*)&pntm
->ntmTm
);
4019 pntm
->ntmTm
.ntmSizeEM
= pntm
->ntmTm
.tmHeight
- pntm
->ntmTm
.tmInternalLeading
;
4021 lstrcpynW(pelf
->elfLogFont
.lfFaceName
, face
->family
->FamilyName
, LF_FACESIZE
);
4022 lstrcpynW(pelf
->elfFullName
, face
->family
->FamilyName
, LF_FULLFACESIZE
);
4023 lstrcpynW(pelf
->elfStyle
, face
->StyleName
, LF_FACESIZE
);
4026 pntm
->ntmTm
.ntmFlags
= face
->ntmFlags
;
4027 pntm
->ntmTm
.ntmCellHeight
= pntm
->ntmTm
.tmHeight
;
4028 pntm
->ntmTm
.ntmAvgWidth
= pntm
->ntmTm
.tmAveCharWidth
;
4029 pntm
->ntmFontSig
= face
->fs
;
4031 pelf
->elfScript
[0] = '\0'; /* This will get set in WineEngEnumFonts */
4033 pelf
->elfLogFont
.lfEscapement
= 0;
4034 pelf
->elfLogFont
.lfOrientation
= 0;
4035 pelf
->elfLogFont
.lfHeight
= pntm
->ntmTm
.tmHeight
;
4036 pelf
->elfLogFont
.lfWidth
= pntm
->ntmTm
.tmAveCharWidth
;
4037 pelf
->elfLogFont
.lfWeight
= pntm
->ntmTm
.tmWeight
;
4038 pelf
->elfLogFont
.lfItalic
= pntm
->ntmTm
.tmItalic
;
4039 pelf
->elfLogFont
.lfUnderline
= pntm
->ntmTm
.tmUnderlined
;
4040 pelf
->elfLogFont
.lfStrikeOut
= pntm
->ntmTm
.tmStruckOut
;
4041 pelf
->elfLogFont
.lfCharSet
= pntm
->ntmTm
.tmCharSet
;
4042 pelf
->elfLogFont
.lfOutPrecision
= OUT_STROKE_PRECIS
;
4043 pelf
->elfLogFont
.lfClipPrecision
= CLIP_STROKE_PRECIS
;
4044 pelf
->elfLogFont
.lfQuality
= DRAFT_QUALITY
;
4045 pelf
->elfLogFont
.lfPitchAndFamily
= (pntm
->ntmTm
.tmPitchAndFamily
& 0xf1) + 1;
4048 if (pntm
->ntmTm
.tmPitchAndFamily
& TMPF_TRUETYPE
)
4049 *ptype
|= TRUETYPE_FONTTYPE
;
4050 if (pntm
->ntmTm
.tmPitchAndFamily
& TMPF_DEVICE
)
4051 *ptype
|= DEVICE_FONTTYPE
;
4052 if(!(pntm
->ntmTm
.tmPitchAndFamily
& TMPF_VECTOR
))
4053 *ptype
|= RASTER_FONTTYPE
;
4055 face
->cached_enum_data
= HeapAlloc(GetProcessHeap(), 0, sizeof(*face
->cached_enum_data
));
4056 if (face
->cached_enum_data
)
4058 face
->cached_enum_data
->elf
= *pelf
;
4059 face
->cached_enum_data
->ntm
= *pntm
;
4060 face
->cached_enum_data
->type
= *ptype
;
4066 /*************************************************************
4070 DWORD
WineEngEnumFonts(LPLOGFONTW plf
, FONTENUMPROCW proc
, LPARAM lparam
)
4074 struct list
*family_elem_ptr
, *face_elem_ptr
;
4076 NEWTEXTMETRICEXW ntm
;
4085 lf
.lfCharSet
= DEFAULT_CHARSET
;
4086 lf
.lfPitchAndFamily
= 0;
4087 lf
.lfFaceName
[0] = 0;
4091 TRACE("facename = %s charset %d\n", debugstr_w(plf
->lfFaceName
), plf
->lfCharSet
);
4094 EnterCriticalSection( &freetype_cs
);
4095 if(plf
->lfFaceName
[0]) {
4097 psub
= get_font_subst(&font_subst_list
, plf
->lfFaceName
, plf
->lfCharSet
);
4100 TRACE("substituting %s -> %s\n", debugstr_w(plf
->lfFaceName
),
4101 debugstr_w(psub
->to
.name
));
4103 strcpyW(lf
.lfFaceName
, psub
->to
.name
);
4107 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
4108 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
4109 if(!strcmpiW(plf
->lfFaceName
, family
->FamilyName
)) {
4110 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
4111 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
4112 GetEnumStructs(face
, &elf
, &ntm
, &type
);
4113 for(i
= 0; i
< 32; i
++) {
4114 if(!face
->scalable
&& face
->fs
.fsCsb
[0] == 0) { /* OEM bitmap */
4115 elf
.elfLogFont
.lfCharSet
= ntm
.ntmTm
.tmCharSet
= OEM_CHARSET
;
4116 strcpyW(elf
.elfScript
, OEM_DOSW
);
4117 i
= 32; /* break out of loop */
4118 } else if(!(face
->fs
.fsCsb
[0] & (1L << i
)))
4121 fs
.fsCsb
[0] = 1L << i
;
4123 if(!TranslateCharsetInfo(fs
.fsCsb
, &csi
,
4125 csi
.ciCharset
= DEFAULT_CHARSET
;
4126 if(i
== 31) csi
.ciCharset
= SYMBOL_CHARSET
;
4127 if(csi
.ciCharset
!= DEFAULT_CHARSET
) {
4128 elf
.elfLogFont
.lfCharSet
=
4129 ntm
.ntmTm
.tmCharSet
= csi
.ciCharset
;
4131 strcpyW(elf
.elfScript
, ElfScriptsW
[i
]);
4133 FIXME("Unknown elfscript for bit %d\n", i
);
4136 TRACE("enuming face %s full %s style %s charset %d type %d script %s it %d weight %d ntmflags %08x\n",
4137 debugstr_w(elf
.elfLogFont
.lfFaceName
),
4138 debugstr_w(elf
.elfFullName
), debugstr_w(elf
.elfStyle
),
4139 csi
.ciCharset
, type
, debugstr_w(elf
.elfScript
),
4140 elf
.elfLogFont
.lfItalic
, elf
.elfLogFont
.lfWeight
,
4141 ntm
.ntmTm
.ntmFlags
);
4142 /* release section before callback (FIXME) */
4143 LeaveCriticalSection( &freetype_cs
);
4144 if (!proc(&elf
.elfLogFont
, (TEXTMETRICW
*)&ntm
, type
, lparam
)) return 0;
4145 EnterCriticalSection( &freetype_cs
);
4151 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
4152 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
4153 face_elem_ptr
= list_head(&family
->faces
);
4154 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
4155 GetEnumStructs(face
, &elf
, &ntm
, &type
);
4156 for(i
= 0; i
< 32; i
++) {
4157 if(!face
->scalable
&& face
->fs
.fsCsb
[0] == 0) { /* OEM bitmap */
4158 elf
.elfLogFont
.lfCharSet
= ntm
.ntmTm
.tmCharSet
= OEM_CHARSET
;
4159 strcpyW(elf
.elfScript
, OEM_DOSW
);
4160 i
= 32; /* break out of loop */
4161 } else if(!(face
->fs
.fsCsb
[0] & (1L << i
)))
4164 fs
.fsCsb
[0] = 1L << i
;
4166 if(!TranslateCharsetInfo(fs
.fsCsb
, &csi
,
4168 csi
.ciCharset
= DEFAULT_CHARSET
;
4169 if(i
== 31) csi
.ciCharset
= SYMBOL_CHARSET
;
4170 if(csi
.ciCharset
!= DEFAULT_CHARSET
) {
4171 elf
.elfLogFont
.lfCharSet
= ntm
.ntmTm
.tmCharSet
=
4174 strcpyW(elf
.elfScript
, ElfScriptsW
[i
]);
4176 FIXME("Unknown elfscript for bit %d\n", i
);
4179 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
4180 debugstr_w(elf
.elfLogFont
.lfFaceName
),
4181 debugstr_w(elf
.elfFullName
), debugstr_w(elf
.elfStyle
),
4182 csi
.ciCharset
, type
, debugstr_w(elf
.elfScript
),
4183 elf
.elfLogFont
.lfItalic
, elf
.elfLogFont
.lfWeight
,
4184 ntm
.ntmTm
.ntmFlags
);
4185 /* release section before callback (FIXME) */
4186 LeaveCriticalSection( &freetype_cs
);
4187 if (!proc(&elf
.elfLogFont
, (TEXTMETRICW
*)&ntm
, type
, lparam
)) return 0;
4188 EnterCriticalSection( &freetype_cs
);
4192 LeaveCriticalSection( &freetype_cs
);
4196 static void FTVectorToPOINTFX(FT_Vector
*vec
, POINTFX
*pt
)
4198 pt
->x
.value
= vec
->x
>> 6;
4199 pt
->x
.fract
= (vec
->x
& 0x3f) << 10;
4200 pt
->x
.fract
|= ((pt
->x
.fract
>> 6) | (pt
->x
.fract
>> 12));
4201 pt
->y
.value
= vec
->y
>> 6;
4202 pt
->y
.fract
= (vec
->y
& 0x3f) << 10;
4203 pt
->y
.fract
|= ((pt
->y
.fract
>> 6) | (pt
->y
.fract
>> 12));
4207 /***************************************************
4208 * According to the MSDN documentation on WideCharToMultiByte,
4209 * certain codepages cannot set the default_used parameter.
4210 * This returns TRUE if the codepage can set that parameter, false else
4211 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
4213 static BOOL
codepage_sets_default_used(UINT codepage
)
4227 * GSUB Table handling functions
4230 static INT
GSUB_is_glyph_covered(LPCVOID table
, UINT glyph
)
4232 const GSUB_CoverageFormat1
* cf1
;
4236 if (GET_BE_WORD(cf1
->CoverageFormat
) == 1)
4238 int count
= GET_BE_WORD(cf1
->GlyphCount
);
4240 TRACE("Coverage Format 1, %i glyphs\n",count
);
4241 for (i
= 0; i
< count
; i
++)
4242 if (glyph
== GET_BE_WORD(cf1
->GlyphArray
[i
]))
4246 else if (GET_BE_WORD(cf1
->CoverageFormat
) == 2)
4248 const GSUB_CoverageFormat2
* cf2
;
4251 cf2
= (const GSUB_CoverageFormat2
*)cf1
;
4253 count
= GET_BE_WORD(cf2
->RangeCount
);
4254 TRACE("Coverage Format 2, %i ranges\n",count
);
4255 for (i
= 0; i
< count
; i
++)
4257 if (glyph
< GET_BE_WORD(cf2
->RangeRecord
[i
].Start
))
4259 if ((glyph
>= GET_BE_WORD(cf2
->RangeRecord
[i
].Start
)) &&
4260 (glyph
<= GET_BE_WORD(cf2
->RangeRecord
[i
].End
)))
4262 return (GET_BE_WORD(cf2
->RangeRecord
[i
].StartCoverageIndex
) +
4263 glyph
- GET_BE_WORD(cf2
->RangeRecord
[i
].Start
));
4269 ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1
->CoverageFormat
));
4274 static const GSUB_Script
* GSUB_get_script_table( const GSUB_Header
* header
, const char* tag
)
4276 const GSUB_ScriptList
*script
;
4277 const GSUB_Script
*deflt
= NULL
;
4279 script
= (const GSUB_ScriptList
*)((const BYTE
*)header
+ GET_BE_WORD(header
->ScriptList
));
4281 TRACE("%i scripts in this font\n",GET_BE_WORD(script
->ScriptCount
));
4282 for (i
= 0; i
< GET_BE_WORD(script
->ScriptCount
); i
++)
4284 const GSUB_Script
*scr
;
4287 offset
= GET_BE_WORD(script
->ScriptRecord
[i
].Script
);
4288 scr
= (const GSUB_Script
*)((const BYTE
*)script
+ offset
);
4290 if (strncmp(script
->ScriptRecord
[i
].ScriptTag
, tag
,4)==0)
4292 if (strncmp(script
->ScriptRecord
[i
].ScriptTag
, "dflt",4)==0)
4298 static const GSUB_LangSys
* GSUB_get_lang_table( const GSUB_Script
* script
, const char* tag
)
4302 const GSUB_LangSys
*Lang
;
4304 TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script
->DefaultLangSys
), GET_BE_WORD(script
->LangSysCount
));
4306 for (i
= 0; i
< GET_BE_WORD(script
->LangSysCount
) ; i
++)
4308 offset
= GET_BE_WORD(script
->LangSysRecord
[i
].LangSys
);
4309 Lang
= (const GSUB_LangSys
*)((const BYTE
*)script
+ offset
);
4311 if ( strncmp(script
->LangSysRecord
[i
].LangSysTag
,tag
,4)==0)
4314 offset
= GET_BE_WORD(script
->DefaultLangSys
);
4317 Lang
= (const GSUB_LangSys
*)((const BYTE
*)script
+ offset
);
4323 static const GSUB_Feature
* GSUB_get_feature(const GSUB_Header
*header
, const GSUB_LangSys
*lang
, const char* tag
)
4326 const GSUB_FeatureList
*feature
;
4327 feature
= (const GSUB_FeatureList
*)((const BYTE
*)header
+ GET_BE_WORD(header
->FeatureList
));
4329 TRACE("%i features\n",GET_BE_WORD(lang
->FeatureCount
));
4330 for (i
= 0; i
< GET_BE_WORD(lang
->FeatureCount
); i
++)
4332 int index
= GET_BE_WORD(lang
->FeatureIndex
[i
]);
4333 if (strncmp(feature
->FeatureRecord
[index
].FeatureTag
,tag
,4)==0)
4335 const GSUB_Feature
*feat
;
4336 feat
= (const GSUB_Feature
*)((const BYTE
*)feature
+ GET_BE_WORD(feature
->FeatureRecord
[index
].Feature
));
4343 static FT_UInt
GSUB_apply_feature(const GSUB_Header
* header
, const GSUB_Feature
* feature
, UINT glyph
)
4347 const GSUB_LookupList
*lookup
;
4348 lookup
= (const GSUB_LookupList
*)((const BYTE
*)header
+ GET_BE_WORD(header
->LookupList
));
4350 TRACE("%i lookups\n", GET_BE_WORD(feature
->LookupCount
));
4351 for (i
= 0; i
< GET_BE_WORD(feature
->LookupCount
); i
++)
4353 const GSUB_LookupTable
*look
;
4354 offset
= GET_BE_WORD(lookup
->Lookup
[GET_BE_WORD(feature
->LookupListIndex
[i
])]);
4355 look
= (const GSUB_LookupTable
*)((const BYTE
*)lookup
+ offset
);
4356 TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look
->LookupType
),GET_BE_WORD(look
->LookupFlag
),GET_BE_WORD(look
->SubTableCount
));
4357 if (GET_BE_WORD(look
->LookupType
) != 1)
4358 FIXME("We only handle SubType 1\n");
4363 for (j
= 0; j
< GET_BE_WORD(look
->SubTableCount
); j
++)
4365 const GSUB_SingleSubstFormat1
*ssf1
;
4366 offset
= GET_BE_WORD(look
->SubTable
[j
]);
4367 ssf1
= (const GSUB_SingleSubstFormat1
*)((const BYTE
*)look
+offset
);
4368 if (GET_BE_WORD(ssf1
->SubstFormat
) == 1)
4370 int offset
= GET_BE_WORD(ssf1
->Coverage
);
4371 TRACE(" subtype 1, delta %i\n", GET_BE_WORD(ssf1
->DeltaGlyphID
));
4372 if (GSUB_is_glyph_covered((const BYTE
*)ssf1
+offset
, glyph
) != -1)
4374 TRACE(" Glyph 0x%x ->",glyph
);
4375 glyph
+= GET_BE_WORD(ssf1
->DeltaGlyphID
);
4376 TRACE(" 0x%x\n",glyph
);
4381 const GSUB_SingleSubstFormat2
*ssf2
;
4385 ssf2
= (const GSUB_SingleSubstFormat2
*)ssf1
;
4386 offset
= GET_BE_WORD(ssf1
->Coverage
);
4387 TRACE(" subtype 2, glyph count %i\n", GET_BE_WORD(ssf2
->GlyphCount
));
4388 index
= GSUB_is_glyph_covered((const BYTE
*)ssf2
+offset
, glyph
);
4389 TRACE(" Coverage index %i\n",index
);
4392 TRACE(" Glyph is 0x%x ->",glyph
);
4393 glyph
= GET_BE_WORD(ssf2
->Substitute
[index
]);
4394 TRACE("0x%x\n",glyph
);
4403 static const char* get_opentype_script(const GdiFont
*font
)
4406 * I am not sure if this is the correct way to generate our script tag
4409 switch (font
->charset
)
4411 case ANSI_CHARSET
: return "latn";
4412 case BALTIC_CHARSET
: return "latn"; /* ?? */
4413 case CHINESEBIG5_CHARSET
: return "hani";
4414 case EASTEUROPE_CHARSET
: return "latn"; /* ?? */
4415 case GB2312_CHARSET
: return "hani";
4416 case GREEK_CHARSET
: return "grek";
4417 case HANGUL_CHARSET
: return "hang";
4418 case RUSSIAN_CHARSET
: return "cyrl";
4419 case SHIFTJIS_CHARSET
: return "kana";
4420 case TURKISH_CHARSET
: return "latn"; /* ?? */
4421 case VIETNAMESE_CHARSET
: return "latn";
4422 case JOHAB_CHARSET
: return "latn"; /* ?? */
4423 case ARABIC_CHARSET
: return "arab";
4424 case HEBREW_CHARSET
: return "hebr";
4425 case THAI_CHARSET
: return "thai";
4426 default: return "latn";
4430 static FT_UInt
get_GSUB_vert_glyph(const GdiFont
*font
, UINT glyph
)
4432 const GSUB_Header
*header
;
4433 const GSUB_Script
*script
;
4434 const GSUB_LangSys
*language
;
4435 const GSUB_Feature
*feature
;
4437 if (!font
->GSUB_Table
)
4440 header
= font
->GSUB_Table
;
4442 script
= GSUB_get_script_table(header
, get_opentype_script(font
));
4445 TRACE("Script not found\n");
4448 language
= GSUB_get_lang_table(script
, "xxxx"); /* Need to get Lang tag */
4451 TRACE("Language not found\n");
4454 feature
= GSUB_get_feature(header
, language
, "vrt2");
4456 feature
= GSUB_get_feature(header
, language
, "vert");
4459 TRACE("vrt2/vert feature not found\n");
4462 return GSUB_apply_feature(header
, feature
, glyph
);
4465 static FT_UInt
get_glyph_index(const GdiFont
*font
, UINT glyph
)
4469 if(font
->ft_face
->charmap
->encoding
== FT_ENCODING_NONE
) {
4470 WCHAR wc
= (WCHAR
)glyph
;
4472 BOOL
*default_used_pointer
;
4475 default_used_pointer
= NULL
;
4476 default_used
= FALSE
;
4477 if (codepage_sets_default_used(font
->codepage
))
4478 default_used_pointer
= &default_used
;
4479 if(!WideCharToMultiByte(font
->codepage
, 0, &wc
, 1, &buf
, sizeof(buf
), NULL
, default_used_pointer
) || default_used
)
4482 ret
= pFT_Get_Char_Index(font
->ft_face
, (unsigned char)buf
);
4483 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph
, buf
, ret
, default_used
);
4484 return get_GSUB_vert_glyph(font
,ret
);
4487 if(font
->ft_face
->charmap
->encoding
== FT_ENCODING_MS_SYMBOL
&& glyph
< 0x100)
4488 glyph
= glyph
+ 0xf000;
4489 glyphId
= pFT_Get_Char_Index(font
->ft_face
, glyph
);
4490 return get_GSUB_vert_glyph(font
,glyphId
);
4493 /*************************************************************
4494 * WineEngGetGlyphIndices
4497 DWORD
WineEngGetGlyphIndices(GdiFont
*font
, LPCWSTR lpstr
, INT count
,
4498 LPWORD pgi
, DWORD flags
)
4501 int default_char
= -1;
4503 if (flags
& GGI_MARK_NONEXISTING_GLYPHS
) default_char
= 0xffff; /* XP would use 0x1f for bitmap fonts */
4505 for(i
= 0; i
< count
; i
++)
4507 pgi
[i
] = get_glyph_index(font
, lpstr
[i
]);
4510 if (default_char
== -1)
4512 if (FT_IS_SFNT(font
->ft_face
))
4514 TT_OS2
*pOS2
= pFT_Get_Sfnt_Table(font
->ft_face
, ft_sfnt_os2
);
4515 default_char
= (pOS2
->usDefaultChar
? get_glyph_index(font
, pOS2
->usDefaultChar
) : 0);
4520 WineEngGetTextMetrics(font
, &textm
);
4521 default_char
= textm
.tmDefaultChar
;
4524 pgi
[i
] = default_char
;
4530 static inline BOOL
is_identity_FMAT2(const FMAT2
*matrix
)
4532 static const FMAT2 identity
= { 1.0, 0.0, 0.0, 1.0 };
4533 return !memcmp(matrix
, &identity
, sizeof(FMAT2
));
4536 static inline BOOL
is_identity_MAT2(const MAT2
*matrix
)
4538 static const MAT2 identity
= { {0,1}, {0,0}, {0,0}, {0,1} };
4539 return !memcmp(matrix
, &identity
, sizeof(MAT2
));
4542 /*************************************************************
4543 * WineEngGetGlyphOutline
4545 * Behaves in exactly the same way as the win32 api GetGlyphOutline
4546 * except that the first parameter is the HWINEENGFONT of the font in
4547 * question rather than an HDC.
4550 DWORD
WineEngGetGlyphOutline(GdiFont
*incoming_font
, UINT glyph
, UINT format
,
4551 LPGLYPHMETRICS lpgm
, DWORD buflen
, LPVOID buf
,
4554 static const FT_Matrix identityMat
= {(1 << 16), 0, 0, (1 << 16)};
4555 FT_Face ft_face
= incoming_font
->ft_face
;
4556 GdiFont
*font
= incoming_font
;
4557 FT_UInt glyph_index
;
4558 DWORD width
, height
, pitch
, needed
= 0;
4559 FT_Bitmap ft_bitmap
;
4561 INT left
, right
, top
= 0, bottom
= 0, adv
, lsb
, bbx
;
4563 FT_Int load_flags
= FT_LOAD_DEFAULT
| FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH
;
4564 double widthRatio
= 1.0;
4565 FT_Matrix transMat
= identityMat
;
4566 FT_Matrix transMatUnrotated
;
4567 BOOL needsTransform
= FALSE
;
4568 BOOL tategaki
= (font
->GSUB_Table
!= NULL
);
4569 UINT original_index
;
4571 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font
, glyph
, format
, lpgm
,
4572 buflen
, buf
, lpmat
);
4574 TRACE("font transform %f %f %f %f\n",
4575 font
->font_desc
.matrix
.eM11
, font
->font_desc
.matrix
.eM12
,
4576 font
->font_desc
.matrix
.eM21
, font
->font_desc
.matrix
.eM22
);
4579 EnterCriticalSection( &freetype_cs
);
4581 if(format
& GGO_GLYPH_INDEX
) {
4582 glyph_index
= get_GSUB_vert_glyph(incoming_font
,glyph
);
4583 original_index
= glyph
;
4584 format
&= ~GGO_GLYPH_INDEX
;
4586 get_glyph_index_linked(incoming_font
, glyph
, &font
, &glyph_index
);
4587 ft_face
= font
->ft_face
;
4588 original_index
= glyph_index
;
4591 if(format
& GGO_UNHINTED
) {
4592 load_flags
|= FT_LOAD_NO_HINTING
;
4593 format
&= ~GGO_UNHINTED
;
4596 /* tategaki never appears to happen to lower glyph index */
4597 if (glyph_index
< TATEGAKI_LOWER_BOUND
)
4600 if(original_index
>= font
->gmsize
* GM_BLOCK_SIZE
) {
4601 font
->gmsize
= (original_index
/ GM_BLOCK_SIZE
+ 1);
4602 font
->gm
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, font
->gm
,
4603 font
->gmsize
* sizeof(GM
*));
4605 if (format
== GGO_METRICS
&& font
->gm
[original_index
/ GM_BLOCK_SIZE
] != NULL
&&
4606 FONT_GM(font
,original_index
)->init
&& is_identity_MAT2(lpmat
))
4608 *lpgm
= FONT_GM(font
,original_index
)->gm
;
4609 TRACE("cached: %u,%u,%s,%d,%d\n", lpgm
->gmBlackBoxX
, lpgm
->gmBlackBoxY
,
4610 wine_dbgstr_point(&lpgm
->gmptGlyphOrigin
),
4611 lpgm
->gmCellIncX
, lpgm
->gmCellIncY
);
4612 LeaveCriticalSection( &freetype_cs
);
4613 return 1; /* FIXME */
4617 if (!font
->gm
[original_index
/ GM_BLOCK_SIZE
])
4618 font
->gm
[original_index
/ GM_BLOCK_SIZE
] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
, sizeof(GM
) * GM_BLOCK_SIZE
);
4620 /* Scaling factor */
4625 WineEngGetTextMetrics(font
, &tm
);
4627 widthRatio
= (double)font
->aveWidth
;
4628 widthRatio
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
4631 widthRatio
= font
->scale_y
;
4633 /* Scaling transform */
4634 if (widthRatio
!= 1.0 || font
->scale_y
!= 1.0)
4637 scaleMat
.xx
= FT_FixedFromFloat(widthRatio
);
4640 scaleMat
.yy
= FT_FixedFromFloat(font
->scale_y
);
4642 pFT_Matrix_Multiply(&scaleMat
, &transMat
);
4643 needsTransform
= TRUE
;
4646 /* Slant transform */
4647 if (font
->fake_italic
) {
4650 slantMat
.xx
= (1 << 16);
4651 slantMat
.xy
= ((1 << 16) >> 2);
4653 slantMat
.yy
= (1 << 16);
4654 pFT_Matrix_Multiply(&slantMat
, &transMat
);
4655 needsTransform
= TRUE
;
4658 /* Rotation transform */
4659 transMatUnrotated
= transMat
;
4660 if(font
->orientation
&& !tategaki
) {
4661 FT_Matrix rotationMat
;
4663 angle
= FT_FixedFromFloat((double)font
->orientation
/ 10.0);
4664 pFT_Vector_Unit(&vecAngle
, angle
);
4665 rotationMat
.xx
= vecAngle
.x
;
4666 rotationMat
.xy
= -vecAngle
.y
;
4667 rotationMat
.yx
= -rotationMat
.xy
;
4668 rotationMat
.yy
= rotationMat
.xx
;
4670 pFT_Matrix_Multiply(&rotationMat
, &transMat
);
4671 needsTransform
= TRUE
;
4674 /* World transform */
4675 if (!is_identity_FMAT2(&font
->font_desc
.matrix
))
4678 worldMat
.xx
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM11
);
4679 worldMat
.xy
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM12
);
4680 worldMat
.yx
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM21
);
4681 worldMat
.yy
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM22
);
4682 pFT_Matrix_Multiply(&worldMat
, &transMat
);
4683 pFT_Matrix_Multiply(&worldMat
, &transMatUnrotated
);
4684 needsTransform
= TRUE
;
4687 /* Extra transformation specified by caller */
4688 if (!is_identity_MAT2(lpmat
))
4691 extraMat
.xx
= FT_FixedFromFIXED(lpmat
->eM11
);
4692 extraMat
.xy
= FT_FixedFromFIXED(lpmat
->eM12
);
4693 extraMat
.yx
= FT_FixedFromFIXED(lpmat
->eM21
);
4694 extraMat
.yy
= FT_FixedFromFIXED(lpmat
->eM22
);
4695 pFT_Matrix_Multiply(&extraMat
, &transMat
);
4696 pFT_Matrix_Multiply(&extraMat
, &transMatUnrotated
);
4697 needsTransform
= TRUE
;
4700 if (needsTransform
|| (format
== GGO_NATIVE
|| format
== GGO_BEZIER
||
4701 format
== GGO_GRAY2_BITMAP
|| format
== GGO_GRAY4_BITMAP
||
4702 format
== GGO_GRAY8_BITMAP
))
4704 load_flags
|= FT_LOAD_NO_BITMAP
;
4707 err
= pFT_Load_Glyph(ft_face
, glyph_index
, load_flags
);
4710 WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index
, err
);
4711 LeaveCriticalSection( &freetype_cs
);
4715 left
= (INT
)(ft_face
->glyph
->metrics
.horiBearingX
) & -64;
4716 right
= (INT
)((ft_face
->glyph
->metrics
.horiBearingX
+ ft_face
->glyph
->metrics
.width
) + 63) & -64;
4718 adv
= (INT
)((ft_face
->glyph
->metrics
.horiAdvance
) + 63) >> 6;
4720 bbx
= (right
- left
) >> 6;
4722 if(!needsTransform
) {
4723 top
= (ft_face
->glyph
->metrics
.horiBearingY
+ 63) & -64;
4724 bottom
= (ft_face
->glyph
->metrics
.horiBearingY
-
4725 ft_face
->glyph
->metrics
.height
) & -64;
4726 lpgm
->gmCellIncX
= adv
;
4727 lpgm
->gmCellIncY
= 0;
4731 for(xc
= 0; xc
< 2; xc
++) {
4732 for(yc
= 0; yc
< 2; yc
++) {
4733 vec
.x
= (ft_face
->glyph
->metrics
.horiBearingX
+
4734 xc
* ft_face
->glyph
->metrics
.width
);
4735 vec
.y
= ft_face
->glyph
->metrics
.horiBearingY
-
4736 yc
* ft_face
->glyph
->metrics
.height
;
4737 TRACE("Vec %ld,%ld\n", vec
.x
, vec
.y
);
4738 pFT_Vector_Transform(&vec
, &transMat
);
4739 if(xc
== 0 && yc
== 0) {
4740 left
= right
= vec
.x
;
4741 top
= bottom
= vec
.y
;
4743 if(vec
.x
< left
) left
= vec
.x
;
4744 else if(vec
.x
> right
) right
= vec
.x
;
4745 if(vec
.y
< bottom
) bottom
= vec
.y
;
4746 else if(vec
.y
> top
) top
= vec
.y
;
4751 right
= (right
+ 63) & -64;
4752 bottom
= bottom
& -64;
4753 top
= (top
+ 63) & -64;
4755 TRACE("transformed box: (%d,%d - %d,%d)\n", left
, top
, right
, bottom
);
4756 vec
.x
= ft_face
->glyph
->metrics
.horiAdvance
;
4758 pFT_Vector_Transform(&vec
, &transMat
);
4759 lpgm
->gmCellIncX
= (vec
.x
+63) >> 6;
4760 lpgm
->gmCellIncY
= -((vec
.y
+63) >> 6);
4762 vec
.x
= ft_face
->glyph
->metrics
.horiAdvance
;
4764 pFT_Vector_Transform(&vec
, &transMatUnrotated
);
4765 adv
= (vec
.x
+63) >> 6;
4767 lpgm
->gmBlackBoxX
= (right
- left
) >> 6;
4768 lpgm
->gmBlackBoxY
= (top
- bottom
) >> 6;
4769 lpgm
->gmptGlyphOrigin
.x
= left
>> 6;
4770 lpgm
->gmptGlyphOrigin
.y
= top
>> 6;
4772 TRACE("%u,%u,%s,%d,%d\n", lpgm
->gmBlackBoxX
, lpgm
->gmBlackBoxY
,
4773 wine_dbgstr_point(&lpgm
->gmptGlyphOrigin
),
4774 lpgm
->gmCellIncX
, lpgm
->gmCellIncY
);
4776 if ((format
== GGO_METRICS
|| format
== GGO_BITMAP
|| format
== WINE_GGO_GRAY16_BITMAP
) &&
4777 is_identity_MAT2(lpmat
)) /* don't cache custom transforms */
4779 FONT_GM(font
,original_index
)->gm
= *lpgm
;
4780 FONT_GM(font
,original_index
)->adv
= adv
;
4781 FONT_GM(font
,original_index
)->lsb
= lsb
;
4782 FONT_GM(font
,original_index
)->bbx
= bbx
;
4783 FONT_GM(font
,original_index
)->init
= TRUE
;
4786 if(format
== GGO_METRICS
)
4788 LeaveCriticalSection( &freetype_cs
);
4789 return 1; /* FIXME */
4792 if(ft_face
->glyph
->format
!= ft_glyph_format_outline
&&
4793 (format
== GGO_NATIVE
|| format
== GGO_BEZIER
||
4794 format
== GGO_GRAY2_BITMAP
|| format
== GGO_GRAY4_BITMAP
||
4795 format
== GGO_GRAY8_BITMAP
))
4797 TRACE("loaded a bitmap\n");
4798 LeaveCriticalSection( &freetype_cs
);
4804 width
= lpgm
->gmBlackBoxX
;
4805 height
= lpgm
->gmBlackBoxY
;
4806 pitch
= ((width
+ 31) >> 5) << 2;
4807 needed
= pitch
* height
;
4809 if(!buf
|| !buflen
) break;
4811 switch(ft_face
->glyph
->format
) {
4812 case ft_glyph_format_bitmap
:
4814 BYTE
*src
= ft_face
->glyph
->bitmap
.buffer
, *dst
= buf
;
4815 INT w
= (ft_face
->glyph
->bitmap
.width
+ 7) >> 3;
4816 INT h
= ft_face
->glyph
->bitmap
.rows
;
4818 memcpy(dst
, src
, w
);
4819 src
+= ft_face
->glyph
->bitmap
.pitch
;
4825 case ft_glyph_format_outline
:
4826 ft_bitmap
.width
= width
;
4827 ft_bitmap
.rows
= height
;
4828 ft_bitmap
.pitch
= pitch
;
4829 ft_bitmap
.pixel_mode
= ft_pixel_mode_mono
;
4830 ft_bitmap
.buffer
= buf
;
4833 pFT_Outline_Transform(&ft_face
->glyph
->outline
, &transMat
);
4835 pFT_Outline_Translate(&ft_face
->glyph
->outline
, -left
, -bottom
);
4837 /* Note: FreeType will only set 'black' bits for us. */
4838 memset(buf
, 0, needed
);
4839 pFT_Outline_Get_Bitmap(library
, &ft_face
->glyph
->outline
, &ft_bitmap
);
4843 FIXME("loaded glyph format %x\n", ft_face
->glyph
->format
);
4844 LeaveCriticalSection( &freetype_cs
);
4849 case GGO_GRAY2_BITMAP
:
4850 case GGO_GRAY4_BITMAP
:
4851 case GGO_GRAY8_BITMAP
:
4852 case WINE_GGO_GRAY16_BITMAP
:
4854 unsigned int mult
, row
, col
;
4857 width
= lpgm
->gmBlackBoxX
;
4858 height
= lpgm
->gmBlackBoxY
;
4859 pitch
= (width
+ 3) / 4 * 4;
4860 needed
= pitch
* height
;
4862 if(!buf
|| !buflen
) break;
4864 switch(ft_face
->glyph
->format
) {
4865 case ft_glyph_format_bitmap
:
4867 BYTE
*src
= ft_face
->glyph
->bitmap
.buffer
, *dst
= buf
;
4868 INT h
= ft_face
->glyph
->bitmap
.rows
;
4871 for(x
= 0; x
< pitch
; x
++)
4873 if(x
< ft_face
->glyph
->bitmap
.width
)
4874 dst
[x
] = (src
[x
/ 8] & (1 << ( (7 - (x
% 8))))) ? 0xff : 0;
4878 src
+= ft_face
->glyph
->bitmap
.pitch
;
4881 LeaveCriticalSection( &freetype_cs
);
4884 case ft_glyph_format_outline
:
4886 ft_bitmap
.width
= width
;
4887 ft_bitmap
.rows
= height
;
4888 ft_bitmap
.pitch
= pitch
;
4889 ft_bitmap
.pixel_mode
= ft_pixel_mode_grays
;
4890 ft_bitmap
.buffer
= buf
;
4893 pFT_Outline_Transform(&ft_face
->glyph
->outline
, &transMat
);
4895 pFT_Outline_Translate(&ft_face
->glyph
->outline
, -left
, -bottom
);
4897 memset(ft_bitmap
.buffer
, 0, buflen
);
4899 pFT_Outline_Get_Bitmap(library
, &ft_face
->glyph
->outline
, &ft_bitmap
);
4901 if(format
== GGO_GRAY2_BITMAP
)
4903 else if(format
== GGO_GRAY4_BITMAP
)
4905 else if(format
== GGO_GRAY8_BITMAP
)
4907 else /* format == WINE_GGO_GRAY16_BITMAP */
4909 LeaveCriticalSection( &freetype_cs
);
4915 FIXME("loaded glyph format %x\n", ft_face
->glyph
->format
);
4916 LeaveCriticalSection( &freetype_cs
);
4921 for(row
= 0; row
< height
; row
++) {
4923 for(col
= 0; col
< width
; col
++, ptr
++) {
4924 *ptr
= (((int)*ptr
) * mult
+ 128) / 256;
4931 case WINE_GGO_HRGB_BITMAP
:
4932 case WINE_GGO_HBGR_BITMAP
:
4933 case WINE_GGO_VRGB_BITMAP
:
4934 case WINE_GGO_VBGR_BITMAP
:
4935 #ifdef HAVE_FREETYPE_FTLCDFIL_H
4937 switch (ft_face
->glyph
->format
)
4939 case FT_GLYPH_FORMAT_BITMAP
:
4944 width
= lpgm
->gmBlackBoxX
;
4945 height
= lpgm
->gmBlackBoxY
;
4947 needed
= pitch
* height
;
4949 if (!buf
|| !buflen
) break;
4951 memset(buf
, 0, buflen
);
4953 src
= ft_face
->glyph
->bitmap
.buffer
;
4954 src_pitch
= ft_face
->glyph
->bitmap
.pitch
;
4958 for (x
= 0; x
< width
; x
++)
4960 if ( src
[x
/ 8] & (1 << ( (7 - (x
% 8)))) )
4961 ((unsigned int *)dst
)[x
] = ~0u;
4970 case FT_GLYPH_FORMAT_OUTLINE
:
4974 INT x
, src_pitch
, src_width
, src_height
, rgb_interval
, hmul
, vmul
;
4975 INT x_shift
, y_shift
;
4977 FT_LcdFilter lcdfilter
= FT_LCD_FILTER_DEFAULT
;
4978 FT_Render_Mode render_mode
=
4979 (format
== WINE_GGO_HRGB_BITMAP
|| format
== WINE_GGO_HBGR_BITMAP
)?
4980 FT_RENDER_MODE_LCD
: FT_RENDER_MODE_LCD_V
;
4982 if ( lcdfilter
== FT_LCD_FILTER_DEFAULT
|| lcdfilter
== FT_LCD_FILTER_LIGHT
)
4984 if ( render_mode
== FT_RENDER_MODE_LCD
)
4986 lpgm
->gmBlackBoxX
+= 2;
4987 lpgm
->gmptGlyphOrigin
.x
-= 1;
4991 lpgm
->gmBlackBoxY
+= 2;
4992 lpgm
->gmptGlyphOrigin
.y
+= 1;
4996 width
= lpgm
->gmBlackBoxX
;
4997 height
= lpgm
->gmBlackBoxY
;
4999 needed
= pitch
* height
;
5001 if (!buf
|| !buflen
) break;
5003 memset(buf
, 0, buflen
);
5005 rgb
= (format
== WINE_GGO_HRGB_BITMAP
|| format
== WINE_GGO_VRGB_BITMAP
);
5007 if ( needsTransform
)
5008 pFT_Outline_Transform (&ft_face
->glyph
->outline
, &transMat
);
5010 if ( pFT_Library_SetLcdFilter
)
5011 pFT_Library_SetLcdFilter( library
, lcdfilter
);
5012 pFT_Render_Glyph (ft_face
->glyph
, render_mode
);
5014 src
= ft_face
->glyph
->bitmap
.buffer
;
5015 src_pitch
= ft_face
->glyph
->bitmap
.pitch
;
5016 src_width
= ft_face
->glyph
->bitmap
.width
;
5017 src_height
= ft_face
->glyph
->bitmap
.rows
;
5019 if ( render_mode
== FT_RENDER_MODE_LCD
)
5027 rgb_interval
= src_pitch
;
5032 x_shift
= ft_face
->glyph
->bitmap_left
- lpgm
->gmptGlyphOrigin
.x
;
5033 if ( x_shift
< 0 ) x_shift
= 0;
5034 if ( x_shift
+ (src_width
/ hmul
) > width
)
5035 x_shift
= width
- (src_width
/ hmul
);
5037 y_shift
= lpgm
->gmptGlyphOrigin
.y
- ft_face
->glyph
->bitmap_top
;
5038 if ( y_shift
< 0 ) y_shift
= 0;
5039 if ( y_shift
+ (src_height
/ vmul
) > height
)
5040 y_shift
= height
- (src_height
/ vmul
);
5042 dst
+= x_shift
+ y_shift
* ( pitch
/ 4 );
5043 while ( src_height
)
5045 for ( x
= 0; x
< src_width
/ hmul
; x
++ )
5047 unsigned int alpha
= (src
[hmul
* x
+ rgb_interval
* 0] +
5048 src
[hmul
* x
+ rgb_interval
* 1] +
5049 src
[hmul
* x
+ rgb_interval
* 2]) / 3;
5052 dst
[x
] = ((src
[hmul
* x
+ rgb_interval
* 0] * alpha
/ 255) << 16) |
5053 ((src
[hmul
* x
+ rgb_interval
* 1] * alpha
/ 255) << 8) |
5054 ((src
[hmul
* x
+ rgb_interval
* 2] * alpha
/ 255) << 0) |
5059 dst
[x
] = ((src
[hmul
* x
+ rgb_interval
* 2] * alpha
/ 255) << 16) |
5060 ((src
[hmul
* x
+ rgb_interval
* 1] * alpha
/ 255) << 8) |
5061 ((src
[hmul
* x
+ rgb_interval
* 0] * alpha
/ 255) << 0) |
5065 src
+= src_pitch
* vmul
;
5074 FIXME ("loaded glyph format %x\n", ft_face
->glyph
->format
);
5075 LeaveCriticalSection ( &freetype_cs
);
5082 LeaveCriticalSection( &freetype_cs
);
5088 int contour
, point
= 0, first_pt
;
5089 FT_Outline
*outline
= &ft_face
->glyph
->outline
;
5090 TTPOLYGONHEADER
*pph
;
5092 DWORD pph_start
, cpfx
, type
;
5094 if(buflen
== 0) buf
= NULL
;
5096 if (needsTransform
&& buf
) {
5097 pFT_Outline_Transform(outline
, &transMat
);
5100 for(contour
= 0; contour
< outline
->n_contours
; contour
++) {
5102 pph
= (TTPOLYGONHEADER
*)((char *)buf
+ needed
);
5105 pph
->dwType
= TT_POLYGON_TYPE
;
5106 FTVectorToPOINTFX(&outline
->points
[point
], &pph
->pfxStart
);
5108 needed
+= sizeof(*pph
);
5110 while(point
<= outline
->contours
[contour
]) {
5111 ppc
= (TTPOLYCURVE
*)((char *)buf
+ needed
);
5112 type
= (outline
->tags
[point
] & FT_Curve_Tag_On
) ?
5113 TT_PRIM_LINE
: TT_PRIM_QSPLINE
;
5117 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
5120 } while(point
<= outline
->contours
[contour
] &&
5121 (outline
->tags
[point
] & FT_Curve_Tag_On
) ==
5122 (outline
->tags
[point
-1] & FT_Curve_Tag_On
));
5123 /* At the end of a contour Windows adds the start point, but
5125 if(point
> outline
->contours
[contour
] &&
5126 !(outline
->tags
[point
-1] & FT_Curve_Tag_On
)) {
5128 FTVectorToPOINTFX(&outline
->points
[first_pt
], &ppc
->apfx
[cpfx
]);
5130 } else if(point
<= outline
->contours
[contour
] &&
5131 outline
->tags
[point
] & FT_Curve_Tag_On
) {
5132 /* add closing pt for bezier */
5134 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
5142 needed
+= sizeof(*ppc
) + (cpfx
- 1) * sizeof(POINTFX
);
5145 pph
->cb
= needed
- pph_start
;
5151 /* Convert the quadratic Beziers to cubic Beziers.
5152 The parametric eqn for a cubic Bezier is, from PLRM:
5153 r(t) = at^3 + bt^2 + ct + r0
5154 with the control points:
5159 A quadratic Beizer has the form:
5160 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
5162 So equating powers of t leads to:
5163 r1 = 2/3 p1 + 1/3 p0
5164 r2 = 2/3 p1 + 1/3 p2
5165 and of course r0 = p0, r3 = p2
5168 int contour
, point
= 0, first_pt
;
5169 FT_Outline
*outline
= &ft_face
->glyph
->outline
;
5170 TTPOLYGONHEADER
*pph
;
5172 DWORD pph_start
, cpfx
, type
;
5173 FT_Vector cubic_control
[4];
5174 if(buflen
== 0) buf
= NULL
;
5176 if (needsTransform
&& buf
) {
5177 pFT_Outline_Transform(outline
, &transMat
);
5180 for(contour
= 0; contour
< outline
->n_contours
; contour
++) {
5182 pph
= (TTPOLYGONHEADER
*)((char *)buf
+ needed
);
5185 pph
->dwType
= TT_POLYGON_TYPE
;
5186 FTVectorToPOINTFX(&outline
->points
[point
], &pph
->pfxStart
);
5188 needed
+= sizeof(*pph
);
5190 while(point
<= outline
->contours
[contour
]) {
5191 ppc
= (TTPOLYCURVE
*)((char *)buf
+ needed
);
5192 type
= (outline
->tags
[point
] & FT_Curve_Tag_On
) ?
5193 TT_PRIM_LINE
: TT_PRIM_CSPLINE
;
5196 if(type
== TT_PRIM_LINE
) {
5198 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
5202 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
5205 /* FIXME: Possible optimization in endpoint calculation
5206 if there are two consecutive curves */
5207 cubic_control
[0] = outline
->points
[point
-1];
5208 if(!(outline
->tags
[point
-1] & FT_Curve_Tag_On
)) {
5209 cubic_control
[0].x
+= outline
->points
[point
].x
+ 1;
5210 cubic_control
[0].y
+= outline
->points
[point
].y
+ 1;
5211 cubic_control
[0].x
>>= 1;
5212 cubic_control
[0].y
>>= 1;
5214 if(point
+1 > outline
->contours
[contour
])
5215 cubic_control
[3] = outline
->points
[first_pt
];
5217 cubic_control
[3] = outline
->points
[point
+1];
5218 if(!(outline
->tags
[point
+1] & FT_Curve_Tag_On
)) {
5219 cubic_control
[3].x
+= outline
->points
[point
].x
+ 1;
5220 cubic_control
[3].y
+= outline
->points
[point
].y
+ 1;
5221 cubic_control
[3].x
>>= 1;
5222 cubic_control
[3].y
>>= 1;
5225 /* r1 = 1/3 p0 + 2/3 p1
5226 r2 = 1/3 p2 + 2/3 p1 */
5227 cubic_control
[1].x
= (2 * outline
->points
[point
].x
+ 1) / 3;
5228 cubic_control
[1].y
= (2 * outline
->points
[point
].y
+ 1) / 3;
5229 cubic_control
[2] = cubic_control
[1];
5230 cubic_control
[1].x
+= (cubic_control
[0].x
+ 1) / 3;
5231 cubic_control
[1].y
+= (cubic_control
[0].y
+ 1) / 3;
5232 cubic_control
[2].x
+= (cubic_control
[3].x
+ 1) / 3;
5233 cubic_control
[2].y
+= (cubic_control
[3].y
+ 1) / 3;
5235 FTVectorToPOINTFX(&cubic_control
[1], &ppc
->apfx
[cpfx
]);
5236 FTVectorToPOINTFX(&cubic_control
[2], &ppc
->apfx
[cpfx
+1]);
5237 FTVectorToPOINTFX(&cubic_control
[3], &ppc
->apfx
[cpfx
+2]);
5242 } while(point
<= outline
->contours
[contour
] &&
5243 (outline
->tags
[point
] & FT_Curve_Tag_On
) ==
5244 (outline
->tags
[point
-1] & FT_Curve_Tag_On
));
5245 /* At the end of a contour Windows adds the start point,
5246 but only for Beziers and we've already done that.
5248 if(point
<= outline
->contours
[contour
] &&
5249 outline
->tags
[point
] & FT_Curve_Tag_On
) {
5250 /* This is the closing pt of a bezier, but we've already
5251 added it, so just inc point and carry on */
5258 needed
+= sizeof(*ppc
) + (cpfx
- 1) * sizeof(POINTFX
);
5261 pph
->cb
= needed
- pph_start
;
5267 FIXME("Unsupported format %d\n", format
);
5268 LeaveCriticalSection( &freetype_cs
);
5271 LeaveCriticalSection( &freetype_cs
);
5275 static BOOL
get_bitmap_text_metrics(GdiFont
*font
)
5277 FT_Face ft_face
= font
->ft_face
;
5278 #ifdef HAVE_FREETYPE_FTWINFNT_H
5279 FT_WinFNT_HeaderRec winfnt_header
;
5281 const DWORD size
= offsetof(OUTLINETEXTMETRICW
, otmFiller
);
5282 font
->potm
= HeapAlloc(GetProcessHeap(), 0, size
);
5283 font
->potm
->otmSize
= size
;
5285 #define TM font->potm->otmTextMetrics
5286 #ifdef HAVE_FREETYPE_FTWINFNT_H
5287 if(pFT_Get_WinFNT_Header
&& !pFT_Get_WinFNT_Header(ft_face
, &winfnt_header
))
5289 TM
.tmHeight
= winfnt_header
.pixel_height
;
5290 TM
.tmAscent
= winfnt_header
.ascent
;
5291 TM
.tmDescent
= TM
.tmHeight
- TM
.tmAscent
;
5292 TM
.tmInternalLeading
= winfnt_header
.internal_leading
;
5293 TM
.tmExternalLeading
= winfnt_header
.external_leading
;
5294 TM
.tmAveCharWidth
= winfnt_header
.avg_width
;
5295 TM
.tmMaxCharWidth
= winfnt_header
.max_width
;
5296 TM
.tmWeight
= winfnt_header
.weight
;
5298 TM
.tmDigitizedAspectX
= winfnt_header
.horizontal_resolution
;
5299 TM
.tmDigitizedAspectY
= winfnt_header
.vertical_resolution
;
5300 TM
.tmFirstChar
= winfnt_header
.first_char
;
5301 TM
.tmLastChar
= winfnt_header
.last_char
;
5302 TM
.tmDefaultChar
= winfnt_header
.default_char
+ winfnt_header
.first_char
;
5303 TM
.tmBreakChar
= winfnt_header
.break_char
+ winfnt_header
.first_char
;
5304 TM
.tmItalic
= winfnt_header
.italic
;
5305 TM
.tmUnderlined
= font
->underline
;
5306 TM
.tmStruckOut
= font
->strikeout
;
5307 TM
.tmPitchAndFamily
= winfnt_header
.pitch_and_family
;
5308 TM
.tmCharSet
= winfnt_header
.charset
;
5313 TM
.tmAscent
= ft_face
->size
->metrics
.ascender
>> 6;
5314 TM
.tmDescent
= -ft_face
->size
->metrics
.descender
>> 6;
5315 TM
.tmHeight
= TM
.tmAscent
+ TM
.tmDescent
;
5316 TM
.tmInternalLeading
= TM
.tmHeight
- ft_face
->size
->metrics
.y_ppem
;
5317 TM
.tmExternalLeading
= (ft_face
->size
->metrics
.height
>> 6) - TM
.tmHeight
;
5318 TM
.tmMaxCharWidth
= ft_face
->size
->metrics
.max_advance
>> 6;
5319 TM
.tmAveCharWidth
= TM
.tmMaxCharWidth
* 2 / 3; /* FIXME */
5320 TM
.tmWeight
= ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
? FW_BOLD
: FW_NORMAL
;
5322 TM
.tmDigitizedAspectX
= 96; /* FIXME */
5323 TM
.tmDigitizedAspectY
= 96; /* FIXME */
5325 TM
.tmLastChar
= 255;
5326 TM
.tmDefaultChar
= 32;
5327 TM
.tmBreakChar
= 32;
5328 TM
.tmItalic
= ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
? 1 : 0;
5329 TM
.tmUnderlined
= font
->underline
;
5330 TM
.tmStruckOut
= font
->strikeout
;
5331 /* NB inverted meaning of TMPF_FIXED_PITCH */
5332 TM
.tmPitchAndFamily
= ft_face
->face_flags
& FT_FACE_FLAG_FIXED_WIDTH
? 0 : TMPF_FIXED_PITCH
;
5333 TM
.tmCharSet
= font
->charset
;
5341 static void scale_font_metrics(const GdiFont
*font
, LPTEXTMETRICW ptm
)
5343 double scale_x
, scale_y
;
5347 scale_x
= (double)font
->aveWidth
;
5348 scale_x
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
5351 scale_x
= font
->scale_y
;
5353 scale_x
*= fabs(font
->font_desc
.matrix
.eM11
);
5354 scale_y
= font
->scale_y
* fabs(font
->font_desc
.matrix
.eM22
);
5356 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
5357 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
5359 SCALE_Y(ptm
->tmHeight
);
5360 SCALE_Y(ptm
->tmAscent
);
5361 SCALE_Y(ptm
->tmDescent
);
5362 SCALE_Y(ptm
->tmInternalLeading
);
5363 SCALE_Y(ptm
->tmExternalLeading
);
5364 SCALE_Y(ptm
->tmOverhang
);
5366 SCALE_X(ptm
->tmAveCharWidth
);
5367 SCALE_X(ptm
->tmMaxCharWidth
);
5373 static void scale_outline_font_metrics(const GdiFont
*font
, OUTLINETEXTMETRICW
*potm
)
5375 double scale_x
, scale_y
;
5379 scale_x
= (double)font
->aveWidth
;
5380 scale_x
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
5383 scale_x
= font
->scale_y
;
5385 scale_x
*= fabs(font
->font_desc
.matrix
.eM11
);
5386 scale_y
= font
->scale_y
* fabs(font
->font_desc
.matrix
.eM22
);
5388 scale_font_metrics(font
, &potm
->otmTextMetrics
);
5390 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
5391 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
5393 SCALE_Y(potm
->otmAscent
);
5394 SCALE_Y(potm
->otmDescent
);
5395 SCALE_Y(potm
->otmLineGap
);
5396 SCALE_Y(potm
->otmsCapEmHeight
);
5397 SCALE_Y(potm
->otmsXHeight
);
5398 SCALE_Y(potm
->otmrcFontBox
.top
);
5399 SCALE_Y(potm
->otmrcFontBox
.bottom
);
5400 SCALE_X(potm
->otmrcFontBox
.left
);
5401 SCALE_X(potm
->otmrcFontBox
.right
);
5402 SCALE_Y(potm
->otmMacAscent
);
5403 SCALE_Y(potm
->otmMacDescent
);
5404 SCALE_Y(potm
->otmMacLineGap
);
5405 SCALE_X(potm
->otmptSubscriptSize
.x
);
5406 SCALE_Y(potm
->otmptSubscriptSize
.y
);
5407 SCALE_X(potm
->otmptSubscriptOffset
.x
);
5408 SCALE_Y(potm
->otmptSubscriptOffset
.y
);
5409 SCALE_X(potm
->otmptSuperscriptSize
.x
);
5410 SCALE_Y(potm
->otmptSuperscriptSize
.y
);
5411 SCALE_X(potm
->otmptSuperscriptOffset
.x
);
5412 SCALE_Y(potm
->otmptSuperscriptOffset
.y
);
5413 SCALE_Y(potm
->otmsStrikeoutSize
);
5414 SCALE_Y(potm
->otmsStrikeoutPosition
);
5415 SCALE_Y(potm
->otmsUnderscoreSize
);
5416 SCALE_Y(potm
->otmsUnderscorePosition
);
5422 /*************************************************************
5423 * WineEngGetTextMetrics
5426 BOOL
WineEngGetTextMetrics(GdiFont
*font
, LPTEXTMETRICW ptm
)
5429 EnterCriticalSection( &freetype_cs
);
5431 if(!WineEngGetOutlineTextMetrics(font
, 0, NULL
))
5432 if(!get_bitmap_text_metrics(font
))
5434 LeaveCriticalSection( &freetype_cs
);
5438 /* Make sure that the font has sane width/height ratio */
5441 if ((font
->aveWidth
+ font
->potm
->otmTextMetrics
.tmHeight
- 1) / font
->potm
->otmTextMetrics
.tmHeight
> 100)
5443 WARN("Ignoring too large font->aveWidth %d\n", font
->aveWidth
);
5449 *ptm
= font
->potm
->otmTextMetrics
;
5450 scale_font_metrics(font
, ptm
);
5451 LeaveCriticalSection( &freetype_cs
);
5455 static BOOL
face_has_symbol_charmap(FT_Face ft_face
)
5459 for(i
= 0; i
< ft_face
->num_charmaps
; i
++)
5461 if(ft_face
->charmaps
[i
]->encoding
== FT_ENCODING_MS_SYMBOL
)
5467 /*************************************************************
5468 * WineEngGetOutlineTextMetrics
5471 UINT
WineEngGetOutlineTextMetrics(GdiFont
*font
, UINT cbSize
,
5472 OUTLINETEXTMETRICW
*potm
)
5474 FT_Face ft_face
= font
->ft_face
;
5475 UINT needed
, lenfam
, lensty
, ret
;
5477 TT_HoriHeader
*pHori
;
5478 TT_Postscript
*pPost
;
5479 FT_Fixed x_scale
, y_scale
;
5480 WCHAR
*family_nameW
, *style_nameW
;
5481 static const WCHAR spaceW
[] = {' ', '\0'};
5483 INT ascent
, descent
;
5485 TRACE("font=%p\n", font
);
5487 if(!FT_IS_SCALABLE(ft_face
))
5491 EnterCriticalSection( &freetype_cs
);
5494 if(cbSize
>= font
->potm
->otmSize
)
5496 memcpy(potm
, font
->potm
, font
->potm
->otmSize
);
5497 scale_outline_font_metrics(font
, potm
);
5499 LeaveCriticalSection( &freetype_cs
);
5500 return font
->potm
->otmSize
;
5504 needed
= sizeof(*potm
);
5506 lenfam
= (strlenW(font
->name
) + 1) * sizeof(WCHAR
);
5507 family_nameW
= strdupW(font
->name
);
5509 lensty
= MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, NULL
, 0)
5511 style_nameW
= HeapAlloc(GetProcessHeap(), 0, lensty
);
5512 MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1,
5513 style_nameW
, lensty
/sizeof(WCHAR
));
5515 /* These names should be read from the TT name table */
5517 /* length of otmpFamilyName */
5520 /* length of otmpFaceName */
5521 if ((ft_face
->style_flags
& (FT_STYLE_FLAG_ITALIC
| FT_STYLE_FLAG_BOLD
)) == 0) {
5522 needed
+= lenfam
; /* just the family name */
5524 needed
+= lenfam
+ lensty
; /* family + " " + style */
5527 /* length of otmpStyleName */
5530 /* length of otmpFullName */
5531 needed
+= lenfam
+ lensty
;
5534 x_scale
= ft_face
->size
->metrics
.x_scale
;
5535 y_scale
= ft_face
->size
->metrics
.y_scale
;
5537 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
5539 FIXME("Can't find OS/2 table - not TT font?\n");
5544 pHori
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
);
5546 FIXME("Can't find HHEA table - not TT font?\n");
5551 pPost
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_post
); /* we can live with this failing */
5553 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",
5554 pOS2
->usWinAscent
, pOS2
->usWinDescent
,
5555 pOS2
->sTypoAscender
, pOS2
->sTypoDescender
, pOS2
->sTypoLineGap
,
5556 ft_face
->ascender
, ft_face
->descender
, ft_face
->height
,
5557 pHori
->Ascender
, pHori
->Descender
, pHori
->Line_Gap
,
5558 ft_face
->bbox
.yMax
, ft_face
->bbox
.yMin
);
5560 font
->potm
= HeapAlloc(GetProcessHeap(), 0, needed
);
5561 font
->potm
->otmSize
= needed
;
5563 #define TM font->potm->otmTextMetrics
5565 if(pOS2
->usWinAscent
+ pOS2
->usWinDescent
== 0) {
5566 ascent
= pHori
->Ascender
;
5567 descent
= -pHori
->Descender
;
5569 ascent
= pOS2
->usWinAscent
;
5570 descent
= pOS2
->usWinDescent
;
5574 TM
.tmAscent
= font
->yMax
;
5575 TM
.tmDescent
= -font
->yMin
;
5576 TM
.tmInternalLeading
= (TM
.tmAscent
+ TM
.tmDescent
) - ft_face
->size
->metrics
.y_ppem
;
5578 TM
.tmAscent
= (pFT_MulFix(ascent
, y_scale
) + 32) >> 6;
5579 TM
.tmDescent
= (pFT_MulFix(descent
, y_scale
) + 32) >> 6;
5580 TM
.tmInternalLeading
= (pFT_MulFix(ascent
+ descent
5581 - ft_face
->units_per_EM
, y_scale
) + 32) >> 6;
5584 TM
.tmHeight
= TM
.tmAscent
+ TM
.tmDescent
;
5587 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
5589 TM
.tmExternalLeading
= max(0, (pFT_MulFix(pHori
->Line_Gap
-
5590 ((ascent
+ descent
) -
5591 (pHori
->Ascender
- pHori
->Descender
)), y_scale
) + 32) >> 6);
5593 TM
.tmAveCharWidth
= (pFT_MulFix(pOS2
->xAvgCharWidth
, x_scale
) + 32) >> 6;
5594 if (TM
.tmAveCharWidth
== 0) {
5595 TM
.tmAveCharWidth
= 1;
5597 TM
.tmMaxCharWidth
= (pFT_MulFix(ft_face
->bbox
.xMax
- ft_face
->bbox
.xMin
, x_scale
) + 32) >> 6;
5598 TM
.tmWeight
= FW_REGULAR
;
5599 if (font
->fake_bold
)
5600 TM
.tmWeight
= FW_BOLD
;
5603 if (ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
)
5605 if (pOS2
->usWeightClass
> FW_MEDIUM
)
5606 TM
.tmWeight
= pOS2
->usWeightClass
;
5608 else if (pOS2
->usWeightClass
<= FW_MEDIUM
)
5609 TM
.tmWeight
= pOS2
->usWeightClass
;
5612 TM
.tmDigitizedAspectX
= 300;
5613 TM
.tmDigitizedAspectY
= 300;
5614 /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
5615 * symbol range to 0 - f0ff
5618 if (face_has_symbol_charmap(ft_face
) || (pOS2
->usFirstCharIndex
>= 0xf000 && pOS2
->usFirstCharIndex
< 0xf100))
5623 case 1257: /* Baltic */
5624 TM
.tmLastChar
= 0xf8fd;
5627 TM
.tmLastChar
= 0xf0ff;
5629 TM
.tmBreakChar
= 0x20;
5630 TM
.tmDefaultChar
= 0x1f;
5634 TM
.tmFirstChar
= pOS2
->usFirstCharIndex
; /* Should be the first char in the cmap */
5635 TM
.tmLastChar
= pOS2
->usLastCharIndex
; /* Should be min(cmap_last, os2_last) */
5637 if(pOS2
->usFirstCharIndex
<= 1)
5638 TM
.tmBreakChar
= pOS2
->usFirstCharIndex
+ 2;
5639 else if (pOS2
->usFirstCharIndex
> 0xff)
5640 TM
.tmBreakChar
= 0x20;
5642 TM
.tmBreakChar
= pOS2
->usFirstCharIndex
;
5643 TM
.tmDefaultChar
= TM
.tmBreakChar
- 1;
5645 TM
.tmItalic
= font
->fake_italic
? 255 : ((ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
) ? 255 : 0);
5646 TM
.tmUnderlined
= font
->underline
;
5647 TM
.tmStruckOut
= font
->strikeout
;
5649 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
5650 if(!FT_IS_FIXED_WIDTH(ft_face
) &&
5651 (pOS2
->version
== 0xFFFFU
||
5652 pOS2
->panose
[PAN_PROPORTION_INDEX
] != PAN_PROP_MONOSPACED
))
5653 TM
.tmPitchAndFamily
= TMPF_FIXED_PITCH
;
5655 TM
.tmPitchAndFamily
= 0;
5657 switch(pOS2
->panose
[PAN_FAMILYTYPE_INDEX
])
5659 case PAN_FAMILY_SCRIPT
:
5660 TM
.tmPitchAndFamily
|= FF_SCRIPT
;
5663 case PAN_FAMILY_DECORATIVE
:
5664 TM
.tmPitchAndFamily
|= FF_DECORATIVE
;
5669 case PAN_FAMILY_TEXT_DISPLAY
:
5670 case PAN_FAMILY_PICTORIAL
: /* symbol fonts get treated as if they were text */
5671 /* which is clearly not what the panose spec says. */
5673 if(TM
.tmPitchAndFamily
== 0 || /* fixed */
5674 pOS2
->panose
[PAN_PROPORTION_INDEX
] == PAN_PROP_MONOSPACED
)
5675 TM
.tmPitchAndFamily
= FF_MODERN
;
5678 switch(pOS2
->panose
[PAN_SERIFSTYLE_INDEX
])
5683 TM
.tmPitchAndFamily
|= FF_DONTCARE
;
5686 case PAN_SERIF_COVE
:
5687 case PAN_SERIF_OBTUSE_COVE
:
5688 case PAN_SERIF_SQUARE_COVE
:
5689 case PAN_SERIF_OBTUSE_SQUARE_COVE
:
5690 case PAN_SERIF_SQUARE
:
5691 case PAN_SERIF_THIN
:
5692 case PAN_SERIF_BONE
:
5693 case PAN_SERIF_EXAGGERATED
:
5694 case PAN_SERIF_TRIANGLE
:
5695 TM
.tmPitchAndFamily
|= FF_ROMAN
;
5698 case PAN_SERIF_NORMAL_SANS
:
5699 case PAN_SERIF_OBTUSE_SANS
:
5700 case PAN_SERIF_PERP_SANS
:
5701 case PAN_SERIF_FLARED
:
5702 case PAN_SERIF_ROUNDED
:
5703 TM
.tmPitchAndFamily
|= FF_SWISS
;
5710 if(FT_IS_SCALABLE(ft_face
))
5711 TM
.tmPitchAndFamily
|= TMPF_VECTOR
;
5713 if(FT_IS_SFNT(ft_face
))
5715 if (font
->ntmFlags
& NTM_PS_OPENTYPE
)
5716 TM
.tmPitchAndFamily
|= TMPF_DEVICE
;
5718 TM
.tmPitchAndFamily
|= TMPF_TRUETYPE
;
5721 TM
.tmCharSet
= font
->charset
;
5723 font
->potm
->otmFiller
= 0;
5724 memcpy(&font
->potm
->otmPanoseNumber
, pOS2
->panose
, PANOSE_COUNT
);
5725 font
->potm
->otmfsSelection
= pOS2
->fsSelection
;
5726 font
->potm
->otmfsType
= pOS2
->fsType
;
5727 font
->potm
->otmsCharSlopeRise
= pHori
->caret_Slope_Rise
;
5728 font
->potm
->otmsCharSlopeRun
= pHori
->caret_Slope_Run
;
5729 font
->potm
->otmItalicAngle
= 0; /* POST table */
5730 font
->potm
->otmEMSquare
= ft_face
->units_per_EM
;
5731 font
->potm
->otmAscent
= (pFT_MulFix(pOS2
->sTypoAscender
, y_scale
) + 32) >> 6;
5732 font
->potm
->otmDescent
= (pFT_MulFix(pOS2
->sTypoDescender
, y_scale
) + 32) >> 6;
5733 font
->potm
->otmLineGap
= (pFT_MulFix(pOS2
->sTypoLineGap
, y_scale
) + 32) >> 6;
5734 font
->potm
->otmsCapEmHeight
= (pFT_MulFix(pOS2
->sCapHeight
, y_scale
) + 32) >> 6;
5735 font
->potm
->otmsXHeight
= (pFT_MulFix(pOS2
->sxHeight
, y_scale
) + 32) >> 6;
5736 font
->potm
->otmrcFontBox
.left
= (pFT_MulFix(ft_face
->bbox
.xMin
, x_scale
) + 32) >> 6;
5737 font
->potm
->otmrcFontBox
.right
= (pFT_MulFix(ft_face
->bbox
.xMax
, x_scale
) + 32) >> 6;
5738 font
->potm
->otmrcFontBox
.top
= (pFT_MulFix(ft_face
->bbox
.yMax
, y_scale
) + 32) >> 6;
5739 font
->potm
->otmrcFontBox
.bottom
= (pFT_MulFix(ft_face
->bbox
.yMin
, y_scale
) + 32) >> 6;
5740 font
->potm
->otmMacAscent
= TM
.tmAscent
;
5741 font
->potm
->otmMacDescent
= -TM
.tmDescent
;
5742 font
->potm
->otmMacLineGap
= font
->potm
->otmLineGap
;
5743 font
->potm
->otmusMinimumPPEM
= 0; /* TT Header */
5744 font
->potm
->otmptSubscriptSize
.x
= (pFT_MulFix(pOS2
->ySubscriptXSize
, x_scale
) + 32) >> 6;
5745 font
->potm
->otmptSubscriptSize
.y
= (pFT_MulFix(pOS2
->ySubscriptYSize
, y_scale
) + 32) >> 6;
5746 font
->potm
->otmptSubscriptOffset
.x
= (pFT_MulFix(pOS2
->ySubscriptXOffset
, x_scale
) + 32) >> 6;
5747 font
->potm
->otmptSubscriptOffset
.y
= (pFT_MulFix(pOS2
->ySubscriptYOffset
, y_scale
) + 32) >> 6;
5748 font
->potm
->otmptSuperscriptSize
.x
= (pFT_MulFix(pOS2
->ySuperscriptXSize
, x_scale
) + 32) >> 6;
5749 font
->potm
->otmptSuperscriptSize
.y
= (pFT_MulFix(pOS2
->ySuperscriptYSize
, y_scale
) + 32) >> 6;
5750 font
->potm
->otmptSuperscriptOffset
.x
= (pFT_MulFix(pOS2
->ySuperscriptXOffset
, x_scale
) + 32) >> 6;
5751 font
->potm
->otmptSuperscriptOffset
.y
= (pFT_MulFix(pOS2
->ySuperscriptYOffset
, y_scale
) + 32) >> 6;
5752 font
->potm
->otmsStrikeoutSize
= (pFT_MulFix(pOS2
->yStrikeoutSize
, y_scale
) + 32) >> 6;
5753 font
->potm
->otmsStrikeoutPosition
= (pFT_MulFix(pOS2
->yStrikeoutPosition
, y_scale
) + 32) >> 6;
5755 font
->potm
->otmsUnderscoreSize
= 0;
5756 font
->potm
->otmsUnderscorePosition
= 0;
5758 font
->potm
->otmsUnderscoreSize
= (pFT_MulFix(pPost
->underlineThickness
, y_scale
) + 32) >> 6;
5759 font
->potm
->otmsUnderscorePosition
= (pFT_MulFix(pPost
->underlinePosition
, y_scale
) + 32) >> 6;
5763 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
5764 cp
= (char*)font
->potm
+ sizeof(*font
->potm
);
5765 font
->potm
->otmpFamilyName
= (LPSTR
)(cp
- (char*)font
->potm
);
5766 strcpyW((WCHAR
*)cp
, family_nameW
);
5768 font
->potm
->otmpStyleName
= (LPSTR
)(cp
- (char*)font
->potm
);
5769 strcpyW((WCHAR
*)cp
, style_nameW
);
5771 font
->potm
->otmpFaceName
= (LPSTR
)(cp
- (char*)font
->potm
);
5772 strcpyW((WCHAR
*)cp
, family_nameW
);
5773 if (ft_face
->style_flags
& (FT_STYLE_FLAG_ITALIC
| FT_STYLE_FLAG_BOLD
)) {
5774 strcatW((WCHAR
*)cp
, spaceW
);
5775 strcatW((WCHAR
*)cp
, style_nameW
);
5776 cp
+= lenfam
+ lensty
;
5779 font
->potm
->otmpFullName
= (LPSTR
)(cp
- (char*)font
->potm
);
5780 strcpyW((WCHAR
*)cp
, family_nameW
);
5781 strcatW((WCHAR
*)cp
, spaceW
);
5782 strcatW((WCHAR
*)cp
, style_nameW
);
5785 if(potm
&& needed
<= cbSize
)
5787 memcpy(potm
, font
->potm
, font
->potm
->otmSize
);
5788 scale_outline_font_metrics(font
, potm
);
5792 HeapFree(GetProcessHeap(), 0, style_nameW
);
5793 HeapFree(GetProcessHeap(), 0, family_nameW
);
5795 LeaveCriticalSection( &freetype_cs
);
5799 static BOOL
load_child_font(GdiFont
*font
, CHILD_FONT
*child
)
5801 HFONTLIST
*hfontlist
;
5802 child
->font
= alloc_font();
5803 child
->font
->ft_face
= OpenFontFace(child
->font
, child
->face
, 0, -font
->ppem
);
5804 if(!child
->font
->ft_face
)
5806 free_font(child
->font
);
5811 child
->font
->font_desc
= font
->font_desc
;
5812 child
->font
->ntmFlags
= child
->face
->ntmFlags
;
5813 child
->font
->orientation
= font
->orientation
;
5814 child
->font
->scale_y
= font
->scale_y
;
5815 hfontlist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist
));
5816 hfontlist
->hfont
= CreateFontIndirectW(&font
->font_desc
.lf
);
5817 child
->font
->name
= strdupW(child
->face
->family
->FamilyName
);
5818 list_add_head(&child
->font
->hfontlist
, &hfontlist
->entry
);
5819 child
->font
->base_font
= font
;
5820 list_add_head(&child_font_list
, &child
->font
->entry
);
5821 TRACE("created child font hfont %p for base %p child %p\n", hfontlist
->hfont
, font
, child
->font
);
5825 static BOOL
get_glyph_index_linked(GdiFont
*font
, UINT c
, GdiFont
**linked_font
, FT_UInt
*glyph
)
5828 CHILD_FONT
*child_font
;
5831 font
= font
->base_font
;
5833 *linked_font
= font
;
5835 if((*glyph
= get_glyph_index(font
, c
)))
5838 LIST_FOR_EACH_ENTRY(child_font
, &font
->child_fonts
, CHILD_FONT
, entry
)
5840 if(!child_font
->font
)
5841 if(!load_child_font(font
, child_font
))
5844 if(!child_font
->font
->ft_face
)
5846 g
= get_glyph_index(child_font
->font
, c
);
5850 *linked_font
= child_font
->font
;
5857 /*************************************************************
5858 * WineEngGetCharWidth
5861 BOOL
WineEngGetCharWidth(GdiFont
*font
, UINT firstChar
, UINT lastChar
,
5864 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
5867 FT_UInt glyph_index
;
5868 GdiFont
*linked_font
;
5870 TRACE("%p, %d, %d, %p\n", font
, firstChar
, lastChar
, buffer
);
5873 EnterCriticalSection( &freetype_cs
);
5874 for(c
= firstChar
; c
<= lastChar
; c
++) {
5875 get_glyph_index_linked(font
, c
, &linked_font
, &glyph_index
);
5876 WineEngGetGlyphOutline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
5877 &gm
, 0, NULL
, &identity
);
5878 buffer
[c
- firstChar
] = FONT_GM(linked_font
,glyph_index
)->adv
;
5880 LeaveCriticalSection( &freetype_cs
);
5884 /*************************************************************
5885 * WineEngGetCharABCWidths
5888 BOOL
WineEngGetCharABCWidths(GdiFont
*font
, UINT firstChar
, UINT lastChar
,
5891 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
5894 FT_UInt glyph_index
;
5895 GdiFont
*linked_font
;
5897 TRACE("%p, %d, %d, %p\n", font
, firstChar
, lastChar
, buffer
);
5899 if(!FT_IS_SCALABLE(font
->ft_face
))
5903 EnterCriticalSection( &freetype_cs
);
5905 for(c
= firstChar
; c
<= lastChar
; c
++) {
5906 get_glyph_index_linked(font
, c
, &linked_font
, &glyph_index
);
5907 WineEngGetGlyphOutline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
5908 &gm
, 0, NULL
, &identity
);
5909 buffer
[c
- firstChar
].abcA
= FONT_GM(linked_font
,glyph_index
)->lsb
;
5910 buffer
[c
- firstChar
].abcB
= FONT_GM(linked_font
,glyph_index
)->bbx
;
5911 buffer
[c
- firstChar
].abcC
= FONT_GM(linked_font
,glyph_index
)->adv
- FONT_GM(linked_font
,glyph_index
)->lsb
-
5912 FONT_GM(linked_font
,glyph_index
)->bbx
;
5914 LeaveCriticalSection( &freetype_cs
);
5918 /*************************************************************
5919 * WineEngGetCharABCWidthsFloat
5922 BOOL
WineEngGetCharABCWidthsFloat(GdiFont
*font
, UINT first
, UINT last
, LPABCFLOAT buffer
)
5924 static const MAT2 identity
= {{0,1}, {0,0}, {0,0}, {0,1}};
5927 FT_UInt glyph_index
;
5928 GdiFont
*linked_font
;
5930 TRACE("%p, %d, %d, %p\n", font
, first
, last
, buffer
);
5933 EnterCriticalSection( &freetype_cs
);
5935 for (c
= first
; c
<= last
; c
++)
5937 get_glyph_index_linked(font
, c
, &linked_font
, &glyph_index
);
5938 WineEngGetGlyphOutline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
5939 &gm
, 0, NULL
, &identity
);
5940 buffer
[c
- first
].abcfA
= FONT_GM(linked_font
, glyph_index
)->lsb
;
5941 buffer
[c
- first
].abcfB
= FONT_GM(linked_font
, glyph_index
)->bbx
;
5942 buffer
[c
- first
].abcfC
= FONT_GM(linked_font
, glyph_index
)->adv
-
5943 FONT_GM(linked_font
, glyph_index
)->lsb
-
5944 FONT_GM(linked_font
, glyph_index
)->bbx
;
5946 LeaveCriticalSection( &freetype_cs
);
5950 /*************************************************************
5951 * WineEngGetCharABCWidthsI
5954 BOOL
WineEngGetCharABCWidthsI(GdiFont
*font
, UINT firstChar
, UINT count
, LPWORD pgi
,
5957 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
5960 FT_UInt glyph_index
;
5961 GdiFont
*linked_font
;
5963 if(!FT_HAS_HORIZONTAL(font
->ft_face
))
5967 EnterCriticalSection( &freetype_cs
);
5969 get_glyph_index_linked(font
, 'a', &linked_font
, &glyph_index
);
5971 for(c
= firstChar
; c
< firstChar
+count
; c
++) {
5972 WineEngGetGlyphOutline(linked_font
, c
, GGO_METRICS
| GGO_GLYPH_INDEX
,
5973 &gm
, 0, NULL
, &identity
);
5974 buffer
[c
- firstChar
].abcA
= FONT_GM(linked_font
,c
)->lsb
;
5975 buffer
[c
- firstChar
].abcB
= FONT_GM(linked_font
,c
)->bbx
;
5976 buffer
[c
- firstChar
].abcC
= FONT_GM(linked_font
,c
)->adv
- FONT_GM(linked_font
,c
)->lsb
5977 - FONT_GM(linked_font
,c
)->bbx
;
5980 for(c
= 0; c
< count
; c
++) {
5981 WineEngGetGlyphOutline(linked_font
, pgi
[c
], GGO_METRICS
| GGO_GLYPH_INDEX
,
5982 &gm
, 0, NULL
, &identity
);
5983 buffer
[c
].abcA
= FONT_GM(linked_font
,pgi
[c
])->lsb
;
5984 buffer
[c
].abcB
= FONT_GM(linked_font
,pgi
[c
])->bbx
;
5985 buffer
[c
].abcC
= FONT_GM(linked_font
,pgi
[c
])->adv
5986 - FONT_GM(linked_font
,pgi
[c
])->lsb
- FONT_GM(linked_font
,pgi
[c
])->bbx
;
5989 LeaveCriticalSection( &freetype_cs
);
5993 /*************************************************************
5994 * WineEngGetTextExtentExPoint
5997 BOOL
WineEngGetTextExtentExPoint(GdiFont
*font
, LPCWSTR wstr
, INT count
,
5998 INT max_ext
, LPINT pnfit
, LPINT dxs
, LPSIZE size
)
6000 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
6005 FT_UInt glyph_index
;
6006 GdiFont
*linked_font
;
6008 TRACE("%p, %s, %d, %d, %p\n", font
, debugstr_wn(wstr
, count
), count
,
6012 EnterCriticalSection( &freetype_cs
);
6015 WineEngGetTextMetrics(font
, &tm
);
6016 size
->cy
= tm
.tmHeight
;
6018 for(idx
= 0; idx
< count
; idx
++) {
6019 get_glyph_index_linked(font
, wstr
[idx
], &linked_font
, &glyph_index
);
6020 WineEngGetGlyphOutline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
6021 &gm
, 0, NULL
, &identity
);
6022 size
->cx
+= FONT_GM(linked_font
,glyph_index
)->adv
;
6024 if (! pnfit
|| ext
<= max_ext
) {
6034 LeaveCriticalSection( &freetype_cs
);
6035 TRACE("return %d, %d, %d\n", size
->cx
, size
->cy
, nfit
);
6039 /*************************************************************
6040 * WineEngGetTextExtentExPointI
6043 BOOL
WineEngGetTextExtentExPointI(GdiFont
*font
, const WORD
*indices
, INT count
,
6044 INT max_ext
, LPINT pnfit
, LPINT dxs
, LPSIZE size
)
6046 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
6052 TRACE("%p, %p, %d, %d, %p\n", font
, indices
, count
, max_ext
, size
);
6055 EnterCriticalSection( &freetype_cs
);
6058 WineEngGetTextMetrics(font
, &tm
);
6059 size
->cy
= tm
.tmHeight
;
6061 for(idx
= 0; idx
< count
; idx
++) {
6062 WineEngGetGlyphOutline(font
, indices
[idx
],
6063 GGO_METRICS
| GGO_GLYPH_INDEX
, &gm
, 0, NULL
,
6065 size
->cx
+= FONT_GM(font
,indices
[idx
])->adv
;
6067 if (! pnfit
|| ext
<= max_ext
) {
6077 LeaveCriticalSection( &freetype_cs
);
6078 TRACE("return %d, %d, %d\n", size
->cx
, size
->cy
, nfit
);
6082 /*************************************************************
6083 * WineEngGetFontData
6086 DWORD
WineEngGetFontData(GdiFont
*font
, DWORD table
, DWORD offset
, LPVOID buf
,
6089 FT_Face ft_face
= font
->ft_face
;
6093 TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
6094 font
, LOBYTE(LOWORD(table
)), HIBYTE(LOWORD(table
)),
6095 LOBYTE(HIWORD(table
)), HIBYTE(HIWORD(table
)), offset
, buf
, cbData
);
6097 if(!FT_IS_SFNT(ft_face
))
6105 if(table
) { /* MS tags differ in endianness from FT ones */
6106 table
= table
>> 24 | table
<< 24 |
6107 (table
>> 8 & 0xff00) | (table
<< 8 & 0xff0000);
6110 /* make sure value of len is the value freetype says it needs */
6113 FT_ULong needed
= 0;
6114 err
= load_sfnt_table(ft_face
, table
, offset
, NULL
, &needed
);
6115 if( !err
&& needed
< len
) len
= needed
;
6117 err
= load_sfnt_table(ft_face
, table
, offset
, buf
, &len
);
6120 TRACE("Can't find table %c%c%c%c\n",
6121 /* bytes were reversed */
6122 HIBYTE(HIWORD(table
)), LOBYTE(HIWORD(table
)),
6123 HIBYTE(LOWORD(table
)), LOBYTE(LOWORD(table
)));
6129 /*************************************************************
6130 * WineEngGetTextFace
6133 INT
WineEngGetTextFace(GdiFont
*font
, INT count
, LPWSTR str
)
6135 INT n
= strlenW(font
->name
) + 1;
6137 lstrcpynW(str
, font
->name
, count
);
6138 return min(count
, n
);
6143 UINT
WineEngGetTextCharsetInfo(GdiFont
*font
, LPFONTSIGNATURE fs
, DWORD flags
)
6145 if (fs
) *fs
= font
->fs
;
6146 return font
->charset
;
6149 BOOL
WineEngGetLinkedHFont(DC
*dc
, WCHAR c
, HFONT
*new_hfont
, UINT
*glyph
)
6151 GdiFont
*font
= dc
->gdiFont
, *linked_font
;
6152 struct list
*first_hfont
;
6156 EnterCriticalSection( &freetype_cs
);
6157 ret
= get_glyph_index_linked(font
, c
, &linked_font
, glyph
);
6158 TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph
, linked_font
);
6159 if(font
== linked_font
)
6160 *new_hfont
= dc
->hFont
;
6163 first_hfont
= list_head(&linked_font
->hfontlist
);
6164 *new_hfont
= LIST_ENTRY(first_hfont
, struct tagHFONTLIST
, entry
)->hfont
;
6166 LeaveCriticalSection( &freetype_cs
);
6170 /* Retrieve a list of supported Unicode ranges for a given font.
6171 * Can be called with NULL gs to calculate the buffer size. Returns
6172 * the number of ranges found.
6174 static DWORD
get_font_unicode_ranges(FT_Face face
, GLYPHSET
*gs
)
6176 DWORD num_ranges
= 0;
6178 if (face
->charmap
->encoding
== FT_ENCODING_UNICODE
&& pFT_Get_First_Char
)
6181 FT_ULong char_code
, char_code_prev
;
6184 char_code_prev
= char_code
= pFT_Get_First_Char(face
, &glyph_code
);
6186 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
6187 face
->num_glyphs
, glyph_code
, char_code
);
6189 if (!glyph_code
) return 0;
6193 gs
->ranges
[0].wcLow
= (USHORT
)char_code
;
6194 gs
->ranges
[0].cGlyphs
= 0;
6195 gs
->cGlyphsSupported
= 0;
6201 if (char_code
< char_code_prev
)
6203 ERR("expected increasing char code from FT_Get_Next_Char\n");
6206 if (char_code
- char_code_prev
> 1)
6211 gs
->ranges
[num_ranges
- 1].wcLow
= (USHORT
)char_code
;
6212 gs
->ranges
[num_ranges
- 1].cGlyphs
= 1;
6213 gs
->cGlyphsSupported
++;
6218 gs
->ranges
[num_ranges
- 1].cGlyphs
++;
6219 gs
->cGlyphsSupported
++;
6221 char_code_prev
= char_code
;
6222 char_code
= pFT_Get_Next_Char(face
, char_code
, &glyph_code
);
6226 FIXME("encoding %u not supported\n", face
->charmap
->encoding
);
6231 DWORD
WineEngGetFontUnicodeRanges(GdiFont
*font
, LPGLYPHSET glyphset
)
6234 DWORD num_ranges
= get_font_unicode_ranges(font
->ft_face
, glyphset
);
6236 size
= sizeof(GLYPHSET
) + sizeof(WCRANGE
) * (num_ranges
- 1);
6239 glyphset
->cbThis
= size
;
6240 glyphset
->cRanges
= num_ranges
;
6245 /*************************************************************
6248 BOOL
WineEngFontIsLinked(GdiFont
*font
)
6252 EnterCriticalSection( &freetype_cs
);
6253 ret
= !list_empty(&font
->child_fonts
);
6254 LeaveCriticalSection( &freetype_cs
);
6258 static BOOL
is_hinting_enabled(void)
6260 /* Use the >= 2.2.0 function if available */
6261 if(pFT_Get_TrueType_Engine_Type
)
6263 FT_TrueTypeEngineType type
= pFT_Get_TrueType_Engine_Type(library
);
6264 return type
== FT_TRUETYPE_ENGINE_TYPE_PATENTED
;
6266 #ifdef FT_DRIVER_HAS_HINTER
6271 /* otherwise if we've been compiled with < 2.2.0 headers
6272 use the internal macro */
6273 mod
= pFT_Get_Module(library
, "truetype");
6274 if(mod
&& FT_DRIVER_HAS_HINTER(mod
))
6282 static BOOL
is_subpixel_rendering_enabled( void )
6284 #ifdef HAVE_FREETYPE_FTLCDFIL_H
6285 return pFT_Library_SetLcdFilter
&&
6286 pFT_Library_SetLcdFilter( NULL
, 0 ) != FT_Err_Unimplemented_Feature
;
6292 /*************************************************************************
6293 * GetRasterizerCaps (GDI32.@)
6295 BOOL WINAPI
GetRasterizerCaps( LPRASTERIZER_STATUS lprs
, UINT cbNumBytes
)
6297 static int hinting
= -1;
6298 static int subpixel
= -1;
6302 hinting
= is_hinting_enabled();
6303 TRACE("hinting is %senabled\n", hinting
? "" : "NOT ");
6306 if ( subpixel
== -1 )
6308 subpixel
= is_subpixel_rendering_enabled();
6309 TRACE("subpixel rendering is %senabled\n", subpixel
? "" : "NOT ");
6312 lprs
->nSize
= sizeof(RASTERIZER_STATUS
);
6313 lprs
->wFlags
= TT_AVAILABLE
| TT_ENABLED
| (hinting
? WINE_TT_HINTER_ENABLED
: 0);
6315 lprs
->wFlags
|= WINE_TT_SUBPIXEL_RENDERING_ENABLED
;
6316 lprs
->nLanguageID
= 0;
6320 /*************************************************************
6321 * WineEngRealizationInfo
6323 BOOL
WineEngRealizationInfo(GdiFont
*font
, realization_info_t
*info
)
6325 FIXME("(%p, %p): stub!\n", font
, info
);
6328 if(FT_IS_SCALABLE(font
->ft_face
))
6331 info
->cache_num
= font
->cache_num
;
6332 info
->unknown2
= -1;
6336 /*************************************************************************
6337 * Kerning support for TrueType fonts
6339 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
6341 struct TT_kern_table
6347 struct TT_kern_subtable
6356 USHORT horizontal
: 1;
6358 USHORT cross_stream
: 1;
6359 USHORT override
: 1;
6360 USHORT reserved1
: 4;
6366 struct TT_format0_kern_subtable
6370 USHORT entrySelector
;
6381 static DWORD
parse_format0_kern_subtable(GdiFont
*font
,
6382 const struct TT_format0_kern_subtable
*tt_f0_ks
,
6383 const USHORT
*glyph_to_char
,
6384 KERNINGPAIR
*kern_pair
, DWORD cPairs
)
6387 const struct TT_kern_pair
*tt_kern_pair
;
6389 TRACE("font height %d, units_per_EM %d\n", font
->ppem
, font
->ft_face
->units_per_EM
);
6391 nPairs
= GET_BE_WORD(tt_f0_ks
->nPairs
);
6393 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
6394 nPairs
, GET_BE_WORD(tt_f0_ks
->searchRange
),
6395 GET_BE_WORD(tt_f0_ks
->entrySelector
), GET_BE_WORD(tt_f0_ks
->rangeShift
));
6397 if (!kern_pair
|| !cPairs
)
6400 tt_kern_pair
= (const struct TT_kern_pair
*)(tt_f0_ks
+ 1);
6402 nPairs
= min(nPairs
, cPairs
);
6404 for (i
= 0; i
< nPairs
; i
++)
6406 kern_pair
->wFirst
= glyph_to_char
[GET_BE_WORD(tt_kern_pair
[i
].left
)];
6407 kern_pair
->wSecond
= glyph_to_char
[GET_BE_WORD(tt_kern_pair
[i
].right
)];
6408 /* this algorithm appears to better match what Windows does */
6409 kern_pair
->iKernAmount
= (short)GET_BE_WORD(tt_kern_pair
[i
].value
) * font
->ppem
;
6410 if (kern_pair
->iKernAmount
< 0)
6412 kern_pair
->iKernAmount
-= font
->ft_face
->units_per_EM
/ 2;
6413 kern_pair
->iKernAmount
-= font
->ppem
;
6415 else if (kern_pair
->iKernAmount
> 0)
6417 kern_pair
->iKernAmount
+= font
->ft_face
->units_per_EM
/ 2;
6418 kern_pair
->iKernAmount
+= font
->ppem
;
6420 kern_pair
->iKernAmount
/= font
->ft_face
->units_per_EM
;
6422 TRACE("left %u right %u value %d\n",
6423 kern_pair
->wFirst
, kern_pair
->wSecond
, kern_pair
->iKernAmount
);
6427 TRACE("copied %u entries\n", nPairs
);
6431 DWORD
WineEngGetKerningPairs(GdiFont
*font
, DWORD cPairs
, KERNINGPAIR
*kern_pair
)
6435 const struct TT_kern_table
*tt_kern_table
;
6436 const struct TT_kern_subtable
*tt_kern_subtable
;
6438 USHORT
*glyph_to_char
;
6441 EnterCriticalSection( &freetype_cs
);
6442 if (font
->total_kern_pairs
!= (DWORD
)-1)
6444 if (cPairs
&& kern_pair
)
6446 cPairs
= min(cPairs
, font
->total_kern_pairs
);
6447 memcpy(kern_pair
, font
->kern_pairs
, cPairs
* sizeof(*kern_pair
));
6448 LeaveCriticalSection( &freetype_cs
);
6451 LeaveCriticalSection( &freetype_cs
);
6452 return font
->total_kern_pairs
;
6455 font
->total_kern_pairs
= 0;
6457 length
= WineEngGetFontData(font
, MS_KERN_TAG
, 0, NULL
, 0);
6459 if (length
== GDI_ERROR
)
6461 TRACE("no kerning data in the font\n");
6462 LeaveCriticalSection( &freetype_cs
);
6466 buf
= HeapAlloc(GetProcessHeap(), 0, length
);
6469 WARN("Out of memory\n");
6470 LeaveCriticalSection( &freetype_cs
);
6474 WineEngGetFontData(font
, MS_KERN_TAG
, 0, buf
, length
);
6476 /* build a glyph index to char code map */
6477 glyph_to_char
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(USHORT
) * 65536);
6480 WARN("Out of memory allocating a glyph index to char code map\n");
6481 HeapFree(GetProcessHeap(), 0, buf
);
6482 LeaveCriticalSection( &freetype_cs
);
6486 if (font
->ft_face
->charmap
->encoding
== FT_ENCODING_UNICODE
&& pFT_Get_First_Char
)
6492 char_code
= pFT_Get_First_Char(font
->ft_face
, &glyph_code
);
6494 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
6495 font
->ft_face
->num_glyphs
, glyph_code
, char_code
);
6499 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
6501 /* FIXME: This doesn't match what Windows does: it does some fancy
6502 * things with duplicate glyph index to char code mappings, while
6503 * we just avoid overriding existing entries.
6505 if (glyph_code
<= 65535 && !glyph_to_char
[glyph_code
])
6506 glyph_to_char
[glyph_code
] = (USHORT
)char_code
;
6508 char_code
= pFT_Get_Next_Char(font
->ft_face
, char_code
, &glyph_code
);
6515 FIXME("encoding %u not supported\n", font
->ft_face
->charmap
->encoding
);
6516 for (n
= 0; n
<= 65535; n
++)
6517 glyph_to_char
[n
] = (USHORT
)n
;
6520 tt_kern_table
= buf
;
6521 nTables
= GET_BE_WORD(tt_kern_table
->nTables
);
6522 TRACE("version %u, nTables %u\n",
6523 GET_BE_WORD(tt_kern_table
->version
), nTables
);
6525 tt_kern_subtable
= (const struct TT_kern_subtable
*)(tt_kern_table
+ 1);
6527 for (i
= 0; i
< nTables
; i
++)
6529 struct TT_kern_subtable tt_kern_subtable_copy
;
6531 tt_kern_subtable_copy
.version
= GET_BE_WORD(tt_kern_subtable
->version
);
6532 tt_kern_subtable_copy
.length
= GET_BE_WORD(tt_kern_subtable
->length
);
6533 tt_kern_subtable_copy
.coverage
.word
= GET_BE_WORD(tt_kern_subtable
->coverage
.word
);
6535 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
6536 tt_kern_subtable_copy
.version
, tt_kern_subtable_copy
.length
,
6537 tt_kern_subtable_copy
.coverage
.word
, tt_kern_subtable_copy
.coverage
.bits
.format
);
6539 /* According to the TrueType specification this is the only format
6540 * that will be properly interpreted by Windows and OS/2
6542 if (tt_kern_subtable_copy
.coverage
.bits
.format
== 0)
6544 DWORD new_chunk
, old_total
= font
->total_kern_pairs
;
6546 new_chunk
= parse_format0_kern_subtable(font
, (const struct TT_format0_kern_subtable
*)(tt_kern_subtable
+ 1),
6547 glyph_to_char
, NULL
, 0);
6548 font
->total_kern_pairs
+= new_chunk
;
6550 if (!font
->kern_pairs
)
6551 font
->kern_pairs
= HeapAlloc(GetProcessHeap(), 0,
6552 font
->total_kern_pairs
* sizeof(*font
->kern_pairs
));
6554 font
->kern_pairs
= HeapReAlloc(GetProcessHeap(), 0, font
->kern_pairs
,
6555 font
->total_kern_pairs
* sizeof(*font
->kern_pairs
));
6557 parse_format0_kern_subtable(font
, (const struct TT_format0_kern_subtable
*)(tt_kern_subtable
+ 1),
6558 glyph_to_char
, font
->kern_pairs
+ old_total
, new_chunk
);
6561 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy
.coverage
.bits
.format
);
6563 tt_kern_subtable
= (const struct TT_kern_subtable
*)((const char *)tt_kern_subtable
+ tt_kern_subtable_copy
.length
);
6566 HeapFree(GetProcessHeap(), 0, glyph_to_char
);
6567 HeapFree(GetProcessHeap(), 0, buf
);
6569 if (cPairs
&& kern_pair
)
6571 cPairs
= min(cPairs
, font
->total_kern_pairs
);
6572 memcpy(kern_pair
, font
->kern_pairs
, cPairs
* sizeof(*kern_pair
));
6573 LeaveCriticalSection( &freetype_cs
);
6576 LeaveCriticalSection( &freetype_cs
);
6577 return font
->total_kern_pairs
;
6580 #else /* HAVE_FREETYPE */
6582 /*************************************************************************/
6584 BOOL
WineEngInit(void)
6588 GdiFont
*WineEngCreateFontInstance(DC
*dc
, HFONT hfont
)
6592 BOOL
WineEngDestroyFontInstance(HFONT hfont
)
6597 DWORD
WineEngEnumFonts(LPLOGFONTW plf
, FONTENUMPROCW proc
, LPARAM lparam
)
6602 DWORD
WineEngGetGlyphIndices(GdiFont
*font
, LPCWSTR lpstr
, INT count
,
6603 LPWORD pgi
, DWORD flags
)
6608 DWORD
WineEngGetGlyphOutline(GdiFont
*font
, UINT glyph
, UINT format
,
6609 LPGLYPHMETRICS lpgm
, DWORD buflen
, LPVOID buf
,
6612 ERR("called but we don't have FreeType\n");
6616 BOOL
WineEngGetTextMetrics(GdiFont
*font
, LPTEXTMETRICW ptm
)
6618 ERR("called but we don't have FreeType\n");
6622 UINT
WineEngGetOutlineTextMetrics(GdiFont
*font
, UINT cbSize
,
6623 OUTLINETEXTMETRICW
*potm
)
6625 ERR("called but we don't have FreeType\n");
6629 BOOL
WineEngGetCharWidth(GdiFont
*font
, UINT firstChar
, UINT lastChar
,
6632 ERR("called but we don't have FreeType\n");
6636 BOOL
WineEngGetCharABCWidths(GdiFont
*font
, UINT firstChar
, UINT lastChar
,
6639 ERR("called but we don't have FreeType\n");
6643 BOOL
WineEngGetCharABCWidthsFloat(GdiFont
*font
, UINT first
, UINT last
, LPABCFLOAT buffer
)
6645 ERR("called but we don't have FreeType\n");
6649 BOOL
WineEngGetCharABCWidthsI(GdiFont
*font
, UINT firstChar
, UINT count
, LPWORD pgi
,
6652 ERR("called but we don't have FreeType\n");
6656 BOOL
WineEngGetTextExtentExPoint(GdiFont
*font
, LPCWSTR wstr
, INT count
,
6657 INT max_ext
, LPINT nfit
, LPINT dx
, LPSIZE size
)
6659 ERR("called but we don't have FreeType\n");
6663 BOOL
WineEngGetTextExtentExPointI(GdiFont
*font
, const WORD
*indices
, INT count
,
6664 INT max_ext
, LPINT nfit
, LPINT dx
, LPSIZE size
)
6666 ERR("called but we don't have FreeType\n");
6670 DWORD
WineEngGetFontData(GdiFont
*font
, DWORD table
, DWORD offset
, LPVOID buf
,
6673 ERR("called but we don't have FreeType\n");
6677 INT
WineEngGetTextFace(GdiFont
*font
, INT count
, LPWSTR str
)
6679 ERR("called but we don't have FreeType\n");
6683 INT
WineEngAddFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
6685 FIXME("(%s, %x, %p): stub\n", debugstr_w(file
), flags
, pdv
);
6689 INT
WineEngRemoveFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
6691 FIXME("(%s, %x, %p): stub\n", debugstr_w(file
), flags
, pdv
);
6695 HANDLE
WineEngAddFontMemResourceEx(PVOID pbFont
, DWORD cbFont
, PVOID pdv
, DWORD
*pcFonts
)
6697 FIXME("(%p, %u, %p, %p): stub\n", pbFont
, cbFont
, pdv
, pcFonts
);
6701 UINT
WineEngGetTextCharsetInfo(GdiFont
*font
, LPFONTSIGNATURE fs
, DWORD flags
)
6703 FIXME("(%p, %p, %u): stub\n", font
, fs
, flags
);
6704 return DEFAULT_CHARSET
;
6707 BOOL
WineEngGetLinkedHFont(DC
*dc
, WCHAR c
, HFONT
*new_hfont
, UINT
*glyph
)
6712 DWORD
WineEngGetFontUnicodeRanges(GdiFont
*font
, LPGLYPHSET glyphset
)
6714 FIXME("(%p, %p): stub\n", font
, glyphset
);
6718 BOOL
WineEngFontIsLinked(GdiFont
*font
)
6723 /*************************************************************************
6724 * GetRasterizerCaps (GDI32.@)
6726 BOOL WINAPI
GetRasterizerCaps( LPRASTERIZER_STATUS lprs
, UINT cbNumBytes
)
6728 lprs
->nSize
= sizeof(RASTERIZER_STATUS
);
6730 lprs
->nLanguageID
= 0;
6734 DWORD
WineEngGetKerningPairs(GdiFont
*font
, DWORD cPairs
, KERNINGPAIR
*kern_pair
)
6736 ERR("called but we don't have FreeType\n");
6740 BOOL
WineEngRealizationInfo(GdiFont
*font
, realization_info_t
*info
)
6742 ERR("called but we don't have FreeType\n");
6746 #endif /* HAVE_FREETYPE */