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"
94 WINE_DEFAULT_DEBUG_CHANNEL(font
);
98 #ifdef HAVE_FT2BUILD_H
101 #ifdef HAVE_FREETYPE_FREETYPE_H
102 #include <freetype/freetype.h>
104 #ifdef HAVE_FREETYPE_FTGLYPH_H
105 #include <freetype/ftglyph.h>
107 #ifdef HAVE_FREETYPE_TTTABLES_H
108 #include <freetype/tttables.h>
110 #ifdef HAVE_FREETYPE_FTTYPES_H
111 #include <freetype/fttypes.h>
113 #ifdef HAVE_FREETYPE_FTSNAMES_H
114 #include <freetype/ftsnames.h>
116 #ifdef HAVE_FREETYPE_TTNAMEID_H
117 #include <freetype/ttnameid.h>
119 #ifdef HAVE_FREETYPE_FTOUTLN_H
120 #include <freetype/ftoutln.h>
122 #ifdef HAVE_FREETYPE_FTTRIGON_H
123 #include <freetype/fttrigon.h>
125 #ifdef HAVE_FREETYPE_FTWINFNT_H
126 #include <freetype/ftwinfnt.h>
128 #ifdef HAVE_FREETYPE_FTMODAPI_H
129 #include <freetype/ftmodapi.h>
131 #ifdef HAVE_FREETYPE_FTLCDFIL_H
132 #include <freetype/ftlcdfil.h>
135 #ifndef HAVE_FT_TRUETYPEENGINETYPE
138 FT_TRUETYPE_ENGINE_TYPE_NONE
= 0,
139 FT_TRUETYPE_ENGINE_TYPE_UNPATENTED
,
140 FT_TRUETYPE_ENGINE_TYPE_PATENTED
141 } FT_TrueTypeEngineType
;
144 static FT_Library library
= 0;
151 static FT_Version_t FT_Version
;
152 static DWORD FT_SimpleVersion
;
154 static void *ft_handle
= NULL
;
156 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
157 MAKE_FUNCPTR(FT_Done_Face
);
158 MAKE_FUNCPTR(FT_Get_Char_Index
);
159 MAKE_FUNCPTR(FT_Get_First_Char
);
160 MAKE_FUNCPTR(FT_Get_Module
);
161 MAKE_FUNCPTR(FT_Get_Next_Char
);
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_Get_WinFNT_Header
);
166 MAKE_FUNCPTR(FT_Init_FreeType
);
167 MAKE_FUNCPTR(FT_Library_Version
);
168 MAKE_FUNCPTR(FT_Load_Glyph
);
169 MAKE_FUNCPTR(FT_Load_Sfnt_Table
);
170 MAKE_FUNCPTR(FT_Matrix_Multiply
);
171 #ifdef FT_MULFIX_INLINED
172 #define pFT_MulFix FT_MULFIX_INLINED
174 MAKE_FUNCPTR(FT_MulFix
);
176 MAKE_FUNCPTR(FT_New_Face
);
177 MAKE_FUNCPTR(FT_New_Memory_Face
);
178 MAKE_FUNCPTR(FT_Outline_Get_Bitmap
);
179 MAKE_FUNCPTR(FT_Outline_Transform
);
180 MAKE_FUNCPTR(FT_Outline_Translate
);
181 MAKE_FUNCPTR(FT_Render_Glyph
);
182 MAKE_FUNCPTR(FT_Select_Charmap
);
183 MAKE_FUNCPTR(FT_Set_Charmap
);
184 MAKE_FUNCPTR(FT_Set_Pixel_Sizes
);
185 MAKE_FUNCPTR(FT_Vector_Transform
);
186 MAKE_FUNCPTR(FT_Vector_Unit
);
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
);
192 #ifdef SONAME_LIBFONTCONFIG
193 #include <fontconfig/fontconfig.h>
194 MAKE_FUNCPTR(FcConfigGetCurrent
);
195 MAKE_FUNCPTR(FcFontList
);
196 MAKE_FUNCPTR(FcFontSetDestroy
);
197 MAKE_FUNCPTR(FcInit
);
198 MAKE_FUNCPTR(FcObjectSetAdd
);
199 MAKE_FUNCPTR(FcObjectSetCreate
);
200 MAKE_FUNCPTR(FcObjectSetDestroy
);
201 MAKE_FUNCPTR(FcPatternCreate
);
202 MAKE_FUNCPTR(FcPatternDestroy
);
203 MAKE_FUNCPTR(FcPatternGetBool
);
204 MAKE_FUNCPTR(FcPatternGetString
);
210 #define FT_MAKE_TAG( ch0, ch1, ch2, ch3 ) \
211 ( ((DWORD)(BYTE)(ch0) << 24) | ((DWORD)(BYTE)(ch1) << 16) | \
212 ((DWORD)(BYTE)(ch2) << 8) | (DWORD)(BYTE)(ch3) )
215 #ifndef ft_encoding_none
216 #define FT_ENCODING_NONE ft_encoding_none
218 #ifndef ft_encoding_ms_symbol
219 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
221 #ifndef ft_encoding_unicode
222 #define FT_ENCODING_UNICODE ft_encoding_unicode
224 #ifndef ft_encoding_apple_roman
225 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
228 #ifdef WORDS_BIGENDIAN
229 #define GET_BE_WORD(x) (x)
231 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
234 /* This is basically a copy of FT_Bitmap_Size with an extra element added */
241 FT_Short internal_leading
;
244 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
245 So to let this compile on older versions of FreeType we'll define the
246 new structure here. */
248 FT_Short height
, width
;
249 FT_Pos size
, x_ppem
, y_ppem
;
255 NEWTEXTMETRICEXW ntm
;
259 typedef struct tagFace
{
265 DWORD font_data_size
;
268 FONTSIGNATURE fs_links
;
270 FT_Fixed font_version
;
272 Bitmap_Size size
; /* set if face is a bitmap */
273 BOOL external
; /* TRUE if we should manually add this font to the registry */
274 struct tagFamily
*family
;
275 /* Cached data for Enum */
276 struct enum_data
*cached_enum_data
;
279 typedef struct tagFamily
{
281 const WCHAR
*FamilyName
;
282 const WCHAR
*EnglishName
;
288 INT adv
; /* These three hold to widths of the unrotated chars */
306 typedef struct tagHFONTLIST
{
321 struct list hfontlist
;
322 OUTLINETEXTMETRICW
*potm
;
323 DWORD total_kern_pairs
;
324 KERNINGPAIR
*kern_pairs
;
325 struct list child_fonts
;
327 /* the following members can be accessed without locking, they are never modified after creation */
329 struct font_mapping
*mapping
;
352 const WCHAR
*font_name
;
356 struct enum_charset_element
{
359 WCHAR name
[LF_FACESIZE
];
362 struct enum_charset_list
{
364 struct enum_charset_element element
[32];
367 #define GM_BLOCK_SIZE 128
368 #define FONT_GM(font,idx) (&(font)->gm[(idx) / GM_BLOCK_SIZE][(idx) % GM_BLOCK_SIZE])
370 static struct list gdi_font_list
= LIST_INIT(gdi_font_list
);
371 static struct list unused_gdi_font_list
= LIST_INIT(unused_gdi_font_list
);
372 #define UNUSED_CACHE_SIZE 10
373 static struct list child_font_list
= LIST_INIT(child_font_list
);
374 static struct list system_links
= LIST_INIT(system_links
);
376 static struct list font_subst_list
= LIST_INIT(font_subst_list
);
378 static struct list font_list
= LIST_INIT(font_list
);
380 struct freetype_physdev
382 struct gdi_physdev dev
;
386 static inline struct freetype_physdev
*get_freetype_dev( PHYSDEV dev
)
388 return (struct freetype_physdev
*)dev
;
391 static const struct gdi_dc_funcs freetype_funcs
;
393 static const WCHAR defSerif
[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
394 static const WCHAR defSans
[] = {'A','r','i','a','l','\0'};
395 static const WCHAR defFixed
[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
397 static const WCHAR fontsW
[] = {'\\','f','o','n','t','s','\0'};
398 static const WCHAR win9x_font_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
399 'W','i','n','d','o','w','s','\\',
400 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
401 'F','o','n','t','s','\0'};
403 static const WCHAR winnt_font_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
404 'W','i','n','d','o','w','s',' ','N','T','\\',
405 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
406 'F','o','n','t','s','\0'};
408 static const WCHAR system_fonts_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
409 static const WCHAR FixedSys_Value
[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
410 static const WCHAR System_Value
[] = {'F','O','N','T','S','.','F','O','N','\0'};
411 static const WCHAR OEMFont_Value
[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
413 static const WCHAR
* const SystemFontValues
[4] = {
420 static const WCHAR external_fonts_reg_key
[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
421 'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
423 /* Interesting and well-known (frequently-assumed!) font names */
424 static const WCHAR Lucida_Sans_Unicode
[] = {'L','u','c','i','d','a',' ','S','a','n','s',' ','U','n','i','c','o','d','e',0};
425 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 };
426 static const WCHAR Tahoma
[] = {'T','a','h','o','m','a',0};
427 static const WCHAR MS_UI_Gothic
[] = {'M','S',' ','U','I',' ','G','o','t','h','i','c',0};
428 static const WCHAR SimSun
[] = {'S','i','m','S','u','n',0};
429 static const WCHAR Gulim
[] = {'G','u','l','i','m',0};
430 static const WCHAR PMingLiU
[] = {'P','M','i','n','g','L','i','U',0};
431 static const WCHAR Batang
[] = {'B','a','t','a','n','g',0};
433 static const WCHAR arial
[] = {'A','r','i','a','l',0};
434 static const WCHAR bitstream_vera_sans
[] = {'B','i','t','s','t','r','e','a','m',' ','V','e','r','a',' ','S','a','n','s',0};
435 static const WCHAR bitstream_vera_sans_mono
[] = {'B','i','t','s','t','r','e','a','m',' ','V','e','r','a',' ','S','a','n','s',' ','M','o','n','o',0};
436 static const WCHAR bitstream_vera_serif
[] = {'B','i','t','s','t','r','e','a','m',' ','V','e','r','a',' ','S','e','r','i','f',0};
437 static const WCHAR courier_new
[] = {'C','o','u','r','i','e','r',' ','N','e','w',0};
438 static const WCHAR liberation_mono
[] = {'L','i','b','e','r','a','t','i','o','n',' ','M','o','n','o',0};
439 static const WCHAR liberation_sans
[] = {'L','i','b','e','r','a','t','i','o','n',' ','S','a','n','s',0};
440 static const WCHAR liberation_serif
[] = {'L','i','b','e','r','a','t','i','o','n',' ','S','e','r','i','f',0};
441 static const WCHAR times_new_roman
[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n',0};
442 static const WCHAR SymbolW
[] = {'S','y','m','b','o','l','\0'};
444 static const WCHAR
*default_serif_list
[] =
448 bitstream_vera_serif
,
452 static const WCHAR
*default_fixed_list
[] =
456 bitstream_vera_sans_mono
,
460 static const WCHAR
*default_sans_list
[] =
473 typedef struct tagFontSubst
{
479 /* Registry font cache key and value names */
480 static const WCHAR wine_fonts_key
[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
481 'F','o','n','t','s',0};
482 static const WCHAR wine_fonts_cache_key
[] = {'C','a','c','h','e',0};
483 static const WCHAR english_name_value
[] = {'E','n','g','l','i','s','h',' ','N','a','m','e',0};
484 static const WCHAR face_index_value
[] = {'I','n','d','e','x',0};
485 static const WCHAR face_italic_value
[] = {'I','t','a','l','i','c',0};
486 static const WCHAR face_bold_value
[] = {'B','o','l','d',0};
487 static const WCHAR face_version_value
[] = {'V','e','r','s','i','o','n',0};
488 static const WCHAR face_external_value
[] = {'E','x','t','e','r','n','a','l',0};
489 static const WCHAR face_height_value
[] = {'H','e','i','g','h','t',0};
490 static const WCHAR face_width_value
[] = {'W','i','d','t','h',0};
491 static const WCHAR face_size_value
[] = {'S','i','z','e',0};
492 static const WCHAR face_x_ppem_value
[] = {'X','p','p','e','m',0};
493 static const WCHAR face_y_ppem_value
[] = {'Y','p','p','e','m',0};
494 static const WCHAR face_internal_leading_value
[] = {'I','n','t','e','r','n','a','l',' ','L','e','a','d','i','n','g',0};
495 static const WCHAR face_font_sig_value
[] = {'F','o','n','t',' ','S','i','g','n','a','t','u','r','e',0};
496 static const WCHAR face_full_name_value
[] = {'F','u','l','l',' ','N','a','m','e','\0'};
509 static struct list mappings_list
= LIST_INIT( mappings_list
);
511 static CRITICAL_SECTION freetype_cs
;
512 static CRITICAL_SECTION_DEBUG critsect_debug
=
515 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
516 0, 0, { (DWORD_PTR
)(__FILE__
": freetype_cs") }
518 static CRITICAL_SECTION freetype_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
520 static const WCHAR font_mutex_nameW
[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
522 static const WCHAR szDefaultFallbackLink
[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0};
523 static BOOL use_default_fallback
= FALSE
;
525 static BOOL
get_glyph_index_linked(GdiFont
*font
, UINT c
, GdiFont
**linked_font
, FT_UInt
*glyph
);
526 static BOOL
get_outline_text_metrics(GdiFont
*font
);
527 static BOOL
get_text_metrics(GdiFont
*font
, LPTEXTMETRICW ptm
);
529 static const WCHAR system_link
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
530 'W','i','n','d','o','w','s',' ','N','T','\\',
531 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
532 'S','y','s','t','e','m','L','i','n','k',0};
534 /****************************************
535 * Notes on .fon files
537 * The fonts System, FixedSys and Terminal are special. There are typically multiple
538 * versions installed for different resolutions and codepages. Windows stores which one to use
539 * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
541 * FIXEDFON.FON FixedSys
543 * OEMFONT.FON Terminal
544 * LogPixels Current dpi set by the display control panel applet
545 * (HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontDPI
546 * also has a LogPixels value that appears to mirror this)
548 * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
549 * (vgaoem.fon would be your oemfont.fon if you have a US setup).
550 * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
551 * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
552 * so that makes sense.
554 * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
555 * to be mapped into the registry on Windows 2000 at least).
558 * ega80woa.fon=ega80850.fon
559 * ega40woa.fon=ega40850.fon
560 * cga80woa.fon=cga80850.fon
561 * cga40woa.fon=cga40850.fon
564 /* These are all structures needed for the GSUB table */
566 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
567 #define TATEGAKI_LOWER_BOUND 0x02F1
583 GSUB_ScriptRecord ScriptRecord
[1];
589 } GSUB_LangSysRecord
;
594 GSUB_LangSysRecord LangSysRecord
[1];
598 WORD LookupOrder
; /* Reserved */
599 WORD ReqFeatureIndex
;
601 WORD FeatureIndex
[1];
607 } GSUB_FeatureRecord
;
611 GSUB_FeatureRecord FeatureRecord
[1];
615 WORD FeatureParams
; /* Reserved */
617 WORD LookupListIndex
[1];
636 } GSUB_CoverageFormat1
;
641 WORD StartCoverageIndex
;
647 GSUB_RangeRecord RangeRecord
[1];
648 } GSUB_CoverageFormat2
;
651 WORD SubstFormat
; /* = 1 */
654 } GSUB_SingleSubstFormat1
;
657 WORD SubstFormat
; /* = 2 */
661 }GSUB_SingleSubstFormat2
;
663 #ifdef HAVE_CARBON_CARBON_H
664 static char *find_cache_dir(void)
668 static char cached_path
[MAX_PATH
];
669 static const char *wine
= "/Wine", *fonts
= "/Fonts";
671 if(*cached_path
) return cached_path
;
673 err
= FSFindFolder(kUserDomain
, kCachedDataFolderType
, kCreateFolder
, &ref
);
676 WARN("can't create cached data folder\n");
679 err
= FSRefMakePath(&ref
, (unsigned char*)cached_path
, sizeof(cached_path
));
682 WARN("can't create cached data path\n");
686 if(strlen(cached_path
) + strlen(wine
) + strlen(fonts
) + 1 > sizeof(cached_path
))
688 ERR("Could not create full path\n");
692 strcat(cached_path
, wine
);
694 if(mkdir(cached_path
, 0700) == -1 && errno
!= EEXIST
)
696 WARN("Couldn't mkdir %s\n", cached_path
);
700 strcat(cached_path
, fonts
);
701 if(mkdir(cached_path
, 0700) == -1 && errno
!= EEXIST
)
703 WARN("Couldn't mkdir %s\n", cached_path
);
710 /******************************************************************
713 * Extracts individual TrueType font files from a Mac suitcase font
714 * and saves them into the user's caches directory (see
716 * Returns a NULL terminated array of filenames.
718 * We do this because they are apps that try to read ttf files
719 * themselves and they don't like Mac suitcase files.
721 static char **expand_mac_font(const char *path
)
728 const char *filename
;
732 unsigned int size
, max_size
;
735 TRACE("path %s\n", path
);
737 s
= FSPathMakeRef((unsigned char*)path
, &ref
, FALSE
);
740 WARN("failed to get ref\n");
744 s
= FSOpenResourceFile(&ref
, 0, NULL
, fsRdPerm
, &res_ref
);
747 TRACE("no data fork, so trying resource fork\n");
748 res_ref
= FSOpenResFile(&ref
, fsRdPerm
);
751 TRACE("unable to open resource fork\n");
758 ret
.array
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, ret
.max_size
* sizeof(*ret
.array
));
761 CloseResFile(res_ref
);
765 out_dir
= find_cache_dir();
767 filename
= strrchr(path
, '/');
768 if(!filename
) filename
= path
;
771 /* output filename has the form out_dir/filename_%04x.ttf */
772 output_len
= strlen(out_dir
) + 1 + strlen(filename
) + 5 + 5;
779 unsigned short *num_faces_ptr
, num_faces
, face
;
782 ResType fond_res
= FT_MAKE_TAG('F','O','N','D');
784 fond
= Get1IndResource(fond_res
, idx
);
786 TRACE("got fond resource %d\n", idx
);
789 fam_rec
= *(FamRec
**)fond
;
790 num_faces_ptr
= (unsigned short *)(fam_rec
+ 1);
791 num_faces
= GET_BE_WORD(*num_faces_ptr
);
793 assoc
= (AsscEntry
*)(num_faces_ptr
+ 1);
794 TRACE("num faces %04x\n", num_faces
);
795 for(face
= 0; face
< num_faces
; face
++, assoc
++)
798 ResType sfnt_res
= FT_MAKE_TAG('s','f','n','t');
799 unsigned short size
, font_id
;
802 size
= GET_BE_WORD(assoc
->fontSize
);
803 font_id
= GET_BE_WORD(assoc
->fontID
);
806 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id
, size
);
810 TRACE("trying to load sfnt id %04x\n", font_id
);
811 sfnt
= GetResource(sfnt_res
, font_id
);
814 TRACE("can't get sfnt resource %04x\n", font_id
);
818 output
= HeapAlloc(GetProcessHeap(), 0, output_len
);
823 sprintf(output
, "%s/%s_%04x.ttf", out_dir
, filename
, font_id
);
825 fd
= open(output
, O_CREAT
| O_EXCL
| O_WRONLY
, 0600);
826 if(fd
!= -1 || errno
== EEXIST
)
830 unsigned char *sfnt_data
;
833 sfnt_data
= *(unsigned char**)sfnt
;
834 write(fd
, sfnt_data
, GetHandleSize(sfnt
));
838 if(ret
.size
>= ret
.max_size
- 1) /* Always want the last element to be NULL */
841 ret
.array
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, ret
.array
, ret
.max_size
* sizeof(*ret
.array
));
843 ret
.array
[ret
.size
++] = output
;
847 WARN("unable to create %s\n", output
);
848 HeapFree(GetProcessHeap(), 0, output
);
851 ReleaseResource(sfnt
);
854 ReleaseResource(fond
);
857 CloseResFile(res_ref
);
862 #endif /* HAVE_CARBON_CARBON_H */
864 static inline BOOL
is_win9x(void)
866 return GetVersion() & 0x80000000;
869 This function builds an FT_Fixed from a double. It fails if the absolute
870 value of the float number is greater than 32768.
872 static inline FT_Fixed
FT_FixedFromFloat(double f
)
878 This function builds an FT_Fixed from a FIXED. It simply put f.value
879 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
881 static inline FT_Fixed
FT_FixedFromFIXED(FIXED f
)
883 return (FT_Fixed
)((int)f
.value
<< 16 | (unsigned int)f
.fract
);
887 static Face
*find_face_from_filename(const WCHAR
*file_name
, const WCHAR
*face_name
)
892 DWORD len
= WideCharToMultiByte(CP_UNIXCP
, 0, file_name
, -1, NULL
, 0, NULL
, NULL
);
893 char *file_nameA
= HeapAlloc(GetProcessHeap(), 0, len
);
895 WideCharToMultiByte(CP_UNIXCP
, 0, file_name
, -1, file_nameA
, len
, NULL
, NULL
);
896 TRACE("looking for file %s name %s\n", debugstr_a(file_nameA
), debugstr_w(face_name
));
898 LIST_FOR_EACH_ENTRY(family
, &font_list
, Family
, entry
)
900 if(face_name
&& strcmpiW(face_name
, family
->FamilyName
))
902 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
906 file
= strrchr(face
->file
, '/');
911 if(!strcasecmp(file
, file_nameA
))
913 HeapFree(GetProcessHeap(), 0, file_nameA
);
918 HeapFree(GetProcessHeap(), 0, file_nameA
);
922 static Family
*find_family_from_name(const WCHAR
*name
)
926 LIST_FOR_EACH_ENTRY(family
, &font_list
, Family
, entry
)
928 if(!strcmpiW(family
->FamilyName
, name
))
935 static void DumpSubstList(void)
939 LIST_FOR_EACH_ENTRY(psub
, &font_subst_list
, FontSubst
, entry
)
941 if(psub
->from
.charset
!= -1 || psub
->to
.charset
!= -1)
942 TRACE("%s:%d -> %s:%d\n", debugstr_w(psub
->from
.name
),
943 psub
->from
.charset
, debugstr_w(psub
->to
.name
), psub
->to
.charset
);
945 TRACE("%s -> %s\n", debugstr_w(psub
->from
.name
),
946 debugstr_w(psub
->to
.name
));
951 static LPWSTR
strdupW(LPCWSTR p
)
954 DWORD len
= (strlenW(p
) + 1) * sizeof(WCHAR
);
955 ret
= HeapAlloc(GetProcessHeap(), 0, len
);
960 static LPSTR
strdupA(LPCSTR p
)
963 DWORD len
= (strlen(p
) + 1);
964 ret
= HeapAlloc(GetProcessHeap(), 0, len
);
969 static FontSubst
*get_font_subst(const struct list
*subst_list
, const WCHAR
*from_name
,
974 LIST_FOR_EACH_ENTRY(element
, subst_list
, FontSubst
, entry
)
976 if(!strcmpiW(element
->from
.name
, from_name
) &&
977 (element
->from
.charset
== from_charset
||
978 element
->from
.charset
== -1))
985 #define ADD_FONT_SUBST_FORCE 1
987 static BOOL
add_font_subst(struct list
*subst_list
, FontSubst
*subst
, INT flags
)
989 FontSubst
*from_exist
, *to_exist
;
991 from_exist
= get_font_subst(subst_list
, subst
->from
.name
, subst
->from
.charset
);
993 if(from_exist
&& (flags
& ADD_FONT_SUBST_FORCE
))
995 list_remove(&from_exist
->entry
);
996 HeapFree(GetProcessHeap(), 0, &from_exist
->from
.name
);
997 HeapFree(GetProcessHeap(), 0, &from_exist
->to
.name
);
998 HeapFree(GetProcessHeap(), 0, from_exist
);
1004 to_exist
= get_font_subst(subst_list
, subst
->to
.name
, subst
->to
.charset
);
1008 HeapFree(GetProcessHeap(), 0, subst
->to
.name
);
1009 subst
->to
.name
= strdupW(to_exist
->to
.name
);
1012 list_add_tail(subst_list
, &subst
->entry
);
1017 HeapFree(GetProcessHeap(), 0, subst
->from
.name
);
1018 HeapFree(GetProcessHeap(), 0, subst
->to
.name
);
1019 HeapFree(GetProcessHeap(), 0, subst
);
1023 static void split_subst_info(NameCs
*nc
, LPSTR str
)
1025 CHAR
*p
= strrchr(str
, ',');
1030 nc
->charset
= strtol(p
+1, NULL
, 10);
1033 len
= MultiByteToWideChar(CP_ACP
, 0, str
, -1, NULL
, 0);
1034 nc
->name
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1035 MultiByteToWideChar(CP_ACP
, 0, str
, -1, nc
->name
, len
);
1038 static void LoadSubstList(void)
1042 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
1046 if(RegOpenKeyA(HKEY_LOCAL_MACHINE
,
1047 "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
1048 &hkey
) == ERROR_SUCCESS
) {
1050 RegQueryInfoKeyA(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
1051 &valuelen
, &datalen
, NULL
, NULL
);
1053 valuelen
++; /* returned value doesn't include room for '\0' */
1054 value
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(CHAR
));
1055 data
= HeapAlloc(GetProcessHeap(), 0, datalen
);
1059 while(RegEnumValueA(hkey
, i
++, value
, &vlen
, NULL
, &type
, data
,
1060 &dlen
) == ERROR_SUCCESS
) {
1061 TRACE("Got %s=%s\n", debugstr_a(value
), debugstr_a(data
));
1063 psub
= HeapAlloc(GetProcessHeap(), 0, sizeof(*psub
));
1064 split_subst_info(&psub
->from
, value
);
1065 split_subst_info(&psub
->to
, data
);
1067 /* Win 2000 doesn't allow mapping between different charsets
1068 or mapping of DEFAULT_CHARSET */
1069 if ((psub
->from
.charset
&& psub
->to
.charset
!= psub
->from
.charset
) ||
1070 psub
->to
.charset
== DEFAULT_CHARSET
) {
1071 HeapFree(GetProcessHeap(), 0, psub
->to
.name
);
1072 HeapFree(GetProcessHeap(), 0, psub
->from
.name
);
1073 HeapFree(GetProcessHeap(), 0, psub
);
1075 add_font_subst(&font_subst_list
, psub
, 0);
1077 /* reset dlen and vlen */
1081 HeapFree(GetProcessHeap(), 0, data
);
1082 HeapFree(GetProcessHeap(), 0, value
);
1088 /*****************************************************************
1089 * get_name_table_entry
1091 * Supply the platform, encoding, language and name ids in req
1092 * and if the name exists the function will fill in the string
1093 * and string_len members. The string is owned by FreeType so
1094 * don't free it. Returns TRUE if the name is found else FALSE.
1096 static BOOL
get_name_table_entry(FT_Face ft_face
, FT_SfntName
*req
)
1099 FT_UInt num_names
, name_index
;
1101 if(FT_IS_SFNT(ft_face
))
1103 num_names
= pFT_Get_Sfnt_Name_Count(ft_face
);
1105 for(name_index
= 0; name_index
< num_names
; name_index
++)
1107 if(!pFT_Get_Sfnt_Name(ft_face
, name_index
, &name
))
1109 if((name
.platform_id
== req
->platform_id
) &&
1110 (name
.encoding_id
== req
->encoding_id
) &&
1111 (name
.language_id
== req
->language_id
) &&
1112 (name
.name_id
== req
->name_id
))
1114 req
->string
= name
.string
;
1115 req
->string_len
= name
.string_len
;
1122 req
->string_len
= 0;
1126 static WCHAR
*get_face_name(FT_Face ft_face
, FT_UShort name_id
, FT_UShort language_id
)
1131 name
.platform_id
= TT_PLATFORM_MICROSOFT
;
1132 name
.encoding_id
= TT_MS_ID_UNICODE_CS
;
1133 name
.language_id
= language_id
;
1134 name
.name_id
= name_id
;
1136 if(get_name_table_entry(ft_face
, &name
))
1140 /* String is not nul terminated and string_len is a byte length. */
1141 ret
= HeapAlloc(GetProcessHeap(), 0, name
.string_len
+ 2);
1142 for(i
= 0; i
< name
.string_len
/ 2; i
++)
1144 WORD
*tmp
= (WORD
*)&name
.string
[i
* 2];
1145 ret
[i
] = GET_BE_WORD(*tmp
);
1148 TRACE("Got localised name %s\n", debugstr_w(ret
));
1154 static LONG
reg_load_dword(HKEY hkey
, const WCHAR
*value
, DWORD
*data
)
1157 LONG r
= RegQueryValueExW(hkey
, value
, NULL
, &type
, NULL
, &needed
);
1158 if(r
!= ERROR_SUCCESS
) return r
;
1159 if(type
!= REG_DWORD
|| needed
!= sizeof(DWORD
)) return ERROR_BAD_CONFIGURATION
;
1160 return RegQueryValueExW(hkey
, value
, NULL
, &type
, (BYTE
*)data
, &needed
);
1163 static inline LONG
reg_save_dword(HKEY hkey
, const WCHAR
*value
, DWORD data
)
1165 return RegSetValueExW(hkey
, value
, 0, REG_DWORD
, (BYTE
*)&data
, sizeof(DWORD
));
1168 static void load_face(HKEY hkey_face
, WCHAR
*face_name
, Family
*family
)
1171 DWORD num_strikes
, max_strike_key_len
;
1173 /* If we have a File Name key then this is a real font, not just the parent
1174 key of a bunch of non-scalable strikes */
1175 if(RegQueryValueExA(hkey_face
, "File Name", NULL
, NULL
, NULL
, &needed
) == ERROR_SUCCESS
)
1179 face
= HeapAlloc(GetProcessHeap(), 0, sizeof(*face
));
1180 face
->cached_enum_data
= NULL
;
1182 face
->file
= HeapAlloc(GetProcessHeap(), 0, needed
);
1183 RegQueryValueExA(hkey_face
, "File Name", NULL
, NULL
, (BYTE
*)face
->file
, &needed
);
1185 face
->StyleName
= strdupW(face_name
);
1186 face
->family
= family
;
1188 if(RegQueryValueExW(hkey_face
, face_full_name_value
, NULL
, NULL
, NULL
, &needed
) == ERROR_SUCCESS
)
1190 WCHAR
*fullName
= HeapAlloc(GetProcessHeap(), 0, needed
);
1191 RegQueryValueExW(hkey_face
, face_full_name_value
, NULL
, NULL
, (BYTE
*)fullName
, &needed
);
1192 face
->FullName
= fullName
;
1195 face
->FullName
= NULL
;
1197 reg_load_dword(hkey_face
, face_index_value
, (DWORD
*)&face
->face_index
);
1198 reg_load_dword(hkey_face
, face_italic_value
, &italic
);
1199 reg_load_dword(hkey_face
, face_bold_value
, &bold
);
1200 reg_load_dword(hkey_face
, face_version_value
, (DWORD
*)&face
->font_version
);
1201 reg_load_dword(hkey_face
, face_external_value
, (DWORD
*)&face
->external
);
1203 needed
= sizeof(face
->fs
);
1204 RegQueryValueExW(hkey_face
, face_font_sig_value
, NULL
, NULL
, (BYTE
*)&face
->fs
, &needed
);
1205 memset(&face
->fs_links
, 0, sizeof(face
->fs_links
));
1207 if(reg_load_dword(hkey_face
, face_height_value
, (DWORD
*)&face
->size
.height
) != ERROR_SUCCESS
)
1209 face
->scalable
= TRUE
;
1210 memset(&face
->size
, 0, sizeof(face
->size
));
1214 face
->scalable
= FALSE
;
1215 reg_load_dword(hkey_face
, face_width_value
, (DWORD
*)&face
->size
.width
);
1216 reg_load_dword(hkey_face
, face_size_value
, (DWORD
*)&face
->size
.size
);
1217 reg_load_dword(hkey_face
, face_x_ppem_value
, (DWORD
*)&face
->size
.x_ppem
);
1218 reg_load_dword(hkey_face
, face_y_ppem_value
, (DWORD
*)&face
->size
.y_ppem
);
1219 reg_load_dword(hkey_face
, face_internal_leading_value
, (DWORD
*)&face
->size
.internal_leading
);
1221 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1222 face
->size
.height
, face
->size
.width
, face
->size
.size
>> 6,
1223 face
->size
.x_ppem
>> 6, face
->size
.y_ppem
>> 6);
1227 if (italic
) face
->ntmFlags
|= NTM_ITALIC
;
1228 if (bold
) face
->ntmFlags
|= NTM_BOLD
;
1229 if (face
->ntmFlags
== 0) face
->ntmFlags
= NTM_REGULAR
;
1231 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1232 face
->fs
.fsCsb
[0], face
->fs
.fsCsb
[1],
1233 face
->fs
.fsUsb
[0], face
->fs
.fsUsb
[1],
1234 face
->fs
.fsUsb
[2], face
->fs
.fsUsb
[3]);
1236 if(!italic
&& !bold
)
1237 list_add_head(&family
->faces
, &face
->entry
);
1239 list_add_tail(&family
->faces
, &face
->entry
);
1241 TRACE("Added font %s %s\n", debugstr_w(family
->FamilyName
), debugstr_w(face
->StyleName
));
1244 /* do we have any bitmap strikes? */
1245 RegQueryInfoKeyW(hkey_face
, NULL
, NULL
, NULL
, &num_strikes
, &max_strike_key_len
, NULL
, NULL
,
1246 NULL
, NULL
, NULL
, NULL
);
1247 if(num_strikes
!= 0)
1249 WCHAR strike_name
[10];
1250 DWORD strike_index
= 0;
1252 needed
= sizeof(strike_name
) / sizeof(WCHAR
);
1253 while(RegEnumKeyExW(hkey_face
, strike_index
++, strike_name
, &needed
,
1254 NULL
, NULL
, NULL
, NULL
) == ERROR_SUCCESS
)
1257 RegOpenKeyExW(hkey_face
, strike_name
, 0, KEY_ALL_ACCESS
, &hkey_strike
);
1258 load_face(hkey_strike
, face_name
, family
);
1259 RegCloseKey(hkey_strike
);
1260 needed
= sizeof(strike_name
) / sizeof(WCHAR
);
1265 static void load_font_list_from_cache(HKEY hkey_font_cache
)
1267 DWORD max_family_key_len
, size
;
1269 DWORD family_index
= 0;
1273 RegQueryInfoKeyW(hkey_font_cache
, NULL
, NULL
, NULL
, NULL
, &max_family_key_len
, NULL
, NULL
,
1274 NULL
, NULL
, NULL
, NULL
);
1275 family_name
= HeapAlloc(GetProcessHeap(), 0, (max_family_key_len
+ 1) * sizeof(WCHAR
));
1277 size
= max_family_key_len
+ 1;
1278 while(RegEnumKeyExW(hkey_font_cache
, family_index
++, family_name
, &size
,
1279 NULL
, NULL
, NULL
, NULL
) == ERROR_SUCCESS
)
1281 WCHAR
*english_family
= NULL
;
1282 DWORD face_index
= 0;
1284 DWORD max_face_key_len
;
1286 RegOpenKeyExW(hkey_font_cache
, family_name
, 0, KEY_ALL_ACCESS
, &hkey_family
);
1287 TRACE("opened family key %s\n", debugstr_w(family_name
));
1288 if(RegQueryValueExW(hkey_family
, english_name_value
, NULL
, NULL
, NULL
, &size
) == ERROR_SUCCESS
)
1290 english_family
= HeapAlloc(GetProcessHeap(), 0, size
);
1291 RegQueryValueExW(hkey_family
, english_name_value
, NULL
, NULL
, (BYTE
*)english_family
, &size
);
1294 family
= HeapAlloc(GetProcessHeap(), 0, sizeof(*family
));
1295 family
->FamilyName
= strdupW(family_name
);
1296 family
->EnglishName
= english_family
;
1297 list_init(&family
->faces
);
1298 list_add_tail(&font_list
, &family
->entry
);
1302 FontSubst
*subst
= HeapAlloc(GetProcessHeap(), 0, sizeof(*subst
));
1303 subst
->from
.name
= strdupW(english_family
);
1304 subst
->from
.charset
= -1;
1305 subst
->to
.name
= strdupW(family_name
);
1306 subst
->to
.charset
= -1;
1307 add_font_subst(&font_subst_list
, subst
, 0);
1310 RegQueryInfoKeyW(hkey_family
, NULL
, NULL
, NULL
, NULL
, &max_face_key_len
, NULL
, NULL
,
1311 NULL
, NULL
, NULL
, NULL
);
1313 face_name
= HeapAlloc(GetProcessHeap(), 0, (max_face_key_len
+ 1) * sizeof(WCHAR
));
1314 size
= max_face_key_len
+ 1;
1315 while(RegEnumKeyExW(hkey_family
, face_index
++, face_name
, &size
,
1316 NULL
, NULL
, NULL
, NULL
) == ERROR_SUCCESS
)
1320 RegOpenKeyExW(hkey_family
, face_name
, 0, KEY_ALL_ACCESS
, &hkey_face
);
1321 load_face(hkey_face
, face_name
, family
);
1322 RegCloseKey(hkey_face
);
1323 size
= max_face_key_len
+ 1;
1325 HeapFree(GetProcessHeap(), 0, face_name
);
1326 RegCloseKey(hkey_family
);
1327 size
= max_family_key_len
+ 1;
1330 HeapFree(GetProcessHeap(), 0, family_name
);
1333 static LONG
create_font_cache_key(HKEY
*hkey
, DWORD
*disposition
)
1336 HKEY hkey_wine_fonts
;
1338 /* We don't want to create the fonts key as volatile, so open this first */
1339 ret
= RegCreateKeyExW(HKEY_CURRENT_USER
, wine_fonts_key
, 0, NULL
, 0,
1340 KEY_ALL_ACCESS
, NULL
, &hkey_wine_fonts
, NULL
);
1341 if(ret
!= ERROR_SUCCESS
)
1343 WARN("Can't create %s\n", debugstr_w(wine_fonts_key
));
1347 ret
= RegCreateKeyExW(hkey_wine_fonts
, wine_fonts_cache_key
, 0, NULL
, REG_OPTION_VOLATILE
,
1348 KEY_ALL_ACCESS
, NULL
, hkey
, disposition
);
1349 RegCloseKey(hkey_wine_fonts
);
1353 static void add_face_to_cache(Face
*face
)
1355 HKEY hkey_font_cache
, hkey_family
, hkey_face
;
1356 WCHAR
*face_key_name
;
1358 create_font_cache_key(&hkey_font_cache
, NULL
);
1360 RegCreateKeyExW(hkey_font_cache
, face
->family
->FamilyName
, 0,
1361 NULL
, REG_OPTION_VOLATILE
, KEY_ALL_ACCESS
, NULL
, &hkey_family
, NULL
);
1362 if(face
->family
->EnglishName
)
1363 RegSetValueExW(hkey_family
, english_name_value
, 0, REG_SZ
, (BYTE
*)face
->family
->EnglishName
,
1364 (strlenW(face
->family
->EnglishName
) + 1) * sizeof(WCHAR
));
1367 face_key_name
= face
->StyleName
;
1370 static const WCHAR fmtW
[] = {'%','s','\\','%','d',0};
1371 face_key_name
= HeapAlloc(GetProcessHeap(), 0, (strlenW(face
->StyleName
) + 10) * sizeof(WCHAR
));
1372 sprintfW(face_key_name
, fmtW
, face
->StyleName
, face
->size
.y_ppem
);
1374 RegCreateKeyExW(hkey_family
, face_key_name
, 0, NULL
, REG_OPTION_VOLATILE
, KEY_ALL_ACCESS
, NULL
,
1377 HeapFree(GetProcessHeap(), 0, face_key_name
);
1379 RegSetValueExA(hkey_face
, "File Name", 0, REG_BINARY
, (BYTE
*)face
->file
, strlen(face
->file
) + 1);
1381 RegSetValueExW(hkey_face
, face_full_name_value
, 0, REG_SZ
, (BYTE
*)face
->FullName
,
1382 (strlenW(face
->FullName
) + 1) * sizeof(WCHAR
));
1384 reg_save_dword(hkey_face
, face_index_value
, face
->face_index
);
1385 reg_save_dword(hkey_face
, face_italic_value
, (face
->ntmFlags
& NTM_ITALIC
) != 0);
1386 reg_save_dword(hkey_face
, face_bold_value
, (face
->ntmFlags
& NTM_BOLD
) != 0);
1387 reg_save_dword(hkey_face
, face_version_value
, face
->font_version
);
1388 reg_save_dword(hkey_face
, face_external_value
, face
->external
);
1390 RegSetValueExW(hkey_face
, face_font_sig_value
, 0, REG_BINARY
, (BYTE
*)&face
->fs
, sizeof(face
->fs
));
1394 reg_save_dword(hkey_face
, face_height_value
, face
->size
.height
);
1395 reg_save_dword(hkey_face
, face_width_value
, face
->size
.width
);
1396 reg_save_dword(hkey_face
, face_size_value
, face
->size
.size
);
1397 reg_save_dword(hkey_face
, face_x_ppem_value
, face
->size
.x_ppem
);
1398 reg_save_dword(hkey_face
, face_y_ppem_value
, face
->size
.y_ppem
);
1399 reg_save_dword(hkey_face
, face_internal_leading_value
, face
->size
.internal_leading
);
1401 RegCloseKey(hkey_face
);
1402 RegCloseKey(hkey_family
);
1403 RegCloseKey(hkey_font_cache
);
1406 static inline int TestStyles(DWORD flags
, DWORD styles
)
1408 return (flags
& styles
) == styles
;
1411 static int StyleOrdering(Face
*face
)
1413 if (TestStyles(face
->ntmFlags
, NTM_BOLD
| NTM_ITALIC
))
1415 if (TestStyles(face
->ntmFlags
, NTM_ITALIC
))
1417 if (TestStyles(face
->ntmFlags
, NTM_BOLD
))
1419 if (TestStyles(face
->ntmFlags
, NTM_REGULAR
))
1422 WARN("Don't know how to order font %s %s with flags 0x%08x\n",
1423 debugstr_w(face
->family
->FamilyName
),
1424 debugstr_w(face
->StyleName
),
1430 /* Add a style of face to a font family using an ordering of the list such
1431 that regular fonts come before bold and italic, and single styles come
1432 before compound styles. */
1433 static void AddFaceToFamily(Face
*face
, Family
*family
)
1437 LIST_FOR_EACH( entry
, &family
->faces
)
1439 Face
*ent
= LIST_ENTRY(entry
, Face
, entry
);
1440 if (StyleOrdering(face
) < StyleOrdering(ent
)) break;
1442 list_add_before( entry
, &face
->entry
);
1445 #define ADDFONT_EXTERNAL_FONT 0x01
1446 #define ADDFONT_FORCE_BITMAP 0x02
1447 #define ADDFONT_ADD_TO_CACHE 0x04
1449 static INT
AddFontToList(const char *file
, void *font_data_ptr
, DWORD font_data_size
, char *fake_family
, const WCHAR
*target_family
, DWORD flags
)
1453 TT_Header
*pHeader
= NULL
;
1454 WCHAR
*english_family
, *localised_family
, *StyleW
;
1458 struct list
*family_elem_ptr
, *face_elem_ptr
;
1460 FT_Long face_index
= 0, num_faces
;
1461 FT_WinFNT_HeaderRec winfnt_header
;
1462 int i
, bitmap_num
, internal_leading
;
1465 /* we always load external fonts from files - otherwise we would get a crash in update_reg_entries */
1466 assert(file
|| !(flags
& ADDFONT_EXTERNAL_FONT
));
1468 #ifdef HAVE_CARBON_CARBON_H
1469 if(file
&& !fake_family
)
1471 char **mac_list
= expand_mac_font(file
);
1474 BOOL had_one
= FALSE
;
1476 for(cursor
= mac_list
; *cursor
; cursor
++)
1479 AddFontToList(*cursor
, NULL
, 0, NULL
, NULL
, flags
);
1480 HeapFree(GetProcessHeap(), 0, *cursor
);
1482 HeapFree(GetProcessHeap(), 0, mac_list
);
1487 #endif /* HAVE_CARBON_CARBON_H */
1490 char *family_name
= fake_family
;
1494 TRACE("Loading font file %s index %ld\n", debugstr_a(file
), face_index
);
1495 err
= pFT_New_Face(library
, file
, face_index
, &ft_face
);
1498 TRACE("Loading font from ptr %p size %d, index %ld\n", font_data_ptr
, font_data_size
, face_index
);
1499 err
= pFT_New_Memory_Face(library
, font_data_ptr
, font_data_size
, face_index
, &ft_face
);
1503 WARN("Unable to load font %s/%p err = %x\n", debugstr_a(file
), font_data_ptr
, err
);
1507 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*/
1508 WARN("Ignoring font %s/%p\n", debugstr_a(file
), font_data_ptr
);
1509 pFT_Done_Face(ft_face
);
1513 /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1514 if(!FT_IS_SCALABLE(ft_face
) && FT_SimpleVersion
< ((2 << 16) | (1 << 8) | (9 << 0))) {
1515 WARN("FreeType version < 2.1.9, skipping bitmap font %s/%p\n", debugstr_a(file
), font_data_ptr
);
1516 pFT_Done_Face(ft_face
);
1520 if(FT_IS_SFNT(ft_face
))
1522 if(!(pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
)) ||
1523 !pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
) ||
1524 !(pHeader
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_head
)))
1526 TRACE("Font %s/%p lacks either an OS2, HHEA or HEAD table.\n"
1527 "Skipping this font.\n", debugstr_a(file
), font_data_ptr
);
1528 pFT_Done_Face(ft_face
);
1532 /* Wine uses ttfs as an intermediate step in building its bitmap fonts;
1533 we don't want to load these. */
1534 if(!memcmp(pOS2
->achVendID
, "Wine", sizeof(pOS2
->achVendID
)))
1538 if(!pFT_Load_Sfnt_Table(ft_face
, FT_MAKE_TAG('E','B','S','C'), 0, NULL
, &len
))
1540 TRACE("Skipping Wine bitmap-only TrueType font %s\n", debugstr_a(file
));
1541 pFT_Done_Face(ft_face
);
1547 if(!ft_face
->family_name
|| !ft_face
->style_name
) {
1548 TRACE("Font %s/%p lacks either a family or style name\n", debugstr_a(file
), font_data_ptr
);
1549 pFT_Done_Face(ft_face
);
1553 if(ft_face
->family_name
[0] == '.') /* Ignore fonts with names beginning with a dot */
1555 TRACE("Ignoring %s since its family name begins with a dot\n", debugstr_a(file
));
1556 pFT_Done_Face(ft_face
);
1562 localised_family
= get_face_name(ft_face
, TT_NAME_ID_FONT_FAMILY
, GetUserDefaultLCID());
1563 if (localised_family
&& strcmpiW(localised_family
,target_family
)!=0)
1565 TRACE("Skipping Index %i: Incorrect Family name for replacement\n",(INT
)face_index
);
1566 HeapFree(GetProcessHeap(), 0, localised_family
);
1567 num_faces
= ft_face
->num_faces
;
1568 pFT_Done_Face(ft_face
);
1571 HeapFree(GetProcessHeap(), 0, localised_family
);
1575 family_name
= ft_face
->family_name
;
1579 My_FT_Bitmap_Size
*size
= NULL
;
1582 if(!FT_IS_SCALABLE(ft_face
))
1583 size
= (My_FT_Bitmap_Size
*)ft_face
->available_sizes
+ bitmap_num
;
1585 len
= MultiByteToWideChar(CP_ACP
, 0, family_name
, -1, NULL
, 0);
1586 english_family
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1587 MultiByteToWideChar(CP_ACP
, 0, family_name
, -1, english_family
, len
);
1589 localised_family
= NULL
;
1591 localised_family
= get_face_name(ft_face
, TT_NAME_ID_FONT_FAMILY
, GetUserDefaultLCID());
1592 if(localised_family
&& !strcmpiW(localised_family
, english_family
)) {
1593 HeapFree(GetProcessHeap(), 0, localised_family
);
1594 localised_family
= NULL
;
1599 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1600 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1601 if(!strcmpiW(family
->FamilyName
, localised_family
? localised_family
: english_family
))
1606 family
= HeapAlloc(GetProcessHeap(), 0, sizeof(*family
));
1607 family
->FamilyName
= strdupW(localised_family
? localised_family
: english_family
);
1608 family
->EnglishName
= localised_family
? strdupW(english_family
) : NULL
;
1609 list_init(&family
->faces
);
1610 list_add_tail(&font_list
, &family
->entry
);
1612 if(localised_family
) {
1613 FontSubst
*subst
= HeapAlloc(GetProcessHeap(), 0, sizeof(*subst
));
1614 subst
->from
.name
= strdupW(english_family
);
1615 subst
->from
.charset
= -1;
1616 subst
->to
.name
= strdupW(localised_family
);
1617 subst
->to
.charset
= -1;
1618 add_font_subst(&font_subst_list
, subst
, 0);
1621 HeapFree(GetProcessHeap(), 0, localised_family
);
1622 HeapFree(GetProcessHeap(), 0, english_family
);
1624 len
= MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, NULL
, 0);
1625 StyleW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1626 MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, StyleW
, len
);
1628 internal_leading
= 0;
1629 memset(&fs
, 0, sizeof(fs
));
1631 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
1633 fs
.fsCsb
[0] = pOS2
->ulCodePageRange1
;
1634 fs
.fsCsb
[1] = pOS2
->ulCodePageRange2
;
1635 fs
.fsUsb
[0] = pOS2
->ulUnicodeRange1
;
1636 fs
.fsUsb
[1] = pOS2
->ulUnicodeRange2
;
1637 fs
.fsUsb
[2] = pOS2
->ulUnicodeRange3
;
1638 fs
.fsUsb
[3] = pOS2
->ulUnicodeRange4
;
1639 if(pOS2
->version
== 0) {
1642 if(pFT_Get_First_Char( ft_face
, &dummy
) < 0x100)
1643 fs
.fsCsb
[0] |= FS_LATIN1
;
1645 fs
.fsCsb
[0] |= FS_SYMBOL
;
1648 else if(!pFT_Get_WinFNT_Header(ft_face
, &winfnt_header
)) {
1650 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header
.pixel_height
, winfnt_header
.charset
,
1651 winfnt_header
.vertical_resolution
,winfnt_header
.horizontal_resolution
, winfnt_header
.nominal_point_size
);
1652 if(TranslateCharsetInfo((DWORD
*)(UINT_PTR
)winfnt_header
.charset
, &csi
, TCI_SRCCHARSET
))
1654 internal_leading
= winfnt_header
.internal_leading
;
1657 face_elem_ptr
= list_head(&family
->faces
);
1658 while(face_elem_ptr
) {
1659 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1660 face_elem_ptr
= list_next(&family
->faces
, face_elem_ptr
);
1661 if(!strcmpiW(face
->StyleName
, StyleW
) &&
1662 (FT_IS_SCALABLE(ft_face
) || ((size
->y_ppem
== face
->size
.y_ppem
) && !memcmp(&fs
, &face
->fs
, sizeof(fs
)) ))) {
1663 TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1664 debugstr_w(family
->FamilyName
), debugstr_w(StyleW
),
1665 face
->font_version
, pHeader
? pHeader
->Font_Revision
: 0);
1668 TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
1669 HeapFree(GetProcessHeap(), 0, StyleW
);
1670 pFT_Done_Face(ft_face
);
1673 if(!pHeader
|| pHeader
->Font_Revision
<= face
->font_version
) {
1674 TRACE("Original font is newer so skipping this one\n");
1675 HeapFree(GetProcessHeap(), 0, StyleW
);
1676 pFT_Done_Face(ft_face
);
1679 TRACE("Replacing original with this one\n");
1680 list_remove(&face
->entry
);
1681 HeapFree(GetProcessHeap(), 0, face
->file
);
1682 HeapFree(GetProcessHeap(), 0, face
->StyleName
);
1683 HeapFree(GetProcessHeap(), 0, face
->FullName
);
1684 HeapFree(GetProcessHeap(), 0, face
);
1689 face
= HeapAlloc(GetProcessHeap(), 0, sizeof(*face
));
1690 face
->cached_enum_data
= NULL
;
1691 face
->StyleName
= StyleW
;
1692 face
->FullName
= get_face_name(ft_face
, TT_NAME_ID_FULL_NAME
, TT_MS_LANGID_ENGLISH_UNITED_STATES
);
1695 face
->file
= strdupA(file
);
1696 face
->font_data_ptr
= NULL
;
1697 face
->font_data_size
= 0;
1702 face
->font_data_ptr
= font_data_ptr
;
1703 face
->font_data_size
= font_data_size
;
1705 face
->face_index
= face_index
;
1707 if (ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
)
1708 face
->ntmFlags
|= NTM_ITALIC
;
1709 if (ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
)
1710 face
->ntmFlags
|= NTM_BOLD
;
1711 if (face
->ntmFlags
== 0) face
->ntmFlags
= NTM_REGULAR
;
1712 face
->font_version
= pHeader
? pHeader
->Font_Revision
: 0;
1713 face
->family
= family
;
1714 face
->external
= (flags
& ADDFONT_EXTERNAL_FONT
) ? TRUE
: FALSE
;
1716 memset(&face
->fs_links
, 0, sizeof(face
->fs_links
));
1718 if(FT_IS_SCALABLE(ft_face
)) {
1719 memset(&face
->size
, 0, sizeof(face
->size
));
1720 face
->scalable
= TRUE
;
1722 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1723 size
->height
, size
->width
, size
->size
>> 6,
1724 size
->x_ppem
>> 6, size
->y_ppem
>> 6);
1725 face
->size
.height
= size
->height
;
1726 face
->size
.width
= size
->width
;
1727 face
->size
.size
= size
->size
;
1728 face
->size
.x_ppem
= size
->x_ppem
;
1729 face
->size
.y_ppem
= size
->y_ppem
;
1730 face
->size
.internal_leading
= internal_leading
;
1731 face
->scalable
= FALSE
;
1734 /* check for the presence of the 'CFF ' table to check if the font is Type1 */
1736 if (!pFT_Load_Sfnt_Table(ft_face
, FT_MAKE_TAG('C','F','F',' '), 0, NULL
, &tmp_size
))
1738 TRACE("Font %s/%p is OTF Type1\n", wine_dbgstr_a(file
), font_data_ptr
);
1739 face
->ntmFlags
|= NTM_PS_OPENTYPE
;
1742 TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1743 face
->fs
.fsCsb
[0], face
->fs
.fsCsb
[1],
1744 face
->fs
.fsUsb
[0], face
->fs
.fsUsb
[1],
1745 face
->fs
.fsUsb
[2], face
->fs
.fsUsb
[3]);
1748 if(face
->fs
.fsCsb
[0] == 0) { /* let's see if we can find any interesting cmaps */
1749 for(i
= 0; i
< ft_face
->num_charmaps
; i
++) {
1750 switch(ft_face
->charmaps
[i
]->encoding
) {
1751 case FT_ENCODING_UNICODE
:
1752 case FT_ENCODING_APPLE_ROMAN
:
1753 face
->fs
.fsCsb
[0] |= FS_LATIN1
;
1755 case FT_ENCODING_MS_SYMBOL
:
1756 face
->fs
.fsCsb
[0] |= FS_SYMBOL
;
1764 if(flags
& ADDFONT_ADD_TO_CACHE
)
1765 add_face_to_cache(face
);
1767 AddFaceToFamily(face
, family
);
1769 } while(!FT_IS_SCALABLE(ft_face
) && ++bitmap_num
< ft_face
->num_fixed_sizes
);
1771 num_faces
= ft_face
->num_faces
;
1772 pFT_Done_Face(ft_face
);
1773 TRACE("Added font %s %s\n", debugstr_w(family
->FamilyName
),
1774 debugstr_w(StyleW
));
1775 } while(num_faces
> ++face_index
);
1779 static INT
AddFontFileToList(const char *file
, char *fake_family
, const WCHAR
*target_family
, DWORD flags
)
1781 return AddFontToList(file
, NULL
, 0, fake_family
, target_family
, flags
);
1784 static void DumpFontList(void)
1788 struct list
*family_elem_ptr
, *face_elem_ptr
;
1790 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1791 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1792 TRACE("Family: %s\n", debugstr_w(family
->FamilyName
));
1793 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
1794 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1795 TRACE("\t%s\t%08x", debugstr_w(face
->StyleName
), face
->fs
.fsCsb
[0]);
1797 TRACE(" %d", face
->size
.height
);
1804 /***********************************************************
1805 * The replacement list is a way to map an entire font
1806 * family onto another family. For example adding
1808 * [HKCU\Software\Wine\Fonts\Replacements]
1809 * "Wingdings"="Winedings"
1811 * would enumerate the Winedings font both as Winedings and
1812 * Wingdings. However if a real Wingdings font is present the
1813 * replacement does not take place.
1816 static void LoadReplaceList(void)
1819 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
1824 struct list
*family_elem_ptr
, *face_elem_ptr
;
1827 /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1828 if(RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts\\Replacements", &hkey
) == ERROR_SUCCESS
)
1830 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
1831 &valuelen
, &datalen
, NULL
, NULL
);
1833 valuelen
++; /* returned value doesn't include room for '\0' */
1834 value
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
1835 data
= HeapAlloc(GetProcessHeap(), 0, datalen
);
1839 while(RegEnumValueW(hkey
, i
++, value
, &vlen
, NULL
, &type
, data
,
1840 &dlen
) == ERROR_SUCCESS
) {
1841 TRACE("Got %s=%s\n", debugstr_w(value
), debugstr_w(data
));
1842 /* "NewName"="Oldname" */
1843 WideCharToMultiByte(CP_ACP
, 0, value
, -1, familyA
, sizeof(familyA
), NULL
, NULL
);
1845 if(!find_family_from_name(value
))
1847 /* Find the old family and hence all of the font files
1849 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
1850 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
1851 if(!strcmpiW(family
->FamilyName
, data
)) {
1852 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
1853 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
1854 TRACE("mapping %s %s to %s\n", debugstr_w(family
->FamilyName
),
1855 debugstr_w(face
->StyleName
), familyA
);
1856 /* Now add a new entry with the new family name */
1857 AddFontToList(face
->file
, face
->font_data_ptr
, face
->font_data_size
,
1858 familyA
, family
->FamilyName
,
1859 ADDFONT_FORCE_BITMAP
| (face
->external
? ADDFONT_EXTERNAL_FONT
: 0));
1865 /* reset dlen and vlen */
1869 HeapFree(GetProcessHeap(), 0, data
);
1870 HeapFree(GetProcessHeap(), 0, value
);
1875 /*************************************************************
1878 static BOOL
init_system_links(void)
1882 DWORD type
, max_val
, max_data
, val_len
, data_len
, index
;
1883 WCHAR
*value
, *data
;
1884 WCHAR
*entry
, *next
;
1885 SYSTEM_LINKS
*font_link
, *system_font_link
;
1886 CHILD_FONT
*child_font
;
1887 static const WCHAR tahoma_ttf
[] = {'t','a','h','o','m','a','.','t','t','f',0};
1888 static const WCHAR System
[] = {'S','y','s','t','e','m',0};
1894 if(RegOpenKeyW(HKEY_LOCAL_MACHINE
, system_link
, &hkey
) == ERROR_SUCCESS
)
1896 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, &max_val
, &max_data
, NULL
, NULL
);
1897 value
= HeapAlloc(GetProcessHeap(), 0, (max_val
+ 1) * sizeof(WCHAR
));
1898 data
= HeapAlloc(GetProcessHeap(), 0, max_data
);
1899 val_len
= max_val
+ 1;
1900 data_len
= max_data
;
1902 while(RegEnumValueW(hkey
, index
++, value
, &val_len
, NULL
, &type
, (LPBYTE
)data
, &data_len
) == ERROR_SUCCESS
)
1904 memset(&fs
, 0, sizeof(fs
));
1905 psub
= get_font_subst(&font_subst_list
, value
, -1);
1906 /* Don't store fonts that are only substitutes for other fonts */
1909 TRACE("%s: SystemLink entry for substituted font, ignoring\n", debugstr_w(value
));
1912 font_link
= HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link
));
1913 font_link
->font_name
= strdupW(value
);
1914 list_init(&font_link
->links
);
1915 for(entry
= data
; (char*)entry
< (char*)data
+ data_len
&& *entry
!= 0; entry
= next
)
1918 CHILD_FONT
*child_font
;
1920 TRACE("%s: %s\n", debugstr_w(value
), debugstr_w(entry
));
1922 next
= entry
+ strlenW(entry
) + 1;
1924 face_name
= strchrW(entry
, ',');
1928 while(isspaceW(*face_name
))
1931 psub
= get_font_subst(&font_subst_list
, face_name
, -1);
1933 face_name
= psub
->to
.name
;
1935 face
= find_face_from_filename(entry
, face_name
);
1938 TRACE("Unable to find file %s face name %s\n", debugstr_w(entry
), debugstr_w(face_name
));
1942 child_font
= HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font
));
1943 child_font
->face
= face
;
1944 child_font
->font
= NULL
;
1945 fs
.fsCsb
[0] |= face
->fs
.fsCsb
[0];
1946 fs
.fsCsb
[1] |= face
->fs
.fsCsb
[1];
1947 TRACE("Adding file %s index %ld\n", child_font
->face
->file
, child_font
->face
->face_index
);
1948 list_add_tail(&font_link
->links
, &child_font
->entry
);
1950 family
= find_family_from_name(font_link
->font_name
);
1953 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
1955 face
->fs_links
= fs
;
1958 list_add_tail(&system_links
, &font_link
->entry
);
1960 val_len
= max_val
+ 1;
1961 data_len
= max_data
;
1964 HeapFree(GetProcessHeap(), 0, value
);
1965 HeapFree(GetProcessHeap(), 0, data
);
1969 /* Explicitly add an entry for the system font, this links to Tahoma and any links
1972 system_font_link
= HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link
));
1973 system_font_link
->font_name
= strdupW(System
);
1974 list_init(&system_font_link
->links
);
1976 face
= find_face_from_filename(tahoma_ttf
, Tahoma
);
1979 child_font
= HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font
));
1980 child_font
->face
= face
;
1981 child_font
->font
= NULL
;
1982 TRACE("Found Tahoma in %s index %ld\n", child_font
->face
->file
, child_font
->face
->face_index
);
1983 list_add_tail(&system_font_link
->links
, &child_font
->entry
);
1985 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
1987 if(!strcmpiW(font_link
->font_name
, Tahoma
))
1989 CHILD_FONT
*font_link_entry
;
1990 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
1992 CHILD_FONT
*new_child
;
1993 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
1994 new_child
->face
= font_link_entry
->face
;
1995 new_child
->font
= NULL
;
1996 list_add_tail(&system_font_link
->links
, &new_child
->entry
);
2001 list_add_tail(&system_links
, &system_font_link
->entry
);
2005 static BOOL
ReadFontDir(const char *dirname
, BOOL external_fonts
)
2008 struct dirent
*dent
;
2009 char path
[MAX_PATH
];
2011 TRACE("Loading fonts from %s\n", debugstr_a(dirname
));
2013 dir
= opendir(dirname
);
2015 WARN("Can't open directory %s\n", debugstr_a(dirname
));
2018 while((dent
= readdir(dir
)) != NULL
) {
2019 struct stat statbuf
;
2021 if(!strcmp(dent
->d_name
, ".") || !strcmp(dent
->d_name
, ".."))
2024 TRACE("Found %s in %s\n", debugstr_a(dent
->d_name
), debugstr_a(dirname
));
2026 sprintf(path
, "%s/%s", dirname
, dent
->d_name
);
2028 if(stat(path
, &statbuf
) == -1)
2030 WARN("Can't stat %s\n", debugstr_a(path
));
2033 if(S_ISDIR(statbuf
.st_mode
))
2034 ReadFontDir(path
, external_fonts
);
2037 DWORD addfont_flags
= ADDFONT_ADD_TO_CACHE
;
2038 if(external_fonts
) addfont_flags
|= ADDFONT_EXTERNAL_FONT
;
2039 AddFontFileToList(path
, NULL
, NULL
, addfont_flags
);
2046 static void load_fontconfig_fonts(void)
2048 #ifdef SONAME_LIBFONTCONFIG
2049 void *fc_handle
= NULL
;
2058 fc_handle
= wine_dlopen(SONAME_LIBFONTCONFIG
, RTLD_NOW
, NULL
, 0);
2060 TRACE("Wine cannot find the fontconfig library (%s).\n",
2061 SONAME_LIBFONTCONFIG
);
2064 #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;}
2065 LOAD_FUNCPTR(FcConfigGetCurrent
);
2066 LOAD_FUNCPTR(FcFontList
);
2067 LOAD_FUNCPTR(FcFontSetDestroy
);
2068 LOAD_FUNCPTR(FcInit
);
2069 LOAD_FUNCPTR(FcObjectSetAdd
);
2070 LOAD_FUNCPTR(FcObjectSetCreate
);
2071 LOAD_FUNCPTR(FcObjectSetDestroy
);
2072 LOAD_FUNCPTR(FcPatternCreate
);
2073 LOAD_FUNCPTR(FcPatternDestroy
);
2074 LOAD_FUNCPTR(FcPatternGetBool
);
2075 LOAD_FUNCPTR(FcPatternGetString
);
2078 if(!pFcInit()) return;
2080 config
= pFcConfigGetCurrent();
2081 pat
= pFcPatternCreate();
2082 os
= pFcObjectSetCreate();
2083 pFcObjectSetAdd(os
, FC_FILE
);
2084 pFcObjectSetAdd(os
, FC_SCALABLE
);
2085 fontset
= pFcFontList(config
, pat
, os
);
2086 if(!fontset
) return;
2087 for(i
= 0; i
< fontset
->nfont
; i
++) {
2090 if(pFcPatternGetString(fontset
->fonts
[i
], FC_FILE
, 0, (FcChar8
**)&file
) != FcResultMatch
)
2092 TRACE("fontconfig: %s\n", file
);
2094 /* We're just interested in OT/TT fonts for now, so this hack just
2095 picks up the scalable fonts without extensions .pf[ab] to save time
2096 loading every other font */
2098 if(pFcPatternGetBool(fontset
->fonts
[i
], FC_SCALABLE
, 0, &scalable
) == FcResultMatch
&& !scalable
)
2100 TRACE("not scalable\n");
2104 len
= strlen( file
);
2105 if(len
< 4) continue;
2106 ext
= &file
[ len
- 3 ];
2107 if(strcasecmp(ext
, "pfa") && strcasecmp(ext
, "pfb"))
2108 AddFontFileToList(file
, NULL
, NULL
, ADDFONT_EXTERNAL_FONT
| ADDFONT_ADD_TO_CACHE
);
2110 pFcFontSetDestroy(fontset
);
2111 pFcObjectSetDestroy(os
);
2112 pFcPatternDestroy(pat
);
2118 static BOOL
load_font_from_data_dir(LPCWSTR file
)
2121 const char *data_dir
= wine_get_data_dir();
2123 if (!data_dir
) data_dir
= wine_get_build_dir();
2130 len
= WideCharToMultiByte(CP_UNIXCP
, 0, file
, -1, NULL
, 0, NULL
, NULL
);
2132 unix_name
= HeapAlloc(GetProcessHeap(), 0, strlen(data_dir
) + len
+ sizeof("/fonts/"));
2134 strcpy(unix_name
, data_dir
);
2135 strcat(unix_name
, "/fonts/");
2137 WideCharToMultiByte(CP_UNIXCP
, 0, file
, -1, unix_name
+ strlen(unix_name
), len
, NULL
, NULL
);
2139 EnterCriticalSection( &freetype_cs
);
2140 ret
= AddFontFileToList(unix_name
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
| ADDFONT_ADD_TO_CACHE
);
2141 LeaveCriticalSection( &freetype_cs
);
2142 HeapFree(GetProcessHeap(), 0, unix_name
);
2147 static BOOL
load_font_from_winfonts_dir(LPCWSTR file
)
2149 static const WCHAR slashW
[] = {'\\','\0'};
2151 WCHAR windowsdir
[MAX_PATH
];
2154 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
2155 strcatW(windowsdir
, fontsW
);
2156 strcatW(windowsdir
, slashW
);
2157 strcatW(windowsdir
, file
);
2158 if ((unixname
= wine_get_unix_file_name(windowsdir
))) {
2159 EnterCriticalSection( &freetype_cs
);
2160 ret
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2161 LeaveCriticalSection( &freetype_cs
);
2162 HeapFree(GetProcessHeap(), 0, unixname
);
2167 static void load_system_fonts(void)
2170 WCHAR data
[MAX_PATH
], windowsdir
[MAX_PATH
], pathW
[MAX_PATH
];
2171 const WCHAR
* const *value
;
2173 static const WCHAR fmtW
[] = {'%','s','\\','%','s','\0'};
2176 if(RegOpenKeyW(HKEY_CURRENT_CONFIG
, system_fonts_reg_key
, &hkey
) == ERROR_SUCCESS
) {
2177 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
2178 strcatW(windowsdir
, fontsW
);
2179 for(value
= SystemFontValues
; *value
; value
++) {
2180 dlen
= sizeof(data
);
2181 if(RegQueryValueExW(hkey
, *value
, 0, &type
, (void*)data
, &dlen
) == ERROR_SUCCESS
&&
2185 sprintfW(pathW
, fmtW
, windowsdir
, data
);
2186 if((unixname
= wine_get_unix_file_name(pathW
))) {
2187 added
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
| ADDFONT_ADD_TO_CACHE
);
2188 HeapFree(GetProcessHeap(), 0, unixname
);
2191 load_font_from_data_dir(data
);
2198 /*************************************************************
2200 * This adds registry entries for any externally loaded fonts
2201 * (fonts from fontconfig or FontDirs). It also deletes entries
2202 * of no longer existing fonts.
2205 static void update_reg_entries(void)
2207 HKEY winnt_key
= 0, win9x_key
= 0, external_key
= 0;
2212 struct list
*family_elem_ptr
, *face_elem_ptr
;
2214 static const WCHAR TrueType
[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
2215 static const WCHAR spaceW
[] = {' ', '\0'};
2218 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
,
2219 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &winnt_key
, NULL
) != ERROR_SUCCESS
) {
2220 ERR("Can't create Windows font reg key\n");
2224 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
,
2225 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &win9x_key
, NULL
) != ERROR_SUCCESS
) {
2226 ERR("Can't create Windows font reg key\n");
2230 if(RegCreateKeyExW(HKEY_CURRENT_USER
, external_fonts_reg_key
,
2231 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &external_key
, NULL
) != ERROR_SUCCESS
) {
2232 ERR("Can't create external font reg key\n");
2236 /* enumerate the fonts and add external ones to the two keys */
2238 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
2239 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
2240 len_fam
= strlenW(family
->FamilyName
) + sizeof(TrueType
) / sizeof(WCHAR
) + 1;
2241 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
2242 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
2243 if(!face
->external
) continue;
2245 if (!(face
->ntmFlags
& NTM_REGULAR
))
2246 len
= len_fam
+ strlenW(face
->StyleName
) + 1;
2247 valueW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2248 strcpyW(valueW
, family
->FamilyName
);
2249 if(len
!= len_fam
) {
2250 strcatW(valueW
, spaceW
);
2251 strcatW(valueW
, face
->StyleName
);
2253 strcatW(valueW
, TrueType
);
2255 file
= wine_get_dos_file_name(face
->file
);
2257 len
= strlenW(file
) + 1;
2260 if((path
= strrchr(face
->file
, '/')) == NULL
)
2264 len
= MultiByteToWideChar(CP_ACP
, 0, path
, -1, NULL
, 0);
2266 file
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2267 MultiByteToWideChar(CP_ACP
, 0, path
, -1, file
, len
);
2269 RegSetValueExW(winnt_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2270 RegSetValueExW(win9x_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2271 RegSetValueExW(external_key
, valueW
, 0, REG_SZ
, (BYTE
*)file
, len
* sizeof(WCHAR
));
2273 HeapFree(GetProcessHeap(), 0, file
);
2274 HeapFree(GetProcessHeap(), 0, valueW
);
2278 if(external_key
) RegCloseKey(external_key
);
2279 if(win9x_key
) RegCloseKey(win9x_key
);
2280 if(winnt_key
) RegCloseKey(winnt_key
);
2284 static void delete_external_font_keys(void)
2286 HKEY winnt_key
= 0, win9x_key
= 0, external_key
= 0;
2287 DWORD dlen
, vlen
, datalen
, valuelen
, i
, type
;
2291 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
,
2292 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &winnt_key
, NULL
) != ERROR_SUCCESS
) {
2293 ERR("Can't create Windows font reg key\n");
2297 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
,
2298 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &win9x_key
, NULL
) != ERROR_SUCCESS
) {
2299 ERR("Can't create Windows font reg key\n");
2303 if(RegCreateKeyW(HKEY_CURRENT_USER
, external_fonts_reg_key
, &external_key
) != ERROR_SUCCESS
) {
2304 ERR("Can't create external font reg key\n");
2308 /* Delete all external fonts added last time */
2310 RegQueryInfoKeyW(external_key
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2311 &valuelen
, &datalen
, NULL
, NULL
);
2312 valuelen
++; /* returned value doesn't include room for '\0' */
2313 valueW
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
2314 data
= HeapAlloc(GetProcessHeap(), 0, datalen
* sizeof(WCHAR
));
2316 dlen
= datalen
* sizeof(WCHAR
);
2319 while(RegEnumValueW(external_key
, i
++, valueW
, &vlen
, NULL
, &type
, data
,
2320 &dlen
) == ERROR_SUCCESS
) {
2322 RegDeleteValueW(winnt_key
, valueW
);
2323 RegDeleteValueW(win9x_key
, valueW
);
2324 /* reset dlen and vlen */
2328 HeapFree(GetProcessHeap(), 0, data
);
2329 HeapFree(GetProcessHeap(), 0, valueW
);
2331 /* Delete the old external fonts key */
2332 RegCloseKey(external_key
);
2333 RegDeleteKeyW(HKEY_CURRENT_USER
, external_fonts_reg_key
);
2336 if(win9x_key
) RegCloseKey(win9x_key
);
2337 if(winnt_key
) RegCloseKey(winnt_key
);
2340 /*************************************************************
2341 * WineEngAddFontResourceEx
2344 INT
WineEngAddFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
2350 if (ft_handle
) /* do it only if we have freetype up and running */
2355 FIXME("Ignoring flags %x\n", flags
);
2357 if((unixname
= wine_get_unix_file_name(file
)))
2359 DWORD addfont_flags
= ADDFONT_FORCE_BITMAP
;
2361 if(!(flags
& FR_PRIVATE
)) addfont_flags
|= ADDFONT_ADD_TO_CACHE
;
2362 EnterCriticalSection( &freetype_cs
);
2363 ret
= AddFontFileToList(unixname
, NULL
, NULL
, addfont_flags
);
2364 LeaveCriticalSection( &freetype_cs
);
2365 HeapFree(GetProcessHeap(), 0, unixname
);
2367 if (!ret
&& !strchrW(file
, '\\')) {
2368 /* Try in %WINDIR%/fonts, needed for Fotobuch Designer */
2369 ret
= load_font_from_winfonts_dir(file
);
2371 /* Try in datadir/fonts (or builddir/fonts),
2372 * needed for Magic the Gathering Online
2374 ret
= load_font_from_data_dir(file
);
2381 /*************************************************************
2382 * WineEngAddFontMemResourceEx
2385 HANDLE
WineEngAddFontMemResourceEx(PVOID pbFont
, DWORD cbFont
, PVOID pdv
, DWORD
*pcFonts
)
2389 if (ft_handle
) /* do it only if we have freetype up and running */
2391 PVOID pFontCopy
= HeapAlloc(GetProcessHeap(), 0, cbFont
);
2393 TRACE("Copying %d bytes of data from %p to %p\n", cbFont
, pbFont
, pFontCopy
);
2394 memcpy(pFontCopy
, pbFont
, cbFont
);
2396 EnterCriticalSection( &freetype_cs
);
2397 *pcFonts
= AddFontToList(NULL
, pFontCopy
, cbFont
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
);
2398 LeaveCriticalSection( &freetype_cs
);
2402 TRACE("AddFontToList failed\n");
2403 HeapFree(GetProcessHeap(), 0, pFontCopy
);
2406 /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
2407 * For now return something unique but quite random
2409 TRACE("Returning handle %lx\n", ((INT_PTR
)pFontCopy
)^0x87654321);
2410 return (HANDLE
)(((INT_PTR
)pFontCopy
)^0x87654321);
2417 /*************************************************************
2418 * WineEngRemoveFontResourceEx
2421 BOOL
WineEngRemoveFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
2424 FIXME("(%s, %x, %p): stub\n", debugstr_w(file
), flags
, pdv
);
2428 static const struct nls_update_font_list
2430 UINT ansi_cp
, oem_cp
;
2431 const char *oem
, *fixed
, *system
;
2432 const char *courier
, *serif
, *small
, *sserif
;
2433 /* these are for font substitutes */
2434 const char *shelldlg
, *tmsrmn
;
2435 const char *fixed_0
, *system_0
, *courier_0
, *serif_0
, *small_0
, *sserif_0
,
2439 const char *from
, *to
;
2440 } arial_0
, courier_new_0
, times_new_roman_0
;
2441 } nls_update_font_list
[] =
2443 /* Latin 1 (United States) */
2444 { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
2445 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2446 "Tahoma","Times New Roman",
2447 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2450 /* Latin 1 (Multilingual) */
2451 { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
2452 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2453 "Tahoma","Times New Roman", /* FIXME unverified */
2454 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2457 /* Eastern Europe */
2458 { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
2459 "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
2460 "Tahoma","Times New Roman", /* FIXME unverified */
2461 "Fixedsys,238", "System,238",
2462 "Courier New,238", "MS Serif,238", "Small Fonts,238",
2463 "MS Sans Serif,238", "MS Sans Serif,238", "MS Serif,238",
2464 { "Arial CE,0", "Arial,238" },
2465 { "Courier New CE,0", "Courier New,238" },
2466 { "Times New Roman CE,0", "Times New Roman,238" }
2469 { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
2470 "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
2471 "Tahoma","Times New Roman", /* FIXME unverified */
2472 "Fixedsys,204", "System,204",
2473 "Courier New,204", "MS Serif,204", "Small Fonts,204",
2474 "MS Sans Serif,204", "MS Sans Serif,204", "MS Serif,204",
2475 { "Arial Cyr,0", "Arial,204" },
2476 { "Courier New Cyr,0", "Courier New,204" },
2477 { "Times New Roman Cyr,0", "Times New Roman,204" }
2480 { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
2481 "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
2482 "Tahoma","Times New Roman", /* FIXME unverified */
2483 "Fixedsys,161", "System,161",
2484 "Courier New,161", "MS Serif,161", "Small Fonts,161",
2485 "MS Sans Serif,161", "MS Sans Serif,161", "MS Serif,161",
2486 { "Arial Greek,0", "Arial,161" },
2487 { "Courier New Greek,0", "Courier New,161" },
2488 { "Times New Roman Greek,0", "Times New Roman,161" }
2491 { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
2492 "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
2493 "Tahoma","Times New Roman", /* FIXME unverified */
2494 "Fixedsys,162", "System,162",
2495 "Courier New,162", "MS Serif,162", "Small Fonts,162",
2496 "MS Sans Serif,162", "MS Sans Serif,162", "MS Serif,162",
2497 { "Arial Tur,0", "Arial,162" },
2498 { "Courier New Tur,0", "Courier New,162" },
2499 { "Times New Roman Tur,0", "Times New Roman,162" }
2502 { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
2503 "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
2504 "Tahoma","Times New Roman", /* FIXME unverified */
2505 "Fixedsys,177", "System,177",
2506 "Courier New,177", "MS Serif,177", "Small Fonts,177",
2507 "MS Sans Serif,177", "MS Sans Serif,177", "MS Serif,177",
2511 { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
2512 "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
2513 "Tahoma","Times New Roman", /* FIXME unverified */
2514 "Fixedsys,178", "System,178",
2515 "Courier New,178", "MS Serif,178", "Small Fonts,178",
2516 "MS Sans Serif,178", "MS Sans Serif,178", "MS Serif,178",
2520 { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
2521 "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
2522 "Tahoma","Times New Roman", /* FIXME unverified */
2523 "Fixedsys,186", "System,186",
2524 "Courier New,186", "MS Serif,186", "Small Fonts,186",
2525 "MS Sans Serif,186", "MS Sans Serif,186", "MS Serif,186",
2526 { "Arial Baltic,0", "Arial,186" },
2527 { "Courier New Baltic,0", "Courier New,186" },
2528 { "Times New Roman Baltic,0", "Times New Roman,186" }
2531 { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
2532 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2533 "Tahoma","Times New Roman", /* FIXME unverified */
2534 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2538 { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
2539 "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
2540 "Tahoma","Times New Roman", /* FIXME unverified */
2541 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2545 { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
2546 "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
2547 "MS UI Gothic","MS Serif",
2548 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2551 /* Chinese Simplified */
2552 { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
2553 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2554 "SimSun", "NSimSun",
2555 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2559 { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
2560 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2562 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2565 /* Chinese Traditional */
2566 { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
2567 "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2568 "PMingLiU", "MingLiU",
2569 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2574 static const WCHAR
*font_links_list
[] =
2576 Lucida_Sans_Unicode
,
2577 Microsoft_Sans_Serif
,
2581 static const struct font_links_defaults_list
2583 /* Keyed off substitution for "MS Shell Dlg" */
2584 const WCHAR
*shelldlg
;
2585 /* Maximum of four substitutes, plus terminating NULL pointer */
2586 const WCHAR
*substitutes
[5];
2587 } font_links_defaults_list
[] =
2589 /* Non East-Asian */
2590 { Tahoma
, /* FIXME unverified ordering */
2591 { MS_UI_Gothic
, SimSun
, Gulim
, PMingLiU
, NULL
}
2593 /* Below lists are courtesy of
2594 * http://blogs.msdn.com/michkap/archive/2005/06/18/430507.aspx
2598 { MS_UI_Gothic
, PMingLiU
, SimSun
, Gulim
, NULL
}
2600 /* Chinese Simplified */
2602 { SimSun
, PMingLiU
, MS_UI_Gothic
, Batang
, NULL
}
2606 { Gulim
, PMingLiU
, MS_UI_Gothic
, SimSun
, NULL
}
2608 /* Chinese Traditional */
2610 { PMingLiU
, SimSun
, MS_UI_Gothic
, Batang
, NULL
}
2614 static inline BOOL
is_dbcs_ansi_cp(UINT ansi_cp
)
2616 return ( ansi_cp
== 932 /* CP932 for Japanese */
2617 || ansi_cp
== 936 /* CP936 for Chinese Simplified */
2618 || ansi_cp
== 949 /* CP949 for Korean */
2619 || ansi_cp
== 950 ); /* CP950 for Chinese Traditional */
2622 static inline HKEY
create_fonts_NT_registry_key(void)
2626 RegCreateKeyExW(HKEY_LOCAL_MACHINE
, winnt_font_reg_key
, 0, NULL
,
2627 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2631 static inline HKEY
create_fonts_9x_registry_key(void)
2635 RegCreateKeyExW(HKEY_LOCAL_MACHINE
, win9x_font_reg_key
, 0, NULL
,
2636 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2640 static inline HKEY
create_config_fonts_registry_key(void)
2644 RegCreateKeyExW(HKEY_CURRENT_CONFIG
, system_fonts_reg_key
, 0, NULL
,
2645 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
);
2649 static void add_font_list(HKEY hkey
, const struct nls_update_font_list
*fl
)
2651 RegSetValueExA(hkey
, "Courier", 0, REG_SZ
, (const BYTE
*)fl
->courier
, strlen(fl
->courier
)+1);
2652 RegSetValueExA(hkey
, "MS Serif", 0, REG_SZ
, (const BYTE
*)fl
->serif
, strlen(fl
->serif
)+1);
2653 RegSetValueExA(hkey
, "MS Sans Serif", 0, REG_SZ
, (const BYTE
*)fl
->sserif
, strlen(fl
->sserif
)+1);
2654 RegSetValueExA(hkey
, "Small Fonts", 0, REG_SZ
, (const BYTE
*)fl
->small
, strlen(fl
->small
)+1);
2657 static void set_value_key(HKEY hkey
, const char *name
, const char *value
)
2660 RegSetValueExA(hkey
, name
, 0, REG_SZ
, (const BYTE
*)value
, strlen(value
) + 1);
2662 RegDeleteValueA(hkey
, name
);
2665 static void update_font_info(void)
2667 char buf
[40], cpbuf
[40];
2670 UINT i
, ansi_cp
= 0, oem_cp
= 0;
2673 if (RegCreateKeyExA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts", 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &hkey
, NULL
) != ERROR_SUCCESS
)
2676 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_IDEFAULTANSICODEPAGE
|LOCALE_RETURN_NUMBER
|LOCALE_NOUSEROVERRIDE
,
2677 (WCHAR
*)&ansi_cp
, sizeof(ansi_cp
)/sizeof(WCHAR
));
2678 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_IDEFAULTCODEPAGE
|LOCALE_RETURN_NUMBER
|LOCALE_NOUSEROVERRIDE
,
2679 (WCHAR
*)&oem_cp
, sizeof(oem_cp
)/sizeof(WCHAR
));
2680 sprintf( cpbuf
, "%u,%u", ansi_cp
, oem_cp
);
2682 /* Setup Default_Fallback usage for DBCS ANSI codepages */
2683 if (is_dbcs_ansi_cp(ansi_cp
))
2684 use_default_fallback
= TRUE
;
2687 if (RegQueryValueExA(hkey
, "Codepages", 0, &type
, (BYTE
*)buf
, &len
) == ERROR_SUCCESS
&& type
== REG_SZ
)
2689 if (!strcmp( buf
, cpbuf
)) /* already set correctly */
2694 TRACE("updating registry, codepages changed %s -> %u,%u\n", buf
, ansi_cp
, oem_cp
);
2696 else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp
, oem_cp
);
2698 RegSetValueExA(hkey
, "Codepages", 0, REG_SZ
, (const BYTE
*)cpbuf
, strlen(cpbuf
)+1);
2701 for (i
= 0; i
< sizeof(nls_update_font_list
)/sizeof(nls_update_font_list
[0]); i
++)
2705 if (nls_update_font_list
[i
].ansi_cp
== ansi_cp
&&
2706 nls_update_font_list
[i
].oem_cp
== oem_cp
)
2708 hkey
= create_config_fonts_registry_key();
2709 RegSetValueExA(hkey
, "OEMFONT.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].oem
, strlen(nls_update_font_list
[i
].oem
)+1);
2710 RegSetValueExA(hkey
, "FIXEDFON.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].fixed
, strlen(nls_update_font_list
[i
].fixed
)+1);
2711 RegSetValueExA(hkey
, "FONTS.FON", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].system
, strlen(nls_update_font_list
[i
].system
)+1);
2714 hkey
= create_fonts_NT_registry_key();
2715 add_font_list(hkey
, &nls_update_font_list
[i
]);
2718 hkey
= create_fonts_9x_registry_key();
2719 add_font_list(hkey
, &nls_update_font_list
[i
]);
2722 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey
))
2724 RegSetValueExA(hkey
, "MS Shell Dlg", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].shelldlg
,
2725 strlen(nls_update_font_list
[i
].shelldlg
)+1);
2726 RegSetValueExA(hkey
, "Tms Rmn", 0, REG_SZ
, (const BYTE
*)nls_update_font_list
[i
].tmsrmn
,
2727 strlen(nls_update_font_list
[i
].tmsrmn
)+1);
2729 set_value_key(hkey
, "Fixedsys,0", nls_update_font_list
[i
].fixed_0
);
2730 set_value_key(hkey
, "System,0", nls_update_font_list
[i
].system_0
);
2731 set_value_key(hkey
, "Courier,0", nls_update_font_list
[i
].courier_0
);
2732 set_value_key(hkey
, "MS Serif,0", nls_update_font_list
[i
].serif_0
);
2733 set_value_key(hkey
, "Small Fonts,0", nls_update_font_list
[i
].small_0
);
2734 set_value_key(hkey
, "MS Sans Serif,0", nls_update_font_list
[i
].sserif_0
);
2735 set_value_key(hkey
, "Helv,0", nls_update_font_list
[i
].helv_0
);
2736 set_value_key(hkey
, "Tms Rmn,0", nls_update_font_list
[i
].tmsrmn_0
);
2738 set_value_key(hkey
, nls_update_font_list
[i
].arial_0
.from
, nls_update_font_list
[i
].arial_0
.to
);
2739 set_value_key(hkey
, nls_update_font_list
[i
].courier_new_0
.from
, nls_update_font_list
[i
].courier_new_0
.to
);
2740 set_value_key(hkey
, nls_update_font_list
[i
].times_new_roman_0
.from
, nls_update_font_list
[i
].times_new_roman_0
.to
);
2748 /* Delete the FontSubstitutes from other locales */
2749 if (!RegCreateKeyA( HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey
))
2751 set_value_key(hkey
, nls_update_font_list
[i
].arial_0
.from
, NULL
);
2752 set_value_key(hkey
, nls_update_font_list
[i
].courier_new_0
.from
, NULL
);
2753 set_value_key(hkey
, nls_update_font_list
[i
].times_new_roman_0
.from
, NULL
);
2759 FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp
, oem_cp
);
2761 /* Clear out system links */
2762 RegDeleteKeyW(HKEY_LOCAL_MACHINE
, system_link
);
2765 static void populate_system_links(HKEY hkey
, const WCHAR
*name
, const WCHAR
*const *values
)
2775 WCHAR buff
[MAX_PATH
];
2779 static const WCHAR comma
[] = {',',0};
2781 RegDeleteValueW(hkey
, name
);
2786 for (i
= 0; values
[i
] != NULL
; i
++)
2789 if (!strcmpiW(name
,value
))
2791 psub
= get_font_subst(&font_subst_list
, value
, -1);
2793 value
= psub
->to
.name
;
2794 family
= find_family_from_name(value
);
2798 /* Use first extant filename for this Family */
2799 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
2803 file
= strrchr(face
->file
, '/');
2812 fileLen
= MultiByteToWideChar(CP_UNIXCP
, 0, file
, -1, NULL
, 0);
2813 fileW
= HeapAlloc(GetProcessHeap(), 0, fileLen
* sizeof(WCHAR
));
2814 MultiByteToWideChar(CP_UNIXCP
, 0, file
, -1, fileW
, fileLen
);
2815 entryLen
= strlenW(fileW
) + 1 + strlenW(value
) + 1;
2816 if (sizeof(buff
)-(data
-buff
) < entryLen
+ 1)
2818 WARN("creating SystemLink for %s, ran out of buffer space\n", debugstr_w(name
));
2819 HeapFree(GetProcessHeap(), 0, fileW
);
2822 strcpyW(data
, fileW
);
2823 strcatW(data
, comma
);
2824 strcatW(data
, value
);
2826 TRACE("added SystemLink for %s to %s in %s\n", debugstr_w(name
), debugstr_w(value
),debugstr_w(fileW
));
2827 HeapFree(GetProcessHeap(), 0, fileW
);
2833 RegSetValueExW(hkey
, name
, 0, REG_MULTI_SZ
, (BYTE
*)buff
, (data
-buff
) * sizeof(WCHAR
));
2835 TRACE("no SystemLink fonts found for %s\n", debugstr_w(name
));
2837 TRACE("removed SystemLink for %s\n", debugstr_w(name
));
2840 static void update_system_links(void)
2848 static const WCHAR MS_Shell_Dlg
[] = {'M','S',' ','S','h','e','l','l',' ','D','l','g',0};
2850 if (!RegCreateKeyExW(HKEY_LOCAL_MACHINE
, system_link
, 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &hkey
, &disposition
))
2852 if (disposition
== REG_OPENED_EXISTING_KEY
)
2854 TRACE("SystemLink key already exists, doing nothing\n");
2859 psub
= get_font_subst(&font_subst_list
, MS_Shell_Dlg
, -1);
2861 WARN("could not find FontSubstitute for MS Shell Dlg\n");
2866 for (i
= 0; i
< sizeof(font_links_defaults_list
)/sizeof(font_links_defaults_list
[0]); i
++)
2868 if (!strcmpiW(font_links_defaults_list
[i
].shelldlg
, psub
->to
.name
))
2870 for (j
= 0; j
< sizeof(font_links_list
)/sizeof(font_links_list
[0]); j
++)
2871 populate_system_links(hkey
, font_links_list
[j
], font_links_defaults_list
[i
].substitutes
);
2873 if (!strcmpiW(psub
->to
.name
, font_links_defaults_list
[i
].substitutes
[0]))
2874 populate_system_links(hkey
, psub
->to
.name
, font_links_defaults_list
[i
].substitutes
);
2877 else if (strcmpiW(psub
->to
.name
, font_links_defaults_list
[i
].substitutes
[0]))
2879 populate_system_links(hkey
, font_links_defaults_list
[i
].substitutes
[0], NULL
);
2884 WARN("there is no SystemLink default list for MS Shell Dlg %s\n", debugstr_w(psub
->to
.name
));
2886 WARN("failed to create SystemLink key\n");
2890 static BOOL
init_freetype(void)
2892 ft_handle
= wine_dlopen(SONAME_LIBFREETYPE
, RTLD_NOW
, NULL
, 0);
2895 "Wine cannot find the FreeType font library. To enable Wine to\n"
2896 "use TrueType fonts please install a version of FreeType greater than\n"
2897 "or equal to 2.0.5.\n"
2898 "http://www.freetype.org\n");
2902 #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;}
2904 LOAD_FUNCPTR(FT_Done_Face
)
2905 LOAD_FUNCPTR(FT_Get_Char_Index
)
2906 LOAD_FUNCPTR(FT_Get_First_Char
)
2907 LOAD_FUNCPTR(FT_Get_Module
)
2908 LOAD_FUNCPTR(FT_Get_Next_Char
)
2909 LOAD_FUNCPTR(FT_Get_Sfnt_Name
)
2910 LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count
)
2911 LOAD_FUNCPTR(FT_Get_Sfnt_Table
)
2912 LOAD_FUNCPTR(FT_Get_WinFNT_Header
)
2913 LOAD_FUNCPTR(FT_Init_FreeType
)
2914 LOAD_FUNCPTR(FT_Library_Version
)
2915 LOAD_FUNCPTR(FT_Load_Glyph
)
2916 LOAD_FUNCPTR(FT_Load_Sfnt_Table
)
2917 LOAD_FUNCPTR(FT_Matrix_Multiply
)
2918 #ifndef FT_MULFIX_INLINED
2919 LOAD_FUNCPTR(FT_MulFix
)
2921 LOAD_FUNCPTR(FT_New_Face
)
2922 LOAD_FUNCPTR(FT_New_Memory_Face
)
2923 LOAD_FUNCPTR(FT_Outline_Get_Bitmap
)
2924 LOAD_FUNCPTR(FT_Outline_Transform
)
2925 LOAD_FUNCPTR(FT_Outline_Translate
)
2926 LOAD_FUNCPTR(FT_Render_Glyph
)
2927 LOAD_FUNCPTR(FT_Select_Charmap
)
2928 LOAD_FUNCPTR(FT_Set_Charmap
)
2929 LOAD_FUNCPTR(FT_Set_Pixel_Sizes
)
2930 LOAD_FUNCPTR(FT_Vector_Transform
)
2931 LOAD_FUNCPTR(FT_Vector_Unit
)
2933 /* Don't warn if these ones are missing */
2934 pFT_Get_TrueType_Engine_Type
= wine_dlsym(ft_handle
, "FT_Get_TrueType_Engine_Type", NULL
, 0);
2935 #ifdef HAVE_FREETYPE_FTLCDFIL_H
2936 pFT_Library_SetLcdFilter
= wine_dlsym(ft_handle
, "FT_Library_SetLcdFilter", NULL
, 0);
2939 if(pFT_Init_FreeType(&library
) != 0) {
2940 ERR("Can't init FreeType library\n");
2941 wine_dlclose(ft_handle
, NULL
, 0);
2945 pFT_Library_Version(library
,&FT_Version
.major
,&FT_Version
.minor
,&FT_Version
.patch
);
2947 TRACE("FreeType version is %d.%d.%d\n",FT_Version
.major
,FT_Version
.minor
,FT_Version
.patch
);
2948 FT_SimpleVersion
= ((FT_Version
.major
<< 16) & 0xff0000) |
2949 ((FT_Version
.minor
<< 8) & 0x00ff00) |
2950 ((FT_Version
.patch
) & 0x0000ff);
2952 font_driver
= &freetype_funcs
;
2957 "Wine cannot find certain functions that it needs inside the FreeType\n"
2958 "font library. To enable Wine to use TrueType fonts please upgrade\n"
2959 "FreeType to at least version 2.1.4.\n"
2960 "http://www.freetype.org\n");
2961 wine_dlclose(ft_handle
, NULL
, 0);
2966 static void init_font_list(void)
2968 static const WCHAR dot_fonW
[] = {'.','f','o','n','\0'};
2969 static const WCHAR pathW
[] = {'P','a','t','h',0};
2971 DWORD valuelen
, datalen
, i
= 0, type
, dlen
, vlen
;
2972 WCHAR windowsdir
[MAX_PATH
];
2974 const char *data_dir
;
2976 delete_external_font_keys();
2978 /* load the system bitmap fonts */
2979 load_system_fonts();
2981 /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
2982 GetWindowsDirectoryW(windowsdir
, sizeof(windowsdir
) / sizeof(WCHAR
));
2983 strcatW(windowsdir
, fontsW
);
2984 if((unixname
= wine_get_unix_file_name(windowsdir
)))
2986 ReadFontDir(unixname
, FALSE
);
2987 HeapFree(GetProcessHeap(), 0, unixname
);
2990 /* load the system truetype fonts */
2991 data_dir
= wine_get_data_dir();
2992 if (!data_dir
) data_dir
= wine_get_build_dir();
2993 if (data_dir
&& (unixname
= HeapAlloc(GetProcessHeap(), 0, strlen(data_dir
) + sizeof("/fonts/"))))
2995 strcpy(unixname
, data_dir
);
2996 strcat(unixname
, "/fonts/");
2997 ReadFontDir(unixname
, TRUE
);
2998 HeapFree(GetProcessHeap(), 0, unixname
);
3001 /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
3002 for any fonts not installed in %WINDOWSDIR%\Fonts. They will have their
3003 full path as the entry. Also look for any .fon fonts, since ReadFontDir
3005 if(RegOpenKeyW(HKEY_LOCAL_MACHINE
,
3006 is_win9x() ? win9x_font_reg_key
: winnt_font_reg_key
,
3007 &hkey
) == ERROR_SUCCESS
)
3009 LPWSTR data
, valueW
;
3010 RegQueryInfoKeyW(hkey
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
3011 &valuelen
, &datalen
, NULL
, NULL
);
3013 valuelen
++; /* returned value doesn't include room for '\0' */
3014 valueW
= HeapAlloc(GetProcessHeap(), 0, valuelen
* sizeof(WCHAR
));
3015 data
= HeapAlloc(GetProcessHeap(), 0, datalen
* sizeof(WCHAR
));
3018 dlen
= datalen
* sizeof(WCHAR
);
3020 while(RegEnumValueW(hkey
, i
++, valueW
, &vlen
, NULL
, &type
, (LPBYTE
)data
,
3021 &dlen
) == ERROR_SUCCESS
)
3023 if(data
[0] && (data
[1] == ':'))
3025 if((unixname
= wine_get_unix_file_name(data
)))
3027 AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
| ADDFONT_ADD_TO_CACHE
);
3028 HeapFree(GetProcessHeap(), 0, unixname
);
3031 else if(dlen
/ 2 >= 6 && !strcmpiW(data
+ dlen
/ 2 - 5, dot_fonW
))
3033 WCHAR pathW
[MAX_PATH
];
3034 static const WCHAR fmtW
[] = {'%','s','\\','%','s','\0'};
3037 sprintfW(pathW
, fmtW
, windowsdir
, data
);
3038 if((unixname
= wine_get_unix_file_name(pathW
)))
3040 added
= AddFontFileToList(unixname
, NULL
, NULL
, ADDFONT_FORCE_BITMAP
| ADDFONT_ADD_TO_CACHE
);
3041 HeapFree(GetProcessHeap(), 0, unixname
);
3044 load_font_from_data_dir(data
);
3046 /* reset dlen and vlen */
3051 HeapFree(GetProcessHeap(), 0, data
);
3052 HeapFree(GetProcessHeap(), 0, valueW
);
3056 load_fontconfig_fonts();
3058 /* then look in any directories that we've specified in the config file */
3059 /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
3060 if(RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Fonts", &hkey
) == ERROR_SUCCESS
)
3066 if (RegQueryValueExW( hkey
, pathW
, NULL
, NULL
, NULL
, &len
) == ERROR_SUCCESS
)
3068 len
+= sizeof(WCHAR
);
3069 valueW
= HeapAlloc( GetProcessHeap(), 0, len
);
3070 if (RegQueryValueExW( hkey
, pathW
, NULL
, NULL
, (LPBYTE
)valueW
, &len
) == ERROR_SUCCESS
)
3072 len
= WideCharToMultiByte( CP_UNIXCP
, 0, valueW
, -1, NULL
, 0, NULL
, NULL
);
3073 valueA
= HeapAlloc( GetProcessHeap(), 0, len
);
3074 WideCharToMultiByte( CP_UNIXCP
, 0, valueW
, -1, valueA
, len
, NULL
, NULL
);
3075 TRACE( "got font path %s\n", debugstr_a(valueA
) );
3080 LPSTR next
= strchr( ptr
, ':' );
3081 if (next
) *next
++ = 0;
3082 if (ptr
[0] == '~' && ptr
[1] == '/' && (home
= getenv( "HOME" )) &&
3083 (unixname
= HeapAlloc( GetProcessHeap(), 0, strlen(ptr
) + strlen(home
) )))
3085 strcpy( unixname
, home
);
3086 strcat( unixname
, ptr
+ 1 );
3087 ReadFontDir( unixname
, TRUE
);
3088 HeapFree( GetProcessHeap(), 0, unixname
);
3091 ReadFontDir( ptr
, TRUE
);
3094 HeapFree( GetProcessHeap(), 0, valueA
);
3096 HeapFree( GetProcessHeap(), 0, valueW
);
3102 static BOOL
move_to_front(const WCHAR
*name
)
3104 Family
*family
, *cursor2
;
3105 LIST_FOR_EACH_ENTRY_SAFE(family
, cursor2
, &font_list
, Family
, entry
)
3107 if(!strcmpiW(family
->FamilyName
, name
))
3109 list_remove(&family
->entry
);
3110 list_add_head(&font_list
, &family
->entry
);
3117 static BOOL
set_default(const WCHAR
**name_list
)
3121 if (move_to_front(*name_list
)) return TRUE
;
3128 static void reorder_font_list(void)
3130 set_default( default_serif_list
);
3131 set_default( default_fixed_list
);
3132 set_default( default_sans_list
);
3135 /*************************************************************
3138 * Initialize FreeType library and create a list of available faces
3140 BOOL
WineEngInit(void)
3142 HKEY hkey_font_cache
;
3146 /* update locale dependent font info in registry */
3149 if(!init_freetype()) return FALSE
;
3151 if((font_mutex
= CreateMutexW(NULL
, FALSE
, font_mutex_nameW
)) == NULL
)
3153 ERR("Failed to create font mutex\n");
3156 WaitForSingleObject(font_mutex
, INFINITE
);
3158 create_font_cache_key(&hkey_font_cache
, &disposition
);
3160 if(disposition
== REG_CREATED_NEW_KEY
)
3163 load_font_list_from_cache(hkey_font_cache
);
3165 RegCloseKey(hkey_font_cache
);
3167 reorder_font_list();
3174 if(disposition
== REG_CREATED_NEW_KEY
)
3175 update_reg_entries();
3177 update_system_links();
3178 init_system_links();
3180 ReleaseMutex(font_mutex
);
3185 static LONG
calc_ppem_for_height(FT_Face ft_face
, LONG height
)
3188 TT_HoriHeader
*pHori
;
3192 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
3193 pHori
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
);
3195 if(height
== 0) height
= 16;
3197 /* Calc. height of EM square:
3199 * For +ve lfHeight we have
3200 * lfHeight = (winAscent + winDescent) * ppem / units_per_em
3201 * Re-arranging gives:
3202 * ppem = units_per_em * lfheight / (winAscent + winDescent)
3204 * For -ve lfHeight we have
3206 * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
3207 * with il = winAscent + winDescent - units_per_em]
3212 if(pOS2
->usWinAscent
+ pOS2
->usWinDescent
== 0)
3213 ppem
= MulDiv(ft_face
->units_per_EM
, height
,
3214 pHori
->Ascender
- pHori
->Descender
);
3216 ppem
= MulDiv(ft_face
->units_per_EM
, height
,
3217 pOS2
->usWinAscent
+ pOS2
->usWinDescent
);
3225 static struct font_mapping
*map_font_file( const char *name
)
3227 struct font_mapping
*mapping
;
3231 if ((fd
= open( name
, O_RDONLY
)) == -1) return NULL
;
3232 if (fstat( fd
, &st
) == -1) goto error
;
3234 LIST_FOR_EACH_ENTRY( mapping
, &mappings_list
, struct font_mapping
, entry
)
3236 if (mapping
->dev
== st
.st_dev
&& mapping
->ino
== st
.st_ino
)
3238 mapping
->refcount
++;
3243 if (!(mapping
= HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping
) )))
3246 mapping
->data
= mmap( NULL
, st
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0 );
3249 if (mapping
->data
== MAP_FAILED
)
3251 HeapFree( GetProcessHeap(), 0, mapping
);
3254 mapping
->refcount
= 1;
3255 mapping
->dev
= st
.st_dev
;
3256 mapping
->ino
= st
.st_ino
;
3257 mapping
->size
= st
.st_size
;
3258 list_add_tail( &mappings_list
, &mapping
->entry
);
3266 static void unmap_font_file( struct font_mapping
*mapping
)
3268 if (!--mapping
->refcount
)
3270 list_remove( &mapping
->entry
);
3271 munmap( mapping
->data
, mapping
->size
);
3272 HeapFree( GetProcessHeap(), 0, mapping
);
3276 static LONG
load_VDMX(GdiFont
*, LONG
);
3278 static FT_Face
OpenFontFace(GdiFont
*font
, Face
*face
, LONG width
, LONG height
)
3285 TRACE("%s/%p, %ld, %d x %d\n", debugstr_a(face
->file
), face
->font_data_ptr
, face
->face_index
, width
, height
);
3289 if (!(font
->mapping
= map_font_file( face
->file
)))
3291 WARN("failed to map %s\n", debugstr_a(face
->file
));
3294 data_ptr
= font
->mapping
->data
;
3295 data_size
= font
->mapping
->size
;
3299 data_ptr
= face
->font_data_ptr
;
3300 data_size
= face
->font_data_size
;
3303 err
= pFT_New_Memory_Face(library
, data_ptr
, data_size
, face
->face_index
, &ft_face
);
3305 ERR("FT_New_Face rets %d\n", err
);
3309 /* set it here, as load_VDMX needs it */
3310 font
->ft_face
= ft_face
;
3312 if(FT_IS_SCALABLE(ft_face
)) {
3313 /* load the VDMX table if we have one */
3314 font
->ppem
= load_VDMX(font
, height
);
3316 font
->ppem
= calc_ppem_for_height(ft_face
, height
);
3317 TRACE("height %d => ppem %d\n", height
, font
->ppem
);
3319 if((err
= pFT_Set_Pixel_Sizes(ft_face
, 0, font
->ppem
)) != 0)
3320 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font
->ppem
, err
);
3322 font
->ppem
= height
;
3323 if((err
= pFT_Set_Pixel_Sizes(ft_face
, width
, height
)) != 0)
3324 WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width
, height
, err
);
3330 static int get_nearest_charset(Face
*face
, int *cp
)
3332 /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
3333 a single face with the requested charset. The idea is to check if
3334 the selected font supports the current ANSI codepage, if it does
3335 return the corresponding charset, else return the first charset */
3338 int acp
= GetACP(), i
;
3342 if(TranslateCharsetInfo((DWORD
*)(INT_PTR
)acp
, &csi
, TCI_SRCCODEPAGE
))
3343 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]))
3344 return csi
.ciCharset
;
3346 for(i
= 0; i
< 32; i
++) {
3348 if(face
->fs
.fsCsb
[0] & fs0
) {
3349 if(TranslateCharsetInfo(&fs0
, &csi
, TCI_SRCFONTSIG
)) {
3351 return csi
.ciCharset
;
3354 FIXME("TCI failing on %x\n", fs0
);
3358 FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
3359 face
->fs
.fsCsb
[0], face
->file
);
3361 return DEFAULT_CHARSET
;
3364 static GdiFont
*alloc_font(void)
3366 GdiFont
*ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*ret
));
3368 ret
->gm
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(GM
*));
3369 ret
->gm
[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(GM
) * GM_BLOCK_SIZE
);
3371 ret
->font_desc
.matrix
.eM11
= ret
->font_desc
.matrix
.eM22
= 1.0;
3372 ret
->total_kern_pairs
= (DWORD
)-1;
3373 ret
->kern_pairs
= NULL
;
3374 list_init(&ret
->hfontlist
);
3375 list_init(&ret
->child_fonts
);
3379 static void free_font(GdiFont
*font
)
3381 struct list
*cursor
, *cursor2
;
3384 LIST_FOR_EACH_SAFE(cursor
, cursor2
, &font
->child_fonts
)
3386 CHILD_FONT
*child
= LIST_ENTRY(cursor
, CHILD_FONT
, entry
);
3387 list_remove(cursor
);
3389 free_font(child
->font
);
3390 HeapFree(GetProcessHeap(), 0, child
);
3393 LIST_FOR_EACH_SAFE(cursor
, cursor2
, &font
->hfontlist
)
3395 HFONTLIST
*hfontlist
= LIST_ENTRY(cursor
, HFONTLIST
, entry
);
3396 DeleteObject(hfontlist
->hfont
);
3397 list_remove(&hfontlist
->entry
);
3398 HeapFree(GetProcessHeap(), 0, hfontlist
);
3401 if (font
->ft_face
) pFT_Done_Face(font
->ft_face
);
3402 if (font
->mapping
) unmap_font_file( font
->mapping
);
3403 HeapFree(GetProcessHeap(), 0, font
->kern_pairs
);
3404 HeapFree(GetProcessHeap(), 0, font
->potm
);
3405 HeapFree(GetProcessHeap(), 0, font
->name
);
3406 for (i
= 0; i
< font
->gmsize
; i
++)
3407 HeapFree(GetProcessHeap(),0,font
->gm
[i
]);
3408 HeapFree(GetProcessHeap(), 0, font
->gm
);
3409 HeapFree(GetProcessHeap(), 0, font
->GSUB_Table
);
3410 HeapFree(GetProcessHeap(), 0, font
);
3414 static DWORD
get_font_data( GdiFont
*font
, DWORD table
, DWORD offset
, LPVOID buf
, DWORD cbData
)
3416 FT_Face ft_face
= font
->ft_face
;
3420 if (!FT_IS_SFNT(ft_face
)) return GDI_ERROR
;
3427 table
= RtlUlongByteSwap( table
); /* MS tags differ in endianness from FT ones */
3429 /* make sure value of len is the value freetype says it needs */
3432 FT_ULong needed
= 0;
3433 err
= pFT_Load_Sfnt_Table(ft_face
, table
, offset
, NULL
, &needed
);
3434 if( !err
&& needed
< len
) len
= needed
;
3436 err
= pFT_Load_Sfnt_Table(ft_face
, table
, offset
, buf
, &len
);
3439 TRACE("Can't find table %c%c%c%c\n",
3440 /* bytes were reversed */
3441 HIBYTE(HIWORD(table
)), LOBYTE(HIWORD(table
)),
3442 HIBYTE(LOWORD(table
)), LOBYTE(LOWORD(table
)));
3448 /*************************************************************
3451 * load the vdmx entry for the specified height
3454 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
3455 ( ( (FT_ULong)_x4 << 24 ) | \
3456 ( (FT_ULong)_x3 << 16 ) | \
3457 ( (FT_ULong)_x2 << 8 ) | \
3460 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
3475 static LONG
load_VDMX(GdiFont
*font
, LONG height
)
3479 BYTE devXRatio
, devYRatio
;
3480 USHORT numRecs
, numRatios
;
3481 DWORD result
, offset
= -1;
3485 result
= get_font_data(font
, MS_VDMX_TAG
, 0, hdr
, 6);
3487 if(result
== GDI_ERROR
) /* no vdmx table present, use linear scaling */
3490 /* FIXME: need the real device aspect ratio */
3494 numRecs
= GET_BE_WORD(hdr
[1]);
3495 numRatios
= GET_BE_WORD(hdr
[2]);
3497 TRACE("numRecs = %d numRatios = %d\n", numRecs
, numRatios
);
3498 for(i
= 0; i
< numRatios
; i
++) {
3501 offset
= (3 * 2) + (i
* sizeof(Ratios
));
3502 get_font_data(font
, MS_VDMX_TAG
, offset
, &ratio
, sizeof(Ratios
));
3505 TRACE("Ratios[%d] %d %d : %d -> %d\n", i
, ratio
.bCharSet
, ratio
.xRatio
, ratio
.yStartRatio
, ratio
.yEndRatio
);
3507 if((ratio
.xRatio
== 0 &&
3508 ratio
.yStartRatio
== 0 &&
3509 ratio
.yEndRatio
== 0) ||
3510 (devXRatio
== ratio
.xRatio
&&
3511 devYRatio
>= ratio
.yStartRatio
&&
3512 devYRatio
<= ratio
.yEndRatio
))
3514 offset
= (3 * 2) + (numRatios
* 4) + (i
* 2);
3515 get_font_data(font
, MS_VDMX_TAG
, offset
, &tmp
, 2);
3516 offset
= GET_BE_WORD(tmp
);
3522 FIXME("No suitable ratio found\n");
3526 if(get_font_data(font
, MS_VDMX_TAG
, offset
, &group
, 4) != GDI_ERROR
) {
3528 BYTE startsz
, endsz
;
3531 recs
= GET_BE_WORD(group
.recs
);
3532 startsz
= group
.startsz
;
3533 endsz
= group
.endsz
;
3535 TRACE("recs=%d startsz=%d endsz=%d\n", recs
, startsz
, endsz
);
3537 vTable
= HeapAlloc(GetProcessHeap(), 0, recs
* 6);
3538 result
= get_font_data(font
, MS_VDMX_TAG
, offset
+ 4, vTable
, recs
* 6);
3539 if(result
== GDI_ERROR
) {
3540 FIXME("Failed to retrieve vTable\n");
3545 for(i
= 0; i
< recs
; i
++) {
3546 SHORT yMax
= GET_BE_WORD(vTable
[(i
* 3) + 1]);
3547 SHORT yMin
= GET_BE_WORD(vTable
[(i
* 3) + 2]);
3548 ppem
= GET_BE_WORD(vTable
[i
* 3]);
3550 if(yMax
+ -yMin
== height
) {
3553 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem
, height
, font
->yMax
, font
->yMin
);
3556 if(yMax
+ -yMin
> height
) {
3559 goto end
; /* failed */
3561 font
->yMax
= GET_BE_WORD(vTable
[(i
* 3) + 1]);
3562 font
->yMin
= GET_BE_WORD(vTable
[(i
* 3) + 2]);
3563 ppem
= GET_BE_WORD(vTable
[i
* 3]);
3564 TRACE("ppem %d found; height=%d yMax=%d yMin=%d\n", ppem
, height
, font
->yMax
, font
->yMin
);
3570 TRACE("ppem not found for height %d\n", height
);
3574 HeapFree(GetProcessHeap(), 0, vTable
);
3580 static BOOL
fontcmp(const GdiFont
*font
, FONT_DESC
*fd
)
3582 if(font
->font_desc
.hash
!= fd
->hash
) return TRUE
;
3583 if(memcmp(&font
->font_desc
.matrix
, &fd
->matrix
, sizeof(fd
->matrix
))) return TRUE
;
3584 if(memcmp(&font
->font_desc
.lf
, &fd
->lf
, offsetof(LOGFONTW
, lfFaceName
))) return TRUE
;
3585 if(!font
->font_desc
.can_use_bitmap
!= !fd
->can_use_bitmap
) return TRUE
;
3586 return strcmpiW(font
->font_desc
.lf
.lfFaceName
, fd
->lf
.lfFaceName
);
3589 static void calc_hash(FONT_DESC
*pfd
)
3591 DWORD hash
= 0, *ptr
, two_chars
;
3595 for(i
= 0, ptr
= (DWORD
*)&pfd
->matrix
; i
< sizeof(FMAT2
)/sizeof(DWORD
); i
++, ptr
++)
3597 for(i
= 0, ptr
= (DWORD
*)&pfd
->lf
; i
< 7; i
++, ptr
++)
3599 for(i
= 0, ptr
= (DWORD
*)pfd
->lf
.lfFaceName
; i
< LF_FACESIZE
/2; i
++, ptr
++) {
3601 pwc
= (WCHAR
*)&two_chars
;
3603 *pwc
= toupperW(*pwc
);
3605 *pwc
= toupperW(*pwc
);
3609 hash
^= !pfd
->can_use_bitmap
;
3614 static GdiFont
*find_in_cache(HFONT hfont
, const LOGFONTW
*plf
, const FMAT2
*pmat
, BOOL can_use_bitmap
)
3619 struct list
*font_elem_ptr
, *hfontlist_elem_ptr
;
3623 fd
.can_use_bitmap
= can_use_bitmap
;
3626 /* try the child list */
3627 LIST_FOR_EACH(font_elem_ptr
, &child_font_list
) {
3628 ret
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3629 if(!fontcmp(ret
, &fd
)) {
3630 if(!can_use_bitmap
&& !FT_IS_SCALABLE(ret
->ft_face
)) continue;
3631 LIST_FOR_EACH(hfontlist_elem_ptr
, &ret
->hfontlist
) {
3632 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
3633 if(hflist
->hfont
== hfont
)
3639 /* try the in-use list */
3640 LIST_FOR_EACH(font_elem_ptr
, &gdi_font_list
) {
3641 ret
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3642 if(!fontcmp(ret
, &fd
)) {
3643 if(!can_use_bitmap
&& !FT_IS_SCALABLE(ret
->ft_face
)) continue;
3644 LIST_FOR_EACH(hfontlist_elem_ptr
, &ret
->hfontlist
) {
3645 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
3646 if(hflist
->hfont
== hfont
)
3649 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3650 hflist
->hfont
= hfont
;
3651 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3656 /* then the unused list */
3657 font_elem_ptr
= list_head(&unused_gdi_font_list
);
3658 while(font_elem_ptr
) {
3659 ret
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
3660 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
3661 if(!fontcmp(ret
, &fd
)) {
3662 if(!can_use_bitmap
&& !FT_IS_SCALABLE(ret
->ft_face
)) continue;
3663 assert(list_empty(&ret
->hfontlist
));
3664 TRACE("Found %p in unused list\n", ret
);
3665 list_remove(&ret
->entry
);
3666 list_add_head(&gdi_font_list
, &ret
->entry
);
3667 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3668 hflist
->hfont
= hfont
;
3669 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3676 static void add_to_cache(GdiFont
*font
)
3678 static DWORD cache_num
= 1;
3680 font
->cache_num
= cache_num
++;
3681 list_add_head(&gdi_font_list
, &font
->entry
);
3684 /*************************************************************
3685 * create_child_font_list
3687 static BOOL
create_child_font_list(GdiFont
*font
)
3690 SYSTEM_LINKS
*font_link
;
3691 CHILD_FONT
*font_link_entry
, *new_child
;
3695 psub
= get_font_subst(&font_subst_list
, font
->name
, -1);
3696 font_name
= psub
? psub
->to
.name
: font
->name
;
3697 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3699 if(!strcmpiW(font_link
->font_name
, font_name
))
3701 TRACE("found entry in system list\n");
3702 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3704 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
3705 new_child
->face
= font_link_entry
->face
;
3706 new_child
->font
= NULL
;
3707 list_add_tail(&font
->child_fonts
, &new_child
->entry
);
3708 TRACE("font %s %ld\n", debugstr_a(new_child
->face
->file
), new_child
->face
->face_index
);
3715 * if not SYMBOL or OEM then we also get all the fonts for Microsoft
3716 * Sans Serif. This is how asian windows get default fallbacks for fonts
3718 if (use_default_fallback
&& font
->charset
!= SYMBOL_CHARSET
&&
3719 font
->charset
!= OEM_CHARSET
&&
3720 strcmpiW(font_name
,szDefaultFallbackLink
) != 0)
3721 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3723 if(!strcmpiW(font_link
->font_name
,szDefaultFallbackLink
))
3725 TRACE("found entry in default fallback list\n");
3726 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3728 new_child
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child
));
3729 new_child
->face
= font_link_entry
->face
;
3730 new_child
->font
= NULL
;
3731 list_add_tail(&font
->child_fonts
, &new_child
->entry
);
3732 TRACE("font %s %ld\n", debugstr_a(new_child
->face
->file
), new_child
->face
->face_index
);
3742 static BOOL
select_charmap(FT_Face ft_face
, FT_Encoding encoding
)
3744 FT_Error ft_err
= FT_Err_Invalid_CharMap_Handle
;
3746 if (pFT_Set_Charmap
)
3749 FT_CharMap cmap0
, cmap1
, cmap2
, cmap3
, cmap_def
;
3751 cmap0
= cmap1
= cmap2
= cmap3
= cmap_def
= NULL
;
3753 for (i
= 0; i
< ft_face
->num_charmaps
; i
++)
3755 if (ft_face
->charmaps
[i
]->encoding
== encoding
)
3757 TRACE("found cmap with platform_id %u, encoding_id %u\n",
3758 ft_face
->charmaps
[i
]->platform_id
, ft_face
->charmaps
[i
]->encoding_id
);
3760 switch (ft_face
->charmaps
[i
]->platform_id
)
3763 cmap_def
= ft_face
->charmaps
[i
];
3765 case 0: /* Apple Unicode */
3766 cmap0
= ft_face
->charmaps
[i
];
3768 case 1: /* Macintosh */
3769 cmap1
= ft_face
->charmaps
[i
];
3772 cmap2
= ft_face
->charmaps
[i
];
3774 case 3: /* Microsoft */
3775 cmap3
= ft_face
->charmaps
[i
];
3780 if (cmap3
) /* prefer Microsoft cmap table */
3781 ft_err
= pFT_Set_Charmap(ft_face
, cmap3
);
3783 ft_err
= pFT_Set_Charmap(ft_face
, cmap1
);
3785 ft_err
= pFT_Set_Charmap(ft_face
, cmap2
);
3787 ft_err
= pFT_Set_Charmap(ft_face
, cmap0
);
3789 ft_err
= pFT_Set_Charmap(ft_face
, cmap_def
);
3791 return ft_err
== FT_Err_Ok
;
3794 return pFT_Select_Charmap(ft_face
, encoding
) == FT_Err_Ok
;
3798 /*************************************************************
3801 static BOOL
freetype_CreateDC( PHYSDEV
*dev
, LPCWSTR driver
, LPCWSTR device
,
3802 LPCWSTR output
, const DEVMODEW
*devmode
)
3804 struct freetype_physdev
*physdev
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*physdev
) );
3806 if (!physdev
) return FALSE
;
3807 push_dc_driver( dev
, &physdev
->dev
, &freetype_funcs
);
3812 /*************************************************************
3815 static BOOL
freetype_DeleteDC( PHYSDEV dev
)
3817 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
3818 HeapFree( GetProcessHeap(), 0, physdev
);
3823 /*************************************************************
3824 * freetype_SelectFont
3826 static HFONT
freetype_SelectFont( PHYSDEV dev
, HFONT hfont
)
3828 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
3830 Face
*face
, *best
, *best_bitmap
;
3831 Family
*family
, *last_resort_family
;
3832 struct list
*family_elem_ptr
, *face_elem_ptr
;
3833 INT height
, width
= 0;
3834 unsigned int score
= 0, new_score
;
3835 signed int diff
= 0, newdiff
;
3836 BOOL bd
, it
, can_use_bitmap
;
3841 FontSubst
*psub
= NULL
;
3842 DC
*dc
= get_dc_ptr( dev
->hdc
);
3844 if (!hfont
) /* notification that the font has been changed by another driver */
3847 physdev
->font
= NULL
;
3848 release_dc_ptr( dc
);
3852 GetObjectW( hfont
, sizeof(lf
), &lf
);
3853 lf
.lfWidth
= abs(lf
.lfWidth
);
3855 can_use_bitmap
= GetDeviceCaps(dev
->hdc
, TEXTCAPS
) & TC_RA_ABLE
;
3857 TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
3858 debugstr_w(lf
.lfFaceName
), lf
.lfHeight
, lf
.lfItalic
,
3859 lf
.lfWeight
, lf
.lfPitchAndFamily
, lf
.lfCharSet
, lf
.lfOrientation
,
3862 if(dc
->GraphicsMode
== GM_ADVANCED
)
3863 memcpy(&dcmat
, &dc
->xformWorld2Vport
, sizeof(FMAT2
));
3866 /* Windows 3.1 compatibility mode GM_COMPATIBLE has only limited
3867 font scaling abilities. */
3868 dcmat
.eM11
= dcmat
.eM22
= dc
->vport2WorldValid
? fabs(dc
->xformWorld2Vport
.eM22
) : 1.0;
3869 dcmat
.eM21
= dcmat
.eM12
= 0;
3872 /* Try to avoid not necessary glyph transformations */
3873 if (dcmat
.eM21
== 0.0 && dcmat
.eM12
== 0.0 && dcmat
.eM11
== dcmat
.eM22
)
3875 lf
.lfHeight
*= fabs(dcmat
.eM11
);
3876 lf
.lfWidth
*= fabs(dcmat
.eM11
);
3877 dcmat
.eM11
= dcmat
.eM22
= 1.0;
3880 TRACE("DC transform %f %f %f %f\n", dcmat
.eM11
, dcmat
.eM12
,
3881 dcmat
.eM21
, dcmat
.eM22
);
3884 EnterCriticalSection( &freetype_cs
);
3886 /* check the cache first */
3887 if((ret
= find_in_cache(hfont
, &lf
, &dcmat
, can_use_bitmap
)) != NULL
) {
3888 TRACE("returning cached gdiFont(%p) for hFont %p\n", ret
, hfont
);
3892 if(list_empty(&font_list
)) /* No fonts installed */
3894 TRACE("No fonts installed\n");
3898 TRACE("not in cache\n");
3901 ret
->font_desc
.matrix
= dcmat
;
3902 ret
->font_desc
.lf
= lf
;
3903 ret
->font_desc
.can_use_bitmap
= can_use_bitmap
;
3904 calc_hash(&ret
->font_desc
);
3905 hflist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist
));
3906 hflist
->hfont
= hfont
;
3907 list_add_head(&ret
->hfontlist
, &hflist
->entry
);
3909 /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
3910 SYMBOL_CHARSET so that Symbol gets picked irrespective of the
3911 original value lfCharSet. Note this is a special case for
3912 Symbol and doesn't happen at least for "Wingdings*" */
3914 if(!strcmpiW(lf
.lfFaceName
, SymbolW
))
3915 lf
.lfCharSet
= SYMBOL_CHARSET
;
3917 if(!TranslateCharsetInfo((DWORD
*)(INT_PTR
)lf
.lfCharSet
, &csi
, TCI_SRCCHARSET
)) {
3918 switch(lf
.lfCharSet
) {
3919 case DEFAULT_CHARSET
:
3920 csi
.fs
.fsCsb
[0] = 0;
3923 FIXME("Untranslated charset %d\n", lf
.lfCharSet
);
3924 csi
.fs
.fsCsb
[0] = 0;
3930 if(lf
.lfFaceName
[0] != '\0') {
3931 SYSTEM_LINKS
*font_link
;
3932 CHILD_FONT
*font_link_entry
;
3933 LPWSTR FaceName
= lf
.lfFaceName
;
3936 * Check for a leading '@' this signals that the font is being
3937 * requested in tategaki mode (vertical writing substitution) but
3938 * does not affect the fontface that is to be selected.
3940 if (lf
.lfFaceName
[0]=='@')
3941 FaceName
= &lf
.lfFaceName
[1];
3943 psub
= get_font_subst(&font_subst_list
, FaceName
, lf
.lfCharSet
);
3946 TRACE("substituting %s,%d -> %s,%d\n", debugstr_w(FaceName
), lf
.lfCharSet
,
3947 debugstr_w(psub
->to
.name
), (psub
->to
.charset
!= -1) ? psub
->to
.charset
: lf
.lfCharSet
);
3948 if (psub
->to
.charset
!= -1)
3949 lf
.lfCharSet
= psub
->to
.charset
;
3952 /* We want a match on name and charset or just name if
3953 charset was DEFAULT_CHARSET. If the latter then
3954 we fixup the returned charset later in get_nearest_charset
3955 where we'll either use the charset of the current ansi codepage
3956 or if that's unavailable the first charset that the font supports.
3958 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3959 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3960 if (!strcmpiW(family
->FamilyName
, FaceName
) ||
3961 (psub
&& !strcmpiW(family
->FamilyName
, psub
->to
.name
)))
3963 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3964 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3965 if((csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) || !csi
.fs
.fsCsb
[0])
3966 if(face
->scalable
|| can_use_bitmap
)
3972 /* Search by full face name. */
3973 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
3974 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
3975 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
3976 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
3977 if(face
->FullName
&& !strcmpiW(face
->FullName
, FaceName
) &&
3978 ((csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) || !csi
.fs
.fsCsb
[0]))
3980 if(face
->scalable
|| can_use_bitmap
)
3987 * Try check the SystemLink list first for a replacement font.
3988 * We may find good replacements there.
3990 LIST_FOR_EACH_ENTRY(font_link
, &system_links
, SYSTEM_LINKS
, entry
)
3992 if(!strcmpiW(font_link
->font_name
, FaceName
) ||
3993 (psub
&& !strcmpiW(font_link
->font_name
,psub
->to
.name
)))
3995 TRACE("found entry in system list\n");
3996 LIST_FOR_EACH_ENTRY(font_link_entry
, &font_link
->links
, CHILD_FONT
, entry
)
3998 face
= font_link_entry
->face
;
3999 family
= face
->family
;
4000 if(csi
.fs
.fsCsb
[0] &
4001 (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]) || !csi
.fs
.fsCsb
[0])
4003 if(face
->scalable
|| can_use_bitmap
)
4011 psub
= NULL
; /* substitution is no more relevant */
4013 /* If requested charset was DEFAULT_CHARSET then try using charset
4014 corresponding to the current ansi codepage */
4015 if (!csi
.fs
.fsCsb
[0])
4018 if(!TranslateCharsetInfo((DWORD
*)(INT_PTR
)acp
, &csi
, TCI_SRCCODEPAGE
)) {
4019 FIXME("TCI failed on codepage %d\n", acp
);
4020 csi
.fs
.fsCsb
[0] = 0;
4022 lf
.lfCharSet
= csi
.ciCharset
;
4025 /* Face families are in the top 4 bits of lfPitchAndFamily,
4026 so mask with 0xF0 before testing */
4028 if((lf
.lfPitchAndFamily
& FIXED_PITCH
) ||
4029 (lf
.lfPitchAndFamily
& 0xF0) == FF_MODERN
)
4030 strcpyW(lf
.lfFaceName
, defFixed
);
4031 else if((lf
.lfPitchAndFamily
& 0xF0) == FF_ROMAN
)
4032 strcpyW(lf
.lfFaceName
, defSerif
);
4033 else if((lf
.lfPitchAndFamily
& 0xF0) == FF_SWISS
)
4034 strcpyW(lf
.lfFaceName
, defSans
);
4036 strcpyW(lf
.lfFaceName
, defSans
);
4037 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
4038 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
4039 if(!strcmpiW(family
->FamilyName
, lf
.lfFaceName
)) {
4040 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
4041 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
4042 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0]))
4043 if(face
->scalable
|| can_use_bitmap
)
4049 last_resort_family
= NULL
;
4050 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
4051 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
4052 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
4053 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
4054 if(csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) {
4057 if(can_use_bitmap
&& !last_resort_family
)
4058 last_resort_family
= family
;
4063 if(last_resort_family
) {
4064 family
= last_resort_family
;
4065 csi
.fs
.fsCsb
[0] = 0;
4069 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
4070 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
4071 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
4072 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
4073 if(face
->scalable
) {
4074 csi
.fs
.fsCsb
[0] = 0;
4075 WARN("just using first face for now\n");
4078 if(can_use_bitmap
&& !last_resort_family
)
4079 last_resort_family
= family
;
4082 if(!last_resort_family
) {
4083 FIXME("can't find a single appropriate font - bailing\n");
4089 WARN("could only find a bitmap font - this will probably look awful!\n");
4090 family
= last_resort_family
;
4091 csi
.fs
.fsCsb
[0] = 0;
4094 it
= lf
.lfItalic
? 1 : 0;
4095 bd
= lf
.lfWeight
> 550 ? 1 : 0;
4097 height
= lf
.lfHeight
;
4099 face
= best
= best_bitmap
= NULL
;
4100 LIST_FOR_EACH_ENTRY(face
, &family
->faces
, Face
, entry
)
4102 if((csi
.fs
.fsCsb
[0] & (face
->fs
.fsCsb
[0] | face
->fs_links
.fsCsb
[0])) || !csi
.fs
.fsCsb
[0])
4106 italic
= (face
->ntmFlags
& NTM_ITALIC
) ? 1 : 0;
4107 bold
= (face
->ntmFlags
& NTM_BOLD
) ? 1 : 0;
4108 new_score
= (italic
^ it
) + (bold
^ bd
);
4109 if(!best
|| new_score
<= score
)
4111 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
4112 italic
, bold
, it
, bd
);
4115 if(best
->scalable
&& score
== 0) break;
4119 newdiff
= height
- (signed int)(best
->size
.height
);
4121 newdiff
= -height
- ((signed int)(best
->size
.height
) - best
->size
.internal_leading
);
4122 if(!best_bitmap
|| new_score
< score
||
4123 (diff
> 0 && newdiff
< diff
&& newdiff
>= 0) || (diff
< 0 && newdiff
> diff
))
4125 TRACE("%d is better for %d diff was %d\n", best
->size
.height
, height
, diff
);
4128 if(score
== 0 && diff
== 0) break;
4135 face
= best
->scalable
? best
: best_bitmap
;
4136 ret
->fake_italic
= (it
&& !(face
->ntmFlags
& NTM_ITALIC
));
4137 ret
->fake_bold
= (bd
&& !(face
->ntmFlags
& NTM_BOLD
));
4140 height
= lf
.lfHeight
;
4144 if(csi
.fs
.fsCsb
[0]) {
4145 ret
->charset
= lf
.lfCharSet
;
4146 ret
->codepage
= csi
.ciACP
;
4149 ret
->charset
= get_nearest_charset(face
, &ret
->codepage
);
4151 TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family
->FamilyName
),
4152 debugstr_w(face
->StyleName
), face
->file
, face
->font_data_ptr
, face
->face_index
);
4154 ret
->aveWidth
= height
? lf
.lfWidth
: 0;
4156 if(!face
->scalable
) {
4157 /* Windows uses integer scaling factors for bitmap fonts */
4158 INT scale
, scaled_height
;
4159 GdiFont
*cachedfont
;
4161 /* FIXME: rotation of bitmap fonts is ignored */
4162 height
= abs(GDI_ROUND( (double)height
* ret
->font_desc
.matrix
.eM22
));
4164 ret
->aveWidth
= (double)ret
->aveWidth
* ret
->font_desc
.matrix
.eM11
;
4165 ret
->font_desc
.matrix
.eM11
= ret
->font_desc
.matrix
.eM22
= 1.0;
4166 dcmat
.eM11
= dcmat
.eM22
= 1.0;
4167 /* As we changed the matrix, we need to search the cache for the font again,
4168 * otherwise we might explode the cache. */
4169 if((cachedfont
= find_in_cache(hfont
, &lf
, &dcmat
, can_use_bitmap
)) != NULL
) {
4170 TRACE("Found cached font after non-scalable matrix rescale!\n");
4175 calc_hash(&ret
->font_desc
);
4177 if (height
!= 0) height
= diff
;
4178 height
+= face
->size
.height
;
4180 scale
= (height
+ face
->size
.height
- 1) / face
->size
.height
;
4181 scaled_height
= scale
* face
->size
.height
;
4182 /* Only jump to the next height if the difference <= 25% original height */
4183 if (scale
> 2 && scaled_height
- height
> face
->size
.height
/ 4) scale
--;
4184 /* The jump between unscaled and doubled is delayed by 1 */
4185 else if (scale
== 2 && scaled_height
- height
> (face
->size
.height
/ 4 - 1)) scale
--;
4186 ret
->scale_y
= scale
;
4188 width
= face
->size
.x_ppem
>> 6;
4189 height
= face
->size
.y_ppem
>> 6;
4193 TRACE("font scale y: %f\n", ret
->scale_y
);
4195 ret
->ft_face
= OpenFontFace(ret
, face
, width
, height
);
4204 ret
->ntmFlags
= face
->ntmFlags
;
4206 if (ret
->charset
== SYMBOL_CHARSET
&&
4207 select_charmap(ret
->ft_face
, FT_ENCODING_MS_SYMBOL
)) {
4210 else if (select_charmap(ret
->ft_face
, FT_ENCODING_UNICODE
)) {
4214 select_charmap(ret
->ft_face
, FT_ENCODING_APPLE_ROMAN
);
4217 ret
->orientation
= FT_IS_SCALABLE(ret
->ft_face
) ? lf
.lfOrientation
: 0;
4218 ret
->name
= psub
? strdupW(psub
->from
.name
) : strdupW(family
->FamilyName
);
4219 ret
->underline
= lf
.lfUnderline
? 0xff : 0;
4220 ret
->strikeout
= lf
.lfStrikeOut
? 0xff : 0;
4221 create_child_font_list(ret
);
4223 if (lf
.lfFaceName
[0]=='@') /* We need to try to load the GSUB table */
4225 int length
= get_font_data(ret
, GSUB_TAG
, 0, NULL
, 0);
4226 if (length
!= GDI_ERROR
)
4228 ret
->GSUB_Table
= HeapAlloc(GetProcessHeap(),0,length
);
4229 get_font_data(ret
, GSUB_TAG
, 0, ret
->GSUB_Table
, length
);
4230 TRACE("Loaded GSUB table of %i bytes\n",length
);
4234 TRACE("caching: gdiFont=%p hfont=%p\n", ret
, hfont
);
4241 physdev
->font
= ret
;
4243 LeaveCriticalSection( &freetype_cs
);
4244 release_dc_ptr( dc
);
4245 return ret
? hfont
: 0;
4248 static void dump_gdi_font_list(void)
4251 struct list
*elem_ptr
;
4253 TRACE("---------- gdiFont Cache ----------\n");
4254 LIST_FOR_EACH(elem_ptr
, &gdi_font_list
) {
4255 gdiFont
= LIST_ENTRY(elem_ptr
, struct tagGdiFont
, entry
);
4256 TRACE("gdiFont=%p %s %d\n",
4257 gdiFont
, debugstr_w(gdiFont
->font_desc
.lf
.lfFaceName
), gdiFont
->font_desc
.lf
.lfHeight
);
4260 TRACE("---------- Unused gdiFont Cache ----------\n");
4261 LIST_FOR_EACH(elem_ptr
, &unused_gdi_font_list
) {
4262 gdiFont
= LIST_ENTRY(elem_ptr
, struct tagGdiFont
, entry
);
4263 TRACE("gdiFont=%p %s %d\n",
4264 gdiFont
, debugstr_w(gdiFont
->font_desc
.lf
.lfFaceName
), gdiFont
->font_desc
.lf
.lfHeight
);
4267 TRACE("---------- Child gdiFont Cache ----------\n");
4268 LIST_FOR_EACH(elem_ptr
, &child_font_list
) {
4269 gdiFont
= LIST_ENTRY(elem_ptr
, struct tagGdiFont
, entry
);
4270 TRACE("gdiFont=%p %s %d\n",
4271 gdiFont
, debugstr_w(gdiFont
->font_desc
.lf
.lfFaceName
), gdiFont
->font_desc
.lf
.lfHeight
);
4275 /*************************************************************
4276 * WineEngDestroyFontInstance
4278 * free the gdiFont associated with this handle
4281 BOOL
WineEngDestroyFontInstance(HFONT handle
)
4286 struct list
*font_elem_ptr
, *hfontlist_elem_ptr
;
4290 EnterCriticalSection( &freetype_cs
);
4292 LIST_FOR_EACH_ENTRY(gdiFont
, &child_font_list
, struct tagGdiFont
, entry
)
4294 hfontlist_elem_ptr
= list_head(&gdiFont
->hfontlist
);
4295 while(hfontlist_elem_ptr
) {
4296 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
4297 hfontlist_elem_ptr
= list_next(&gdiFont
->hfontlist
, hfontlist_elem_ptr
);
4298 if(hflist
->hfont
== handle
) {
4299 TRACE("removing child font %p from child list\n", gdiFont
);
4300 list_remove(&gdiFont
->entry
);
4301 LeaveCriticalSection( &freetype_cs
);
4307 TRACE("destroying hfont=%p\n", handle
);
4309 dump_gdi_font_list();
4311 font_elem_ptr
= list_head(&gdi_font_list
);
4312 while(font_elem_ptr
) {
4313 gdiFont
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
4314 font_elem_ptr
= list_next(&gdi_font_list
, font_elem_ptr
);
4316 hfontlist_elem_ptr
= list_head(&gdiFont
->hfontlist
);
4317 while(hfontlist_elem_ptr
) {
4318 hflist
= LIST_ENTRY(hfontlist_elem_ptr
, struct tagHFONTLIST
, entry
);
4319 hfontlist_elem_ptr
= list_next(&gdiFont
->hfontlist
, hfontlist_elem_ptr
);
4320 if(hflist
->hfont
== handle
) {
4321 list_remove(&hflist
->entry
);
4322 HeapFree(GetProcessHeap(), 0, hflist
);
4326 if(list_empty(&gdiFont
->hfontlist
)) {
4327 TRACE("Moving to Unused list\n");
4328 list_remove(&gdiFont
->entry
);
4329 list_add_head(&unused_gdi_font_list
, &gdiFont
->entry
);
4334 font_elem_ptr
= list_head(&unused_gdi_font_list
);
4335 while(font_elem_ptr
&& i
++ < UNUSED_CACHE_SIZE
)
4336 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
4337 while(font_elem_ptr
) {
4338 gdiFont
= LIST_ENTRY(font_elem_ptr
, struct tagGdiFont
, entry
);
4339 font_elem_ptr
= list_next(&unused_gdi_font_list
, font_elem_ptr
);
4340 TRACE("freeing %p\n", gdiFont
);
4341 list_remove(&gdiFont
->entry
);
4344 LeaveCriticalSection( &freetype_cs
);
4348 static INT
load_script_name( UINT id
, WCHAR buffer
[LF_FACESIZE
] )
4355 id
+= IDS_FIRST_SCRIPT
;
4356 rsrc
= FindResourceW( gdi32_module
, (LPCWSTR
)(ULONG_PTR
)((id
>> 4) + 1), (LPCWSTR
)6 /*RT_STRING*/ );
4357 if (!rsrc
) return 0;
4358 hMem
= LoadResource( gdi32_module
, rsrc
);
4359 if (!hMem
) return 0;
4361 p
= LockResource( hMem
);
4363 while (id
--) p
+= *p
+ 1;
4365 i
= min(LF_FACESIZE
- 1, *p
);
4366 memcpy(buffer
, p
+ 1, i
* sizeof(WCHAR
));
4372 /***************************************************
4373 * create_enum_charset_list
4375 * This function creates charset enumeration list because in DEFAULT_CHARSET
4376 * case, the ANSI codepage's charset takes precedence over other charsets.
4377 * This function works as a filter other than DEFAULT_CHARSET case.
4379 static DWORD
create_enum_charset_list(DWORD charset
, struct enum_charset_list
*list
)
4384 if (TranslateCharsetInfo(ULongToPtr(charset
), &csi
, TCI_SRCCHARSET
) &&
4385 csi
.fs
.fsCsb
[0] != 0) {
4386 list
->element
[n
].mask
= csi
.fs
.fsCsb
[0];
4387 list
->element
[n
].charset
= csi
.ciCharset
;
4388 load_script_name( ffs(csi
.fs
.fsCsb
[0]) - 1, list
->element
[n
].name
);
4391 else { /* charset is DEFAULT_CHARSET or invalid. */
4394 /* Set the current codepage's charset as the first element. */
4396 if (TranslateCharsetInfo((DWORD
*)(INT_PTR
)acp
, &csi
, TCI_SRCCODEPAGE
) &&
4397 csi
.fs
.fsCsb
[0] != 0) {
4398 list
->element
[n
].mask
= csi
.fs
.fsCsb
[0];
4399 list
->element
[n
].charset
= csi
.ciCharset
;
4400 load_script_name( ffs(csi
.fs
.fsCsb
[0]) - 1, list
->element
[n
].name
);
4404 /* Fill out left elements. */
4405 for (i
= 0; i
< 32; i
++) {
4407 fs
.fsCsb
[0] = 1L << i
;
4409 if (n
> 0 && fs
.fsCsb
[0] == list
->element
[0].mask
)
4410 continue; /* skip, already added. */
4411 if (!TranslateCharsetInfo(fs
.fsCsb
, &csi
, TCI_SRCFONTSIG
))
4412 continue; /* skip, this is an invalid fsCsb bit. */
4414 list
->element
[n
].mask
= fs
.fsCsb
[0];
4415 list
->element
[n
].charset
= csi
.ciCharset
;
4416 load_script_name( i
, list
->element
[n
].name
);
4425 static void GetEnumStructs(Face
*face
, LPENUMLOGFONTEXW pelf
,
4426 NEWTEXTMETRICEXW
*pntm
, LPDWORD ptype
)
4431 if (face
->cached_enum_data
)
4434 *pelf
= face
->cached_enum_data
->elf
;
4435 *pntm
= face
->cached_enum_data
->ntm
;
4436 *ptype
= face
->cached_enum_data
->type
;
4440 font
= alloc_font();
4442 if(face
->scalable
) {
4443 height
= -2048; /* 2048 is the most common em size */
4446 height
= face
->size
.y_ppem
>> 6;
4447 width
= face
->size
.x_ppem
>> 6;
4449 font
->scale_y
= 1.0;
4451 if (!(font
->ft_face
= OpenFontFace(font
, face
, width
, height
)))
4457 font
->name
= strdupW(face
->family
->FamilyName
);
4458 font
->ntmFlags
= face
->ntmFlags
;
4460 if (get_outline_text_metrics(font
))
4462 memcpy(&pntm
->ntmTm
, &font
->potm
->otmTextMetrics
, sizeof(TEXTMETRICW
));
4464 pntm
->ntmTm
.ntmSizeEM
= font
->potm
->otmEMSquare
;
4466 lstrcpynW(pelf
->elfLogFont
.lfFaceName
,
4467 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpFamilyName
),
4469 lstrcpynW(pelf
->elfFullName
,
4470 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpFullName
),
4472 lstrcpynW(pelf
->elfStyle
,
4473 (WCHAR
*)((char*)font
->potm
+ (ULONG_PTR
)font
->potm
->otmpStyleName
),
4478 get_text_metrics(font
, (TEXTMETRICW
*)&pntm
->ntmTm
);
4480 pntm
->ntmTm
.ntmSizeEM
= pntm
->ntmTm
.tmHeight
- pntm
->ntmTm
.tmInternalLeading
;
4482 lstrcpynW(pelf
->elfLogFont
.lfFaceName
, face
->family
->FamilyName
, LF_FACESIZE
);
4484 lstrcpynW(pelf
->elfFullName
, face
->FullName
, LF_FULLFACESIZE
);
4486 lstrcpynW(pelf
->elfFullName
, face
->family
->FamilyName
, LF_FULLFACESIZE
);
4487 lstrcpynW(pelf
->elfStyle
, face
->StyleName
, LF_FACESIZE
);
4490 pntm
->ntmTm
.ntmFlags
= face
->ntmFlags
;
4491 pntm
->ntmTm
.ntmCellHeight
= pntm
->ntmTm
.tmHeight
;
4492 pntm
->ntmTm
.ntmAvgWidth
= pntm
->ntmTm
.tmAveCharWidth
;
4493 pntm
->ntmFontSig
= face
->fs
;
4495 pelf
->elfScript
[0] = '\0'; /* This will get set in WineEngEnumFonts */
4497 pelf
->elfLogFont
.lfEscapement
= 0;
4498 pelf
->elfLogFont
.lfOrientation
= 0;
4499 pelf
->elfLogFont
.lfHeight
= pntm
->ntmTm
.tmHeight
;
4500 pelf
->elfLogFont
.lfWidth
= pntm
->ntmTm
.tmAveCharWidth
;
4501 pelf
->elfLogFont
.lfWeight
= pntm
->ntmTm
.tmWeight
;
4502 pelf
->elfLogFont
.lfItalic
= pntm
->ntmTm
.tmItalic
;
4503 pelf
->elfLogFont
.lfUnderline
= pntm
->ntmTm
.tmUnderlined
;
4504 pelf
->elfLogFont
.lfStrikeOut
= pntm
->ntmTm
.tmStruckOut
;
4505 pelf
->elfLogFont
.lfCharSet
= pntm
->ntmTm
.tmCharSet
;
4506 pelf
->elfLogFont
.lfOutPrecision
= OUT_STROKE_PRECIS
;
4507 pelf
->elfLogFont
.lfClipPrecision
= CLIP_STROKE_PRECIS
;
4508 pelf
->elfLogFont
.lfQuality
= DRAFT_QUALITY
;
4509 pelf
->elfLogFont
.lfPitchAndFamily
= (pntm
->ntmTm
.tmPitchAndFamily
& 0xf1) + 1;
4512 if (pntm
->ntmTm
.tmPitchAndFamily
& TMPF_TRUETYPE
)
4513 *ptype
|= TRUETYPE_FONTTYPE
;
4514 if (pntm
->ntmTm
.tmPitchAndFamily
& TMPF_DEVICE
)
4515 *ptype
|= DEVICE_FONTTYPE
;
4516 if(!(pntm
->ntmTm
.tmPitchAndFamily
& TMPF_VECTOR
))
4517 *ptype
|= RASTER_FONTTYPE
;
4519 face
->cached_enum_data
= HeapAlloc(GetProcessHeap(), 0, sizeof(*face
->cached_enum_data
));
4520 if (face
->cached_enum_data
)
4522 face
->cached_enum_data
->elf
= *pelf
;
4523 face
->cached_enum_data
->ntm
= *pntm
;
4524 face
->cached_enum_data
->type
= *ptype
;
4530 static BOOL
family_matches(Family
*family
, const LOGFONTW
*lf
)
4532 struct list
*face_elem_ptr
;
4534 if (!strcmpiW(lf
->lfFaceName
, family
->FamilyName
)) return TRUE
;
4536 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
)
4538 static const WCHAR spaceW
[] = { ' ',0 };
4539 WCHAR full_family_name
[LF_FULLFACESIZE
];
4540 Face
*face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
4542 if (strlenW(family
->FamilyName
) + strlenW(face
->StyleName
) + 2 > LF_FULLFACESIZE
)
4544 FIXME("Length of %s + %s + 2 is longer than LF_FULLFACESIZE\n",
4545 debugstr_w(family
->FamilyName
), debugstr_w(face
->StyleName
));
4549 strcpyW(full_family_name
, family
->FamilyName
);
4550 strcatW(full_family_name
, spaceW
);
4551 strcatW(full_family_name
, face
->StyleName
);
4552 if (!strcmpiW(lf
->lfFaceName
, full_family_name
)) return TRUE
;
4558 static BOOL
face_matches(Face
*face
, const LOGFONTW
*lf
)
4560 static const WCHAR spaceW
[] = { ' ',0 };
4561 WCHAR full_family_name
[LF_FULLFACESIZE
];
4563 if (!strcmpiW(lf
->lfFaceName
, face
->family
->FamilyName
)) return TRUE
;
4565 if (strlenW(face
->family
->FamilyName
) + strlenW(face
->StyleName
) + 2 > LF_FULLFACESIZE
)
4567 FIXME("Length of %s + %s + 2 is longer than LF_FULLFACESIZE\n",
4568 debugstr_w(face
->family
->FamilyName
), debugstr_w(face
->StyleName
));
4572 strcpyW(full_family_name
, face
->family
->FamilyName
);
4573 strcatW(full_family_name
, spaceW
);
4574 strcatW(full_family_name
, face
->StyleName
);
4575 return !strcmpiW(lf
->lfFaceName
, full_family_name
);
4578 static BOOL
enum_face_charsets(Face
*face
, struct enum_charset_list
*list
,
4579 FONTENUMPROCW proc
, LPARAM lparam
)
4582 NEWTEXTMETRICEXW ntm
;
4586 GetEnumStructs(face
, &elf
, &ntm
, &type
);
4587 for(i
= 0; i
< list
->total
; i
++) {
4588 if(!face
->scalable
&& face
->fs
.fsCsb
[0] == 0) { /* OEM bitmap */
4589 elf
.elfLogFont
.lfCharSet
= ntm
.ntmTm
.tmCharSet
= OEM_CHARSET
;
4590 load_script_name( IDS_OEM_DOS
, elf
.elfScript
);
4591 i
= list
->total
; /* break out of loop after enumeration */
4592 } else if(!(face
->fs
.fsCsb
[0] & list
->element
[i
].mask
))
4595 elf
.elfLogFont
.lfCharSet
= ntm
.ntmTm
.tmCharSet
= list
->element
[i
].charset
;
4596 strcpyW(elf
.elfScript
, list
->element
[i
].name
);
4597 if (!elf
.elfScript
[0])
4598 FIXME("Unknown elfscript for bit %d\n", ffs(list
->element
[i
].mask
) - 1);
4600 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
4601 debugstr_w(elf
.elfLogFont
.lfFaceName
),
4602 debugstr_w(elf
.elfFullName
), debugstr_w(elf
.elfStyle
),
4603 elf
.elfLogFont
.lfCharSet
, type
, debugstr_w(elf
.elfScript
),
4604 elf
.elfLogFont
.lfItalic
, elf
.elfLogFont
.lfWeight
,
4605 ntm
.ntmTm
.ntmFlags
);
4606 /* release section before callback (FIXME) */
4607 LeaveCriticalSection( &freetype_cs
);
4608 if (!proc(&elf
.elfLogFont
, (TEXTMETRICW
*)&ntm
, type
, lparam
)) return FALSE
;
4609 EnterCriticalSection( &freetype_cs
);
4614 /*************************************************************
4615 * freetype_EnumFonts
4617 static BOOL
freetype_EnumFonts( PHYSDEV dev
, LPLOGFONTW plf
, FONTENUMPROCW proc
, LPARAM lparam
)
4621 struct list
*family_elem_ptr
, *face_elem_ptr
;
4623 struct enum_charset_list enum_charsets
;
4627 lf
.lfCharSet
= DEFAULT_CHARSET
;
4628 lf
.lfPitchAndFamily
= 0;
4629 lf
.lfFaceName
[0] = 0;
4633 TRACE("facename = %s charset %d\n", debugstr_w(plf
->lfFaceName
), plf
->lfCharSet
);
4635 create_enum_charset_list(plf
->lfCharSet
, &enum_charsets
);
4638 EnterCriticalSection( &freetype_cs
);
4639 if(plf
->lfFaceName
[0]) {
4641 psub
= get_font_subst(&font_subst_list
, plf
->lfFaceName
, plf
->lfCharSet
);
4644 TRACE("substituting %s -> %s\n", debugstr_w(plf
->lfFaceName
),
4645 debugstr_w(psub
->to
.name
));
4647 strcpyW(lf
.lfFaceName
, psub
->to
.name
);
4651 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
4652 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
4653 if(family_matches(family
, plf
)) {
4654 LIST_FOR_EACH(face_elem_ptr
, &family
->faces
) {
4655 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
4656 if (!face_matches(face
, plf
)) continue;
4657 if (!enum_face_charsets(face
, &enum_charsets
, proc
, lparam
)) return FALSE
;
4662 LIST_FOR_EACH(family_elem_ptr
, &font_list
) {
4663 family
= LIST_ENTRY(family_elem_ptr
, Family
, entry
);
4664 face_elem_ptr
= list_head(&family
->faces
);
4665 face
= LIST_ENTRY(face_elem_ptr
, Face
, entry
);
4666 if (!enum_face_charsets(face
, &enum_charsets
, proc
, lparam
)) return FALSE
;
4669 LeaveCriticalSection( &freetype_cs
);
4673 static void FTVectorToPOINTFX(FT_Vector
*vec
, POINTFX
*pt
)
4675 pt
->x
.value
= vec
->x
>> 6;
4676 pt
->x
.fract
= (vec
->x
& 0x3f) << 10;
4677 pt
->x
.fract
|= ((pt
->x
.fract
>> 6) | (pt
->x
.fract
>> 12));
4678 pt
->y
.value
= vec
->y
>> 6;
4679 pt
->y
.fract
= (vec
->y
& 0x3f) << 10;
4680 pt
->y
.fract
|= ((pt
->y
.fract
>> 6) | (pt
->y
.fract
>> 12));
4684 /***************************************************
4685 * According to the MSDN documentation on WideCharToMultiByte,
4686 * certain codepages cannot set the default_used parameter.
4687 * This returns TRUE if the codepage can set that parameter, false else
4688 * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
4690 static BOOL
codepage_sets_default_used(UINT codepage
)
4704 * GSUB Table handling functions
4707 static INT
GSUB_is_glyph_covered(LPCVOID table
, UINT glyph
)
4709 const GSUB_CoverageFormat1
* cf1
;
4713 if (GET_BE_WORD(cf1
->CoverageFormat
) == 1)
4715 int count
= GET_BE_WORD(cf1
->GlyphCount
);
4717 TRACE("Coverage Format 1, %i glyphs\n",count
);
4718 for (i
= 0; i
< count
; i
++)
4719 if (glyph
== GET_BE_WORD(cf1
->GlyphArray
[i
]))
4723 else if (GET_BE_WORD(cf1
->CoverageFormat
) == 2)
4725 const GSUB_CoverageFormat2
* cf2
;
4728 cf2
= (const GSUB_CoverageFormat2
*)cf1
;
4730 count
= GET_BE_WORD(cf2
->RangeCount
);
4731 TRACE("Coverage Format 2, %i ranges\n",count
);
4732 for (i
= 0; i
< count
; i
++)
4734 if (glyph
< GET_BE_WORD(cf2
->RangeRecord
[i
].Start
))
4736 if ((glyph
>= GET_BE_WORD(cf2
->RangeRecord
[i
].Start
)) &&
4737 (glyph
<= GET_BE_WORD(cf2
->RangeRecord
[i
].End
)))
4739 return (GET_BE_WORD(cf2
->RangeRecord
[i
].StartCoverageIndex
) +
4740 glyph
- GET_BE_WORD(cf2
->RangeRecord
[i
].Start
));
4746 ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1
->CoverageFormat
));
4751 static const GSUB_Script
* GSUB_get_script_table( const GSUB_Header
* header
, const char* tag
)
4753 const GSUB_ScriptList
*script
;
4754 const GSUB_Script
*deflt
= NULL
;
4756 script
= (const GSUB_ScriptList
*)((const BYTE
*)header
+ GET_BE_WORD(header
->ScriptList
));
4758 TRACE("%i scripts in this font\n",GET_BE_WORD(script
->ScriptCount
));
4759 for (i
= 0; i
< GET_BE_WORD(script
->ScriptCount
); i
++)
4761 const GSUB_Script
*scr
;
4764 offset
= GET_BE_WORD(script
->ScriptRecord
[i
].Script
);
4765 scr
= (const GSUB_Script
*)((const BYTE
*)script
+ offset
);
4767 if (strncmp(script
->ScriptRecord
[i
].ScriptTag
, tag
,4)==0)
4769 if (strncmp(script
->ScriptRecord
[i
].ScriptTag
, "dflt",4)==0)
4775 static const GSUB_LangSys
* GSUB_get_lang_table( const GSUB_Script
* script
, const char* tag
)
4779 const GSUB_LangSys
*Lang
;
4781 TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script
->DefaultLangSys
), GET_BE_WORD(script
->LangSysCount
));
4783 for (i
= 0; i
< GET_BE_WORD(script
->LangSysCount
) ; i
++)
4785 offset
= GET_BE_WORD(script
->LangSysRecord
[i
].LangSys
);
4786 Lang
= (const GSUB_LangSys
*)((const BYTE
*)script
+ offset
);
4788 if ( strncmp(script
->LangSysRecord
[i
].LangSysTag
,tag
,4)==0)
4791 offset
= GET_BE_WORD(script
->DefaultLangSys
);
4794 Lang
= (const GSUB_LangSys
*)((const BYTE
*)script
+ offset
);
4800 static const GSUB_Feature
* GSUB_get_feature(const GSUB_Header
*header
, const GSUB_LangSys
*lang
, const char* tag
)
4803 const GSUB_FeatureList
*feature
;
4804 feature
= (const GSUB_FeatureList
*)((const BYTE
*)header
+ GET_BE_WORD(header
->FeatureList
));
4806 TRACE("%i features\n",GET_BE_WORD(lang
->FeatureCount
));
4807 for (i
= 0; i
< GET_BE_WORD(lang
->FeatureCount
); i
++)
4809 int index
= GET_BE_WORD(lang
->FeatureIndex
[i
]);
4810 if (strncmp(feature
->FeatureRecord
[index
].FeatureTag
,tag
,4)==0)
4812 const GSUB_Feature
*feat
;
4813 feat
= (const GSUB_Feature
*)((const BYTE
*)feature
+ GET_BE_WORD(feature
->FeatureRecord
[index
].Feature
));
4820 static FT_UInt
GSUB_apply_feature(const GSUB_Header
* header
, const GSUB_Feature
* feature
, UINT glyph
)
4824 const GSUB_LookupList
*lookup
;
4825 lookup
= (const GSUB_LookupList
*)((const BYTE
*)header
+ GET_BE_WORD(header
->LookupList
));
4827 TRACE("%i lookups\n", GET_BE_WORD(feature
->LookupCount
));
4828 for (i
= 0; i
< GET_BE_WORD(feature
->LookupCount
); i
++)
4830 const GSUB_LookupTable
*look
;
4831 offset
= GET_BE_WORD(lookup
->Lookup
[GET_BE_WORD(feature
->LookupListIndex
[i
])]);
4832 look
= (const GSUB_LookupTable
*)((const BYTE
*)lookup
+ offset
);
4833 TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look
->LookupType
),GET_BE_WORD(look
->LookupFlag
),GET_BE_WORD(look
->SubTableCount
));
4834 if (GET_BE_WORD(look
->LookupType
) != 1)
4835 FIXME("We only handle SubType 1\n");
4840 for (j
= 0; j
< GET_BE_WORD(look
->SubTableCount
); j
++)
4842 const GSUB_SingleSubstFormat1
*ssf1
;
4843 offset
= GET_BE_WORD(look
->SubTable
[j
]);
4844 ssf1
= (const GSUB_SingleSubstFormat1
*)((const BYTE
*)look
+offset
);
4845 if (GET_BE_WORD(ssf1
->SubstFormat
) == 1)
4847 int offset
= GET_BE_WORD(ssf1
->Coverage
);
4848 TRACE(" subtype 1, delta %i\n", GET_BE_WORD(ssf1
->DeltaGlyphID
));
4849 if (GSUB_is_glyph_covered((const BYTE
*)ssf1
+offset
, glyph
) != -1)
4851 TRACE(" Glyph 0x%x ->",glyph
);
4852 glyph
+= GET_BE_WORD(ssf1
->DeltaGlyphID
);
4853 TRACE(" 0x%x\n",glyph
);
4858 const GSUB_SingleSubstFormat2
*ssf2
;
4862 ssf2
= (const GSUB_SingleSubstFormat2
*)ssf1
;
4863 offset
= GET_BE_WORD(ssf1
->Coverage
);
4864 TRACE(" subtype 2, glyph count %i\n", GET_BE_WORD(ssf2
->GlyphCount
));
4865 index
= GSUB_is_glyph_covered((const BYTE
*)ssf2
+offset
, glyph
);
4866 TRACE(" Coverage index %i\n",index
);
4869 TRACE(" Glyph is 0x%x ->",glyph
);
4870 glyph
= GET_BE_WORD(ssf2
->Substitute
[index
]);
4871 TRACE("0x%x\n",glyph
);
4880 static const char* get_opentype_script(const GdiFont
*font
)
4883 * I am not sure if this is the correct way to generate our script tag
4886 switch (font
->charset
)
4888 case ANSI_CHARSET
: return "latn";
4889 case BALTIC_CHARSET
: return "latn"; /* ?? */
4890 case CHINESEBIG5_CHARSET
: return "hani";
4891 case EASTEUROPE_CHARSET
: return "latn"; /* ?? */
4892 case GB2312_CHARSET
: return "hani";
4893 case GREEK_CHARSET
: return "grek";
4894 case HANGUL_CHARSET
: return "hang";
4895 case RUSSIAN_CHARSET
: return "cyrl";
4896 case SHIFTJIS_CHARSET
: return "kana";
4897 case TURKISH_CHARSET
: return "latn"; /* ?? */
4898 case VIETNAMESE_CHARSET
: return "latn";
4899 case JOHAB_CHARSET
: return "latn"; /* ?? */
4900 case ARABIC_CHARSET
: return "arab";
4901 case HEBREW_CHARSET
: return "hebr";
4902 case THAI_CHARSET
: return "thai";
4903 default: return "latn";
4907 static FT_UInt
get_GSUB_vert_glyph(const GdiFont
*font
, UINT glyph
)
4909 const GSUB_Header
*header
;
4910 const GSUB_Script
*script
;
4911 const GSUB_LangSys
*language
;
4912 const GSUB_Feature
*feature
;
4914 if (!font
->GSUB_Table
)
4917 header
= font
->GSUB_Table
;
4919 script
= GSUB_get_script_table(header
, get_opentype_script(font
));
4922 TRACE("Script not found\n");
4925 language
= GSUB_get_lang_table(script
, "xxxx"); /* Need to get Lang tag */
4928 TRACE("Language not found\n");
4931 feature
= GSUB_get_feature(header
, language
, "vrt2");
4933 feature
= GSUB_get_feature(header
, language
, "vert");
4936 TRACE("vrt2/vert feature not found\n");
4939 return GSUB_apply_feature(header
, feature
, glyph
);
4942 static FT_UInt
get_glyph_index(const GdiFont
*font
, UINT glyph
)
4946 if(font
->ft_face
->charmap
->encoding
== FT_ENCODING_NONE
) {
4947 WCHAR wc
= (WCHAR
)glyph
;
4949 BOOL
*default_used_pointer
;
4952 default_used_pointer
= NULL
;
4953 default_used
= FALSE
;
4954 if (codepage_sets_default_used(font
->codepage
))
4955 default_used_pointer
= &default_used
;
4956 if(!WideCharToMultiByte(font
->codepage
, 0, &wc
, 1, &buf
, sizeof(buf
), NULL
, default_used_pointer
) || default_used
)
4959 ret
= pFT_Get_Char_Index(font
->ft_face
, (unsigned char)buf
);
4960 TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph
, buf
, ret
, default_used
);
4961 return get_GSUB_vert_glyph(font
,ret
);
4964 if(font
->ft_face
->charmap
->encoding
== FT_ENCODING_MS_SYMBOL
)
4966 if (glyph
< 0x100) glyph
+= 0xf000;
4967 /* there is a number of old pre-Unicode "broken" TTFs, which
4968 do have symbols at U+00XX instead of U+f0XX */
4969 if (!(glyphId
= pFT_Get_Char_Index(font
->ft_face
, glyph
)))
4970 glyphId
= pFT_Get_Char_Index(font
->ft_face
, glyph
-0xf000);
4972 else glyphId
= pFT_Get_Char_Index(font
->ft_face
, glyph
);
4974 return get_GSUB_vert_glyph(font
,glyphId
);
4977 /*************************************************************
4978 * freetype_GetGlyphIndices
4980 static DWORD
freetype_GetGlyphIndices( PHYSDEV dev
, LPCWSTR lpstr
, INT count
, LPWORD pgi
, DWORD flags
)
4982 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
4985 BOOL got_default
= FALSE
;
4989 dev
= GET_NEXT_PHYSDEV( dev
, pGetGlyphIndices
);
4990 return dev
->funcs
->pGetGlyphIndices( dev
, lpstr
, count
, pgi
, flags
);
4993 if (flags
& GGI_MARK_NONEXISTING_GLYPHS
)
4995 default_char
= 0xffff; /* XP would use 0x1f for bitmap fonts */
5000 EnterCriticalSection( &freetype_cs
);
5002 for(i
= 0; i
< count
; i
++)
5004 pgi
[i
] = get_glyph_index(physdev
->font
, lpstr
[i
]);
5009 if (FT_IS_SFNT(physdev
->font
->ft_face
))
5011 TT_OS2
*pOS2
= pFT_Get_Sfnt_Table(physdev
->font
->ft_face
, ft_sfnt_os2
);
5012 default_char
= (pOS2
->usDefaultChar
? get_glyph_index(physdev
->font
, pOS2
->usDefaultChar
) : 0);
5017 get_text_metrics(physdev
->font
, &textm
);
5018 default_char
= textm
.tmDefaultChar
;
5022 pgi
[i
] = default_char
;
5025 LeaveCriticalSection( &freetype_cs
);
5029 static inline BOOL
is_identity_FMAT2(const FMAT2
*matrix
)
5031 static const FMAT2 identity
= { 1.0, 0.0, 0.0, 1.0 };
5032 return !memcmp(matrix
, &identity
, sizeof(FMAT2
));
5035 static inline BOOL
is_identity_MAT2(const MAT2
*matrix
)
5037 static const MAT2 identity
= { {0,1}, {0,0}, {0,0}, {0,1} };
5038 return !memcmp(matrix
, &identity
, sizeof(MAT2
));
5041 static inline BYTE
get_max_level( UINT format
)
5045 case GGO_GRAY2_BITMAP
: return 4;
5046 case GGO_GRAY4_BITMAP
: return 16;
5047 case GGO_GRAY8_BITMAP
: return 64;
5052 static DWORD
get_glyph_outline(GdiFont
*incoming_font
, UINT glyph
, UINT format
,
5053 LPGLYPHMETRICS lpgm
, DWORD buflen
, LPVOID buf
,
5056 static const FT_Matrix identityMat
= {(1 << 16), 0, 0, (1 << 16)};
5057 FT_Face ft_face
= incoming_font
->ft_face
;
5058 GdiFont
*font
= incoming_font
;
5059 FT_UInt glyph_index
;
5060 DWORD width
, height
, pitch
, needed
= 0;
5061 FT_Bitmap ft_bitmap
;
5063 INT left
, right
, top
= 0, bottom
= 0, adv
, lsb
, bbx
;
5065 FT_Int load_flags
= FT_LOAD_DEFAULT
| FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH
;
5066 double widthRatio
= 1.0;
5067 FT_Matrix transMat
= identityMat
;
5068 FT_Matrix transMatUnrotated
;
5069 BOOL needsTransform
= FALSE
;
5070 BOOL tategaki
= (font
->GSUB_Table
!= NULL
);
5071 UINT original_index
;
5073 TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font
, glyph
, format
, lpgm
,
5074 buflen
, buf
, lpmat
);
5076 TRACE("font transform %f %f %f %f\n",
5077 font
->font_desc
.matrix
.eM11
, font
->font_desc
.matrix
.eM12
,
5078 font
->font_desc
.matrix
.eM21
, font
->font_desc
.matrix
.eM22
);
5080 if(format
& GGO_GLYPH_INDEX
) {
5081 glyph_index
= get_GSUB_vert_glyph(incoming_font
,glyph
);
5082 original_index
= glyph
;
5083 format
&= ~GGO_GLYPH_INDEX
;
5085 get_glyph_index_linked(incoming_font
, glyph
, &font
, &glyph_index
);
5086 ft_face
= font
->ft_face
;
5087 original_index
= glyph_index
;
5090 if(format
& GGO_UNHINTED
) {
5091 load_flags
|= FT_LOAD_NO_HINTING
;
5092 format
&= ~GGO_UNHINTED
;
5095 /* tategaki never appears to happen to lower glyph index */
5096 if (glyph_index
< TATEGAKI_LOWER_BOUND
)
5099 if(original_index
>= font
->gmsize
* GM_BLOCK_SIZE
) {
5100 font
->gmsize
= (original_index
/ GM_BLOCK_SIZE
+ 1);
5101 font
->gm
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, font
->gm
,
5102 font
->gmsize
* sizeof(GM
*));
5104 if (format
== GGO_METRICS
&& font
->gm
[original_index
/ GM_BLOCK_SIZE
] != NULL
&&
5105 FONT_GM(font
,original_index
)->init
&& is_identity_MAT2(lpmat
))
5107 *lpgm
= FONT_GM(font
,original_index
)->gm
;
5108 TRACE("cached: %u,%u,%s,%d,%d\n", lpgm
->gmBlackBoxX
, lpgm
->gmBlackBoxY
,
5109 wine_dbgstr_point(&lpgm
->gmptGlyphOrigin
),
5110 lpgm
->gmCellIncX
, lpgm
->gmCellIncY
);
5111 return 1; /* FIXME */
5115 if (!font
->gm
[original_index
/ GM_BLOCK_SIZE
])
5116 font
->gm
[original_index
/ GM_BLOCK_SIZE
] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
, sizeof(GM
) * GM_BLOCK_SIZE
);
5118 /* Scaling factor */
5123 get_text_metrics(font
, &tm
);
5125 widthRatio
= (double)font
->aveWidth
;
5126 widthRatio
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
5129 widthRatio
= font
->scale_y
;
5131 /* Scaling transform */
5132 if (widthRatio
!= 1.0 || font
->scale_y
!= 1.0)
5135 scaleMat
.xx
= FT_FixedFromFloat(widthRatio
);
5138 scaleMat
.yy
= FT_FixedFromFloat(font
->scale_y
);
5140 pFT_Matrix_Multiply(&scaleMat
, &transMat
);
5141 needsTransform
= TRUE
;
5144 /* Slant transform */
5145 if (font
->fake_italic
) {
5148 slantMat
.xx
= (1 << 16);
5149 slantMat
.xy
= ((1 << 16) >> 2);
5151 slantMat
.yy
= (1 << 16);
5152 pFT_Matrix_Multiply(&slantMat
, &transMat
);
5153 needsTransform
= TRUE
;
5156 /* Rotation transform */
5157 transMatUnrotated
= transMat
;
5158 if(font
->orientation
&& !tategaki
) {
5159 FT_Matrix rotationMat
;
5161 angle
= FT_FixedFromFloat((double)font
->orientation
/ 10.0);
5162 pFT_Vector_Unit(&vecAngle
, angle
);
5163 rotationMat
.xx
= vecAngle
.x
;
5164 rotationMat
.xy
= -vecAngle
.y
;
5165 rotationMat
.yx
= -rotationMat
.xy
;
5166 rotationMat
.yy
= rotationMat
.xx
;
5168 pFT_Matrix_Multiply(&rotationMat
, &transMat
);
5169 needsTransform
= TRUE
;
5172 /* World transform */
5173 if (!is_identity_FMAT2(&font
->font_desc
.matrix
))
5176 worldMat
.xx
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM11
);
5177 worldMat
.xy
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM12
);
5178 worldMat
.yx
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM21
);
5179 worldMat
.yy
= FT_FixedFromFloat(font
->font_desc
.matrix
.eM22
);
5180 pFT_Matrix_Multiply(&worldMat
, &transMat
);
5181 pFT_Matrix_Multiply(&worldMat
, &transMatUnrotated
);
5182 needsTransform
= TRUE
;
5185 /* Extra transformation specified by caller */
5186 if (!is_identity_MAT2(lpmat
))
5189 extraMat
.xx
= FT_FixedFromFIXED(lpmat
->eM11
);
5190 extraMat
.xy
= FT_FixedFromFIXED(lpmat
->eM12
);
5191 extraMat
.yx
= FT_FixedFromFIXED(lpmat
->eM21
);
5192 extraMat
.yy
= FT_FixedFromFIXED(lpmat
->eM22
);
5193 pFT_Matrix_Multiply(&extraMat
, &transMat
);
5194 pFT_Matrix_Multiply(&extraMat
, &transMatUnrotated
);
5195 needsTransform
= TRUE
;
5198 if (needsTransform
|| (format
== GGO_NATIVE
|| format
== GGO_BEZIER
||
5199 format
== GGO_GRAY2_BITMAP
|| format
== GGO_GRAY4_BITMAP
||
5200 format
== GGO_GRAY8_BITMAP
))
5202 load_flags
|= FT_LOAD_NO_BITMAP
;
5205 err
= pFT_Load_Glyph(ft_face
, glyph_index
, load_flags
);
5208 WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index
, err
);
5212 if(!needsTransform
) {
5213 left
= (INT
)(ft_face
->glyph
->metrics
.horiBearingX
) & -64;
5214 right
= (INT
)((ft_face
->glyph
->metrics
.horiBearingX
+ ft_face
->glyph
->metrics
.width
) + 63) & -64;
5215 adv
= (INT
)(ft_face
->glyph
->metrics
.horiAdvance
+ 63) >> 6;
5217 top
= (ft_face
->glyph
->metrics
.horiBearingY
+ 63) & -64;
5218 bottom
= (ft_face
->glyph
->metrics
.horiBearingY
-
5219 ft_face
->glyph
->metrics
.height
) & -64;
5220 lpgm
->gmCellIncX
= adv
;
5221 lpgm
->gmCellIncY
= 0;
5228 for(xc
= 0; xc
< 2; xc
++) {
5229 for(yc
= 0; yc
< 2; yc
++) {
5230 vec
.x
= (ft_face
->glyph
->metrics
.horiBearingX
+
5231 xc
* ft_face
->glyph
->metrics
.width
);
5232 vec
.y
= ft_face
->glyph
->metrics
.horiBearingY
-
5233 yc
* ft_face
->glyph
->metrics
.height
;
5234 TRACE("Vec %ld,%ld\n", vec
.x
, vec
.y
);
5235 pFT_Vector_Transform(&vec
, &transMat
);
5236 if(xc
== 0 && yc
== 0) {
5237 left
= right
= vec
.x
;
5238 top
= bottom
= vec
.y
;
5240 if(vec
.x
< left
) left
= vec
.x
;
5241 else if(vec
.x
> right
) right
= vec
.x
;
5242 if(vec
.y
< bottom
) bottom
= vec
.y
;
5243 else if(vec
.y
> top
) top
= vec
.y
;
5248 right
= (right
+ 63) & -64;
5249 bottom
= bottom
& -64;
5250 top
= (top
+ 63) & -64;
5252 TRACE("transformed box: (%d,%d - %d,%d)\n", left
, top
, right
, bottom
);
5253 vec
.x
= ft_face
->glyph
->metrics
.horiAdvance
;
5255 pFT_Vector_Transform(&vec
, &transMat
);
5256 lpgm
->gmCellIncX
= (vec
.x
+63) >> 6;
5257 lpgm
->gmCellIncY
= -((vec
.y
+63) >> 6);
5259 vec
.x
= ft_face
->glyph
->metrics
.horiAdvance
;
5261 pFT_Vector_Transform(&vec
, &transMatUnrotated
);
5262 adv
= (vec
.x
+63) >> 6;
5266 bbx
= (right
- left
) >> 6;
5267 lpgm
->gmBlackBoxX
= (right
- left
) >> 6;
5268 lpgm
->gmBlackBoxY
= (top
- bottom
) >> 6;
5269 lpgm
->gmptGlyphOrigin
.x
= left
>> 6;
5270 lpgm
->gmptGlyphOrigin
.y
= top
>> 6;
5272 TRACE("%u,%u,%s,%d,%d\n", lpgm
->gmBlackBoxX
, lpgm
->gmBlackBoxY
,
5273 wine_dbgstr_point(&lpgm
->gmptGlyphOrigin
),
5274 lpgm
->gmCellIncX
, lpgm
->gmCellIncY
);
5276 if ((format
== GGO_METRICS
|| format
== GGO_BITMAP
|| format
== WINE_GGO_GRAY16_BITMAP
) &&
5277 is_identity_MAT2(lpmat
)) /* don't cache custom transforms */
5279 FONT_GM(font
,original_index
)->gm
= *lpgm
;
5280 FONT_GM(font
,original_index
)->adv
= adv
;
5281 FONT_GM(font
,original_index
)->lsb
= lsb
;
5282 FONT_GM(font
,original_index
)->bbx
= bbx
;
5283 FONT_GM(font
,original_index
)->init
= TRUE
;
5286 if(format
== GGO_METRICS
)
5288 return 1; /* FIXME */
5291 if(ft_face
->glyph
->format
!= ft_glyph_format_outline
&&
5292 (format
== GGO_NATIVE
|| format
== GGO_BEZIER
))
5294 TRACE("loaded a bitmap\n");
5300 width
= lpgm
->gmBlackBoxX
;
5301 height
= lpgm
->gmBlackBoxY
;
5302 pitch
= ((width
+ 31) >> 5) << 2;
5303 needed
= pitch
* height
;
5305 if(!buf
|| !buflen
) break;
5307 switch(ft_face
->glyph
->format
) {
5308 case ft_glyph_format_bitmap
:
5310 BYTE
*src
= ft_face
->glyph
->bitmap
.buffer
, *dst
= buf
;
5311 INT w
= (ft_face
->glyph
->bitmap
.width
+ 7) >> 3;
5312 INT h
= ft_face
->glyph
->bitmap
.rows
;
5314 memcpy(dst
, src
, w
);
5315 src
+= ft_face
->glyph
->bitmap
.pitch
;
5321 case ft_glyph_format_outline
:
5322 ft_bitmap
.width
= width
;
5323 ft_bitmap
.rows
= height
;
5324 ft_bitmap
.pitch
= pitch
;
5325 ft_bitmap
.pixel_mode
= ft_pixel_mode_mono
;
5326 ft_bitmap
.buffer
= buf
;
5329 pFT_Outline_Transform(&ft_face
->glyph
->outline
, &transMat
);
5331 pFT_Outline_Translate(&ft_face
->glyph
->outline
, -left
, -bottom
);
5333 /* Note: FreeType will only set 'black' bits for us. */
5334 memset(buf
, 0, needed
);
5335 pFT_Outline_Get_Bitmap(library
, &ft_face
->glyph
->outline
, &ft_bitmap
);
5339 FIXME("loaded glyph format %x\n", ft_face
->glyph
->format
);
5344 case GGO_GRAY2_BITMAP
:
5345 case GGO_GRAY4_BITMAP
:
5346 case GGO_GRAY8_BITMAP
:
5347 case WINE_GGO_GRAY16_BITMAP
:
5349 unsigned int max_level
, row
, col
;
5352 width
= lpgm
->gmBlackBoxX
;
5353 height
= lpgm
->gmBlackBoxY
;
5354 pitch
= (width
+ 3) / 4 * 4;
5355 needed
= pitch
* height
;
5357 if(!buf
|| !buflen
) break;
5359 max_level
= get_max_level( format
);
5361 switch(ft_face
->glyph
->format
) {
5362 case ft_glyph_format_bitmap
:
5364 BYTE
*src
= ft_face
->glyph
->bitmap
.buffer
, *dst
= buf
;
5365 INT h
= ft_face
->glyph
->bitmap
.rows
;
5367 memset( buf
, 0, needed
);
5369 for(x
= 0; x
< pitch
&& x
< ft_face
->glyph
->bitmap
.width
; x
++)
5370 if (src
[x
/ 8] & (1 << ( (7 - (x
% 8))))) dst
[x
] = max_level
;
5371 src
+= ft_face
->glyph
->bitmap
.pitch
;
5376 case ft_glyph_format_outline
:
5378 ft_bitmap
.width
= width
;
5379 ft_bitmap
.rows
= height
;
5380 ft_bitmap
.pitch
= pitch
;
5381 ft_bitmap
.pixel_mode
= ft_pixel_mode_grays
;
5382 ft_bitmap
.buffer
= buf
;
5385 pFT_Outline_Transform(&ft_face
->glyph
->outline
, &transMat
);
5387 pFT_Outline_Translate(&ft_face
->glyph
->outline
, -left
, -bottom
);
5389 memset(ft_bitmap
.buffer
, 0, buflen
);
5391 pFT_Outline_Get_Bitmap(library
, &ft_face
->glyph
->outline
, &ft_bitmap
);
5393 if (max_level
!= 255)
5395 for (row
= 0, start
= buf
; row
< height
; row
++)
5397 for (col
= 0, ptr
= start
; col
< width
; col
++, ptr
++)
5398 *ptr
= (((int)*ptr
) * max_level
+ 128) / 256;
5406 FIXME("loaded glyph format %x\n", ft_face
->glyph
->format
);
5412 case WINE_GGO_HRGB_BITMAP
:
5413 case WINE_GGO_HBGR_BITMAP
:
5414 case WINE_GGO_VRGB_BITMAP
:
5415 case WINE_GGO_VBGR_BITMAP
:
5416 #ifdef HAVE_FREETYPE_FTLCDFIL_H
5418 switch (ft_face
->glyph
->format
)
5420 case FT_GLYPH_FORMAT_BITMAP
:
5425 width
= lpgm
->gmBlackBoxX
;
5426 height
= lpgm
->gmBlackBoxY
;
5428 needed
= pitch
* height
;
5430 if (!buf
|| !buflen
) break;
5432 memset(buf
, 0, buflen
);
5434 src
= ft_face
->glyph
->bitmap
.buffer
;
5435 src_pitch
= ft_face
->glyph
->bitmap
.pitch
;
5437 height
= min( height
, ft_face
->glyph
->bitmap
.rows
);
5440 for (x
= 0; x
< width
&& x
< ft_face
->glyph
->bitmap
.width
; x
++)
5442 if ( src
[x
/ 8] & (1 << ( (7 - (x
% 8)))) )
5443 ((unsigned int *)dst
)[x
] = ~0u;
5452 case FT_GLYPH_FORMAT_OUTLINE
:
5456 INT x
, src_pitch
, src_width
, src_height
, rgb_interval
, hmul
, vmul
;
5457 INT x_shift
, y_shift
;
5459 FT_LcdFilter lcdfilter
= FT_LCD_FILTER_DEFAULT
;
5460 FT_Render_Mode render_mode
=
5461 (format
== WINE_GGO_HRGB_BITMAP
|| format
== WINE_GGO_HBGR_BITMAP
)?
5462 FT_RENDER_MODE_LCD
: FT_RENDER_MODE_LCD_V
;
5464 if ( lcdfilter
== FT_LCD_FILTER_DEFAULT
|| lcdfilter
== FT_LCD_FILTER_LIGHT
)
5466 if ( render_mode
== FT_RENDER_MODE_LCD
)
5468 lpgm
->gmBlackBoxX
+= 2;
5469 lpgm
->gmptGlyphOrigin
.x
-= 1;
5473 lpgm
->gmBlackBoxY
+= 2;
5474 lpgm
->gmptGlyphOrigin
.y
+= 1;
5478 width
= lpgm
->gmBlackBoxX
;
5479 height
= lpgm
->gmBlackBoxY
;
5481 needed
= pitch
* height
;
5483 if (!buf
|| !buflen
) break;
5485 memset(buf
, 0, buflen
);
5487 rgb
= (format
== WINE_GGO_HRGB_BITMAP
|| format
== WINE_GGO_VRGB_BITMAP
);
5489 if ( needsTransform
)
5490 pFT_Outline_Transform (&ft_face
->glyph
->outline
, &transMat
);
5492 if ( pFT_Library_SetLcdFilter
)
5493 pFT_Library_SetLcdFilter( library
, lcdfilter
);
5494 pFT_Render_Glyph (ft_face
->glyph
, render_mode
);
5496 src
= ft_face
->glyph
->bitmap
.buffer
;
5497 src_pitch
= ft_face
->glyph
->bitmap
.pitch
;
5498 src_width
= ft_face
->glyph
->bitmap
.width
;
5499 src_height
= ft_face
->glyph
->bitmap
.rows
;
5501 if ( render_mode
== FT_RENDER_MODE_LCD
)
5509 rgb_interval
= src_pitch
;
5514 x_shift
= ft_face
->glyph
->bitmap_left
- lpgm
->gmptGlyphOrigin
.x
;
5515 if ( x_shift
< 0 ) x_shift
= 0;
5516 if ( x_shift
+ (src_width
/ hmul
) > width
)
5517 x_shift
= width
- (src_width
/ hmul
);
5519 y_shift
= lpgm
->gmptGlyphOrigin
.y
- ft_face
->glyph
->bitmap_top
;
5520 if ( y_shift
< 0 ) y_shift
= 0;
5521 if ( y_shift
+ (src_height
/ vmul
) > height
)
5522 y_shift
= height
- (src_height
/ vmul
);
5524 dst
+= x_shift
+ y_shift
* ( pitch
/ 4 );
5525 while ( src_height
)
5527 for ( x
= 0; x
< src_width
/ hmul
; x
++ )
5531 dst
[x
] = ((unsigned int)src
[hmul
* x
+ rgb_interval
* 0] << 16) |
5532 ((unsigned int)src
[hmul
* x
+ rgb_interval
* 1] << 8) |
5533 ((unsigned int)src
[hmul
* x
+ rgb_interval
* 2] << 0) |
5534 ((unsigned int)src
[hmul
* x
+ rgb_interval
* 1] << 24) ;
5538 dst
[x
] = ((unsigned int)src
[hmul
* x
+ rgb_interval
* 2] << 16) |
5539 ((unsigned int)src
[hmul
* x
+ rgb_interval
* 1] << 8) |
5540 ((unsigned int)src
[hmul
* x
+ rgb_interval
* 0] << 0) |
5541 ((unsigned int)src
[hmul
* x
+ rgb_interval
* 1] << 24) ;
5544 src
+= src_pitch
* vmul
;
5553 FIXME ("loaded glyph format %x\n", ft_face
->glyph
->format
);
5565 int contour
, point
= 0, first_pt
;
5566 FT_Outline
*outline
= &ft_face
->glyph
->outline
;
5567 TTPOLYGONHEADER
*pph
;
5569 DWORD pph_start
, cpfx
, type
;
5571 if(buflen
== 0) buf
= NULL
;
5573 if (needsTransform
&& buf
) {
5574 pFT_Outline_Transform(outline
, &transMat
);
5577 for(contour
= 0; contour
< outline
->n_contours
; contour
++) {
5579 pph
= (TTPOLYGONHEADER
*)((char *)buf
+ needed
);
5582 pph
->dwType
= TT_POLYGON_TYPE
;
5583 FTVectorToPOINTFX(&outline
->points
[point
], &pph
->pfxStart
);
5585 needed
+= sizeof(*pph
);
5587 while(point
<= outline
->contours
[contour
]) {
5588 ppc
= (TTPOLYCURVE
*)((char *)buf
+ needed
);
5589 type
= (outline
->tags
[point
] & FT_Curve_Tag_On
) ?
5590 TT_PRIM_LINE
: TT_PRIM_QSPLINE
;
5594 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
5597 } while(point
<= outline
->contours
[contour
] &&
5598 (outline
->tags
[point
] & FT_Curve_Tag_On
) ==
5599 (outline
->tags
[point
-1] & FT_Curve_Tag_On
));
5600 /* At the end of a contour Windows adds the start point, but
5602 if(point
> outline
->contours
[contour
] &&
5603 !(outline
->tags
[point
-1] & FT_Curve_Tag_On
)) {
5605 FTVectorToPOINTFX(&outline
->points
[first_pt
], &ppc
->apfx
[cpfx
]);
5607 } else if(point
<= outline
->contours
[contour
] &&
5608 outline
->tags
[point
] & FT_Curve_Tag_On
) {
5609 /* add closing pt for bezier */
5611 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
5619 needed
+= sizeof(*ppc
) + (cpfx
- 1) * sizeof(POINTFX
);
5622 pph
->cb
= needed
- pph_start
;
5628 /* Convert the quadratic Beziers to cubic Beziers.
5629 The parametric eqn for a cubic Bezier is, from PLRM:
5630 r(t) = at^3 + bt^2 + ct + r0
5631 with the control points:
5636 A quadratic Bezier has the form:
5637 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
5639 So equating powers of t leads to:
5640 r1 = 2/3 p1 + 1/3 p0
5641 r2 = 2/3 p1 + 1/3 p2
5642 and of course r0 = p0, r3 = p2
5645 int contour
, point
= 0, first_pt
;
5646 FT_Outline
*outline
= &ft_face
->glyph
->outline
;
5647 TTPOLYGONHEADER
*pph
;
5649 DWORD pph_start
, cpfx
, type
;
5650 FT_Vector cubic_control
[4];
5651 if(buflen
== 0) buf
= NULL
;
5653 if (needsTransform
&& buf
) {
5654 pFT_Outline_Transform(outline
, &transMat
);
5657 for(contour
= 0; contour
< outline
->n_contours
; contour
++) {
5659 pph
= (TTPOLYGONHEADER
*)((char *)buf
+ needed
);
5662 pph
->dwType
= TT_POLYGON_TYPE
;
5663 FTVectorToPOINTFX(&outline
->points
[point
], &pph
->pfxStart
);
5665 needed
+= sizeof(*pph
);
5667 while(point
<= outline
->contours
[contour
]) {
5668 ppc
= (TTPOLYCURVE
*)((char *)buf
+ needed
);
5669 type
= (outline
->tags
[point
] & FT_Curve_Tag_On
) ?
5670 TT_PRIM_LINE
: TT_PRIM_CSPLINE
;
5673 if(type
== TT_PRIM_LINE
) {
5675 FTVectorToPOINTFX(&outline
->points
[point
], &ppc
->apfx
[cpfx
]);
5679 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
5682 /* FIXME: Possible optimization in endpoint calculation
5683 if there are two consecutive curves */
5684 cubic_control
[0] = outline
->points
[point
-1];
5685 if(!(outline
->tags
[point
-1] & FT_Curve_Tag_On
)) {
5686 cubic_control
[0].x
+= outline
->points
[point
].x
+ 1;
5687 cubic_control
[0].y
+= outline
->points
[point
].y
+ 1;
5688 cubic_control
[0].x
>>= 1;
5689 cubic_control
[0].y
>>= 1;
5691 if(point
+1 > outline
->contours
[contour
])
5692 cubic_control
[3] = outline
->points
[first_pt
];
5694 cubic_control
[3] = outline
->points
[point
+1];
5695 if(!(outline
->tags
[point
+1] & FT_Curve_Tag_On
)) {
5696 cubic_control
[3].x
+= outline
->points
[point
].x
+ 1;
5697 cubic_control
[3].y
+= outline
->points
[point
].y
+ 1;
5698 cubic_control
[3].x
>>= 1;
5699 cubic_control
[3].y
>>= 1;
5702 /* r1 = 1/3 p0 + 2/3 p1
5703 r2 = 1/3 p2 + 2/3 p1 */
5704 cubic_control
[1].x
= (2 * outline
->points
[point
].x
+ 1) / 3;
5705 cubic_control
[1].y
= (2 * outline
->points
[point
].y
+ 1) / 3;
5706 cubic_control
[2] = cubic_control
[1];
5707 cubic_control
[1].x
+= (cubic_control
[0].x
+ 1) / 3;
5708 cubic_control
[1].y
+= (cubic_control
[0].y
+ 1) / 3;
5709 cubic_control
[2].x
+= (cubic_control
[3].x
+ 1) / 3;
5710 cubic_control
[2].y
+= (cubic_control
[3].y
+ 1) / 3;
5712 FTVectorToPOINTFX(&cubic_control
[1], &ppc
->apfx
[cpfx
]);
5713 FTVectorToPOINTFX(&cubic_control
[2], &ppc
->apfx
[cpfx
+1]);
5714 FTVectorToPOINTFX(&cubic_control
[3], &ppc
->apfx
[cpfx
+2]);
5719 } while(point
<= outline
->contours
[contour
] &&
5720 (outline
->tags
[point
] & FT_Curve_Tag_On
) ==
5721 (outline
->tags
[point
-1] & FT_Curve_Tag_On
));
5722 /* At the end of a contour Windows adds the start point,
5723 but only for Beziers and we've already done that.
5725 if(point
<= outline
->contours
[contour
] &&
5726 outline
->tags
[point
] & FT_Curve_Tag_On
) {
5727 /* This is the closing pt of a bezier, but we've already
5728 added it, so just inc point and carry on */
5735 needed
+= sizeof(*ppc
) + (cpfx
- 1) * sizeof(POINTFX
);
5738 pph
->cb
= needed
- pph_start
;
5744 FIXME("Unsupported format %d\n", format
);
5750 static BOOL
get_bitmap_text_metrics(GdiFont
*font
)
5752 FT_Face ft_face
= font
->ft_face
;
5753 FT_WinFNT_HeaderRec winfnt_header
;
5754 const DWORD size
= offsetof(OUTLINETEXTMETRICW
, otmFiller
);
5755 font
->potm
= HeapAlloc(GetProcessHeap(), 0, size
);
5756 font
->potm
->otmSize
= size
;
5758 #define TM font->potm->otmTextMetrics
5759 if(!pFT_Get_WinFNT_Header(ft_face
, &winfnt_header
))
5761 TM
.tmHeight
= winfnt_header
.pixel_height
;
5762 TM
.tmAscent
= winfnt_header
.ascent
;
5763 TM
.tmDescent
= TM
.tmHeight
- TM
.tmAscent
;
5764 TM
.tmInternalLeading
= winfnt_header
.internal_leading
;
5765 TM
.tmExternalLeading
= winfnt_header
.external_leading
;
5766 TM
.tmAveCharWidth
= winfnt_header
.avg_width
;
5767 TM
.tmMaxCharWidth
= winfnt_header
.max_width
;
5768 TM
.tmWeight
= winfnt_header
.weight
;
5770 TM
.tmDigitizedAspectX
= winfnt_header
.horizontal_resolution
;
5771 TM
.tmDigitizedAspectY
= winfnt_header
.vertical_resolution
;
5772 TM
.tmFirstChar
= winfnt_header
.first_char
;
5773 TM
.tmLastChar
= winfnt_header
.last_char
;
5774 TM
.tmDefaultChar
= winfnt_header
.default_char
+ winfnt_header
.first_char
;
5775 TM
.tmBreakChar
= winfnt_header
.break_char
+ winfnt_header
.first_char
;
5776 TM
.tmItalic
= winfnt_header
.italic
;
5777 TM
.tmUnderlined
= font
->underline
;
5778 TM
.tmStruckOut
= font
->strikeout
;
5779 TM
.tmPitchAndFamily
= winfnt_header
.pitch_and_family
;
5780 TM
.tmCharSet
= winfnt_header
.charset
;
5784 TM
.tmAscent
= ft_face
->size
->metrics
.ascender
>> 6;
5785 TM
.tmDescent
= -ft_face
->size
->metrics
.descender
>> 6;
5786 TM
.tmHeight
= TM
.tmAscent
+ TM
.tmDescent
;
5787 TM
.tmInternalLeading
= TM
.tmHeight
- ft_face
->size
->metrics
.y_ppem
;
5788 TM
.tmExternalLeading
= (ft_face
->size
->metrics
.height
>> 6) - TM
.tmHeight
;
5789 TM
.tmMaxCharWidth
= ft_face
->size
->metrics
.max_advance
>> 6;
5790 TM
.tmAveCharWidth
= TM
.tmMaxCharWidth
* 2 / 3; /* FIXME */
5791 TM
.tmWeight
= ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
? FW_BOLD
: FW_NORMAL
;
5793 TM
.tmDigitizedAspectX
= 96; /* FIXME */
5794 TM
.tmDigitizedAspectY
= 96; /* FIXME */
5796 TM
.tmLastChar
= 255;
5797 TM
.tmDefaultChar
= 32;
5798 TM
.tmBreakChar
= 32;
5799 TM
.tmItalic
= ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
? 1 : 0;
5800 TM
.tmUnderlined
= font
->underline
;
5801 TM
.tmStruckOut
= font
->strikeout
;
5802 /* NB inverted meaning of TMPF_FIXED_PITCH */
5803 TM
.tmPitchAndFamily
= ft_face
->face_flags
& FT_FACE_FLAG_FIXED_WIDTH
? 0 : TMPF_FIXED_PITCH
;
5804 TM
.tmCharSet
= font
->charset
;
5812 static void scale_font_metrics(const GdiFont
*font
, LPTEXTMETRICW ptm
)
5814 double scale_x
, scale_y
;
5818 scale_x
= (double)font
->aveWidth
;
5819 scale_x
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
5822 scale_x
= font
->scale_y
;
5824 scale_x
*= fabs(font
->font_desc
.matrix
.eM11
);
5825 scale_y
= font
->scale_y
* fabs(font
->font_desc
.matrix
.eM22
);
5827 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
5828 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
5830 SCALE_Y(ptm
->tmHeight
);
5831 SCALE_Y(ptm
->tmAscent
);
5832 SCALE_Y(ptm
->tmDescent
);
5833 SCALE_Y(ptm
->tmInternalLeading
);
5834 SCALE_Y(ptm
->tmExternalLeading
);
5835 SCALE_Y(ptm
->tmOverhang
);
5837 SCALE_X(ptm
->tmAveCharWidth
);
5838 SCALE_X(ptm
->tmMaxCharWidth
);
5844 static void scale_outline_font_metrics(const GdiFont
*font
, OUTLINETEXTMETRICW
*potm
)
5846 double scale_x
, scale_y
;
5850 scale_x
= (double)font
->aveWidth
;
5851 scale_x
/= (double)font
->potm
->otmTextMetrics
.tmAveCharWidth
;
5854 scale_x
= font
->scale_y
;
5856 scale_x
*= fabs(font
->font_desc
.matrix
.eM11
);
5857 scale_y
= font
->scale_y
* fabs(font
->font_desc
.matrix
.eM22
);
5859 scale_font_metrics(font
, &potm
->otmTextMetrics
);
5861 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
5862 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
5864 SCALE_Y(potm
->otmAscent
);
5865 SCALE_Y(potm
->otmDescent
);
5866 SCALE_Y(potm
->otmLineGap
);
5867 SCALE_Y(potm
->otmsCapEmHeight
);
5868 SCALE_Y(potm
->otmsXHeight
);
5869 SCALE_Y(potm
->otmrcFontBox
.top
);
5870 SCALE_Y(potm
->otmrcFontBox
.bottom
);
5871 SCALE_X(potm
->otmrcFontBox
.left
);
5872 SCALE_X(potm
->otmrcFontBox
.right
);
5873 SCALE_Y(potm
->otmMacAscent
);
5874 SCALE_Y(potm
->otmMacDescent
);
5875 SCALE_Y(potm
->otmMacLineGap
);
5876 SCALE_X(potm
->otmptSubscriptSize
.x
);
5877 SCALE_Y(potm
->otmptSubscriptSize
.y
);
5878 SCALE_X(potm
->otmptSubscriptOffset
.x
);
5879 SCALE_Y(potm
->otmptSubscriptOffset
.y
);
5880 SCALE_X(potm
->otmptSuperscriptSize
.x
);
5881 SCALE_Y(potm
->otmptSuperscriptSize
.y
);
5882 SCALE_X(potm
->otmptSuperscriptOffset
.x
);
5883 SCALE_Y(potm
->otmptSuperscriptOffset
.y
);
5884 SCALE_Y(potm
->otmsStrikeoutSize
);
5885 SCALE_Y(potm
->otmsStrikeoutPosition
);
5886 SCALE_Y(potm
->otmsUnderscoreSize
);
5887 SCALE_Y(potm
->otmsUnderscorePosition
);
5893 static BOOL
get_text_metrics(GdiFont
*font
, LPTEXTMETRICW ptm
)
5897 if (!get_outline_text_metrics(font
) && !get_bitmap_text_metrics(font
)) return FALSE
;
5899 /* Make sure that the font has sane width/height ratio */
5902 if ((font
->aveWidth
+ font
->potm
->otmTextMetrics
.tmHeight
- 1) / font
->potm
->otmTextMetrics
.tmHeight
> 100)
5904 WARN("Ignoring too large font->aveWidth %d\n", font
->aveWidth
);
5909 *ptm
= font
->potm
->otmTextMetrics
;
5910 scale_font_metrics(font
, ptm
);
5914 static BOOL
face_has_symbol_charmap(FT_Face ft_face
)
5918 for(i
= 0; i
< ft_face
->num_charmaps
; i
++)
5920 if(ft_face
->charmaps
[i
]->encoding
== FT_ENCODING_MS_SYMBOL
)
5926 static BOOL
get_outline_text_metrics(GdiFont
*font
)
5929 FT_Face ft_face
= font
->ft_face
;
5930 UINT needed
, lenfam
, lensty
;
5932 TT_HoriHeader
*pHori
;
5933 TT_Postscript
*pPost
;
5934 FT_Fixed x_scale
, y_scale
;
5935 WCHAR
*family_nameW
, *style_nameW
;
5936 static const WCHAR spaceW
[] = {' ', '\0'};
5938 INT ascent
, descent
;
5940 TRACE("font=%p\n", font
);
5942 if(!FT_IS_SCALABLE(ft_face
))
5945 needed
= sizeof(*font
->potm
);
5947 lenfam
= (strlenW(font
->name
) + 1) * sizeof(WCHAR
);
5948 family_nameW
= strdupW(font
->name
);
5950 lensty
= MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1, NULL
, 0)
5952 style_nameW
= HeapAlloc(GetProcessHeap(), 0, lensty
);
5953 MultiByteToWideChar(CP_ACP
, 0, ft_face
->style_name
, -1,
5954 style_nameW
, lensty
/sizeof(WCHAR
));
5956 /* These names should be read from the TT name table */
5958 /* length of otmpFamilyName */
5961 /* length of otmpFaceName */
5962 if ((ft_face
->style_flags
& (FT_STYLE_FLAG_ITALIC
| FT_STYLE_FLAG_BOLD
)) == 0) {
5963 needed
+= lenfam
; /* just the family name */
5965 needed
+= lenfam
+ lensty
; /* family + " " + style */
5968 /* length of otmpStyleName */
5971 /* length of otmpFullName */
5972 needed
+= lenfam
+ lensty
;
5975 x_scale
= ft_face
->size
->metrics
.x_scale
;
5976 y_scale
= ft_face
->size
->metrics
.y_scale
;
5978 pOS2
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_os2
);
5980 FIXME("Can't find OS/2 table - not TT font?\n");
5984 pHori
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_hhea
);
5986 FIXME("Can't find HHEA table - not TT font?\n");
5990 pPost
= pFT_Get_Sfnt_Table(ft_face
, ft_sfnt_post
); /* we can live with this failing */
5992 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",
5993 pOS2
->usWinAscent
, pOS2
->usWinDescent
,
5994 pOS2
->sTypoAscender
, pOS2
->sTypoDescender
, pOS2
->sTypoLineGap
,
5995 ft_face
->ascender
, ft_face
->descender
, ft_face
->height
,
5996 pHori
->Ascender
, pHori
->Descender
, pHori
->Line_Gap
,
5997 ft_face
->bbox
.yMax
, ft_face
->bbox
.yMin
);
5999 font
->potm
= HeapAlloc(GetProcessHeap(), 0, needed
);
6000 font
->potm
->otmSize
= needed
;
6002 #define TM font->potm->otmTextMetrics
6004 if(pOS2
->usWinAscent
+ pOS2
->usWinDescent
== 0) {
6005 ascent
= pHori
->Ascender
;
6006 descent
= -pHori
->Descender
;
6008 ascent
= pOS2
->usWinAscent
;
6009 descent
= pOS2
->usWinDescent
;
6013 TM
.tmAscent
= font
->yMax
;
6014 TM
.tmDescent
= -font
->yMin
;
6015 TM
.tmInternalLeading
= (TM
.tmAscent
+ TM
.tmDescent
) - ft_face
->size
->metrics
.y_ppem
;
6017 TM
.tmAscent
= (pFT_MulFix(ascent
, y_scale
) + 32) >> 6;
6018 TM
.tmDescent
= (pFT_MulFix(descent
, y_scale
) + 32) >> 6;
6019 TM
.tmInternalLeading
= (pFT_MulFix(ascent
+ descent
6020 - ft_face
->units_per_EM
, y_scale
) + 32) >> 6;
6023 TM
.tmHeight
= TM
.tmAscent
+ TM
.tmDescent
;
6026 el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
6028 TM
.tmExternalLeading
= max(0, (pFT_MulFix(pHori
->Line_Gap
-
6029 ((ascent
+ descent
) -
6030 (pHori
->Ascender
- pHori
->Descender
)), y_scale
) + 32) >> 6);
6032 TM
.tmAveCharWidth
= (pFT_MulFix(pOS2
->xAvgCharWidth
, x_scale
) + 32) >> 6;
6033 if (TM
.tmAveCharWidth
== 0) {
6034 TM
.tmAveCharWidth
= 1;
6036 TM
.tmMaxCharWidth
= (pFT_MulFix(ft_face
->bbox
.xMax
- ft_face
->bbox
.xMin
, x_scale
) + 32) >> 6;
6037 TM
.tmWeight
= FW_REGULAR
;
6038 if (font
->fake_bold
)
6039 TM
.tmWeight
= FW_BOLD
;
6042 if (ft_face
->style_flags
& FT_STYLE_FLAG_BOLD
)
6044 if (pOS2
->usWeightClass
> FW_MEDIUM
)
6045 TM
.tmWeight
= pOS2
->usWeightClass
;
6047 else if (pOS2
->usWeightClass
<= FW_MEDIUM
)
6048 TM
.tmWeight
= pOS2
->usWeightClass
;
6051 TM
.tmDigitizedAspectX
= 300;
6052 TM
.tmDigitizedAspectY
= 300;
6053 /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
6054 * symbol range to 0 - f0ff
6057 if (face_has_symbol_charmap(ft_face
) || (pOS2
->usFirstCharIndex
>= 0xf000 && pOS2
->usFirstCharIndex
< 0xf100))
6062 case 1257: /* Baltic */
6063 TM
.tmLastChar
= 0xf8fd;
6066 TM
.tmLastChar
= 0xf0ff;
6068 TM
.tmBreakChar
= 0x20;
6069 TM
.tmDefaultChar
= 0x1f;
6073 TM
.tmFirstChar
= pOS2
->usFirstCharIndex
; /* Should be the first char in the cmap */
6074 TM
.tmLastChar
= pOS2
->usLastCharIndex
; /* Should be min(cmap_last, os2_last) */
6076 if(pOS2
->usFirstCharIndex
<= 1)
6077 TM
.tmBreakChar
= pOS2
->usFirstCharIndex
+ 2;
6078 else if (pOS2
->usFirstCharIndex
> 0xff)
6079 TM
.tmBreakChar
= 0x20;
6081 TM
.tmBreakChar
= pOS2
->usFirstCharIndex
;
6082 TM
.tmDefaultChar
= TM
.tmBreakChar
- 1;
6084 TM
.tmItalic
= font
->fake_italic
? 255 : ((ft_face
->style_flags
& FT_STYLE_FLAG_ITALIC
) ? 255 : 0);
6085 TM
.tmUnderlined
= font
->underline
;
6086 TM
.tmStruckOut
= font
->strikeout
;
6088 /* Yes TPMF_FIXED_PITCH is correct; braindead api */
6089 if(!FT_IS_FIXED_WIDTH(ft_face
) &&
6090 (pOS2
->version
== 0xFFFFU
||
6091 pOS2
->panose
[PAN_PROPORTION_INDEX
] != PAN_PROP_MONOSPACED
))
6092 TM
.tmPitchAndFamily
= TMPF_FIXED_PITCH
;
6094 TM
.tmPitchAndFamily
= 0;
6096 switch(pOS2
->panose
[PAN_FAMILYTYPE_INDEX
])
6098 case PAN_FAMILY_SCRIPT
:
6099 TM
.tmPitchAndFamily
|= FF_SCRIPT
;
6102 case PAN_FAMILY_DECORATIVE
:
6103 TM
.tmPitchAndFamily
|= FF_DECORATIVE
;
6108 case PAN_FAMILY_TEXT_DISPLAY
:
6109 case PAN_FAMILY_PICTORIAL
: /* symbol fonts get treated as if they were text */
6110 /* which is clearly not what the panose spec says. */
6112 if(TM
.tmPitchAndFamily
== 0 || /* fixed */
6113 pOS2
->panose
[PAN_PROPORTION_INDEX
] == PAN_PROP_MONOSPACED
)
6114 TM
.tmPitchAndFamily
= FF_MODERN
;
6117 switch(pOS2
->panose
[PAN_SERIFSTYLE_INDEX
])
6122 TM
.tmPitchAndFamily
|= FF_DONTCARE
;
6125 case PAN_SERIF_COVE
:
6126 case PAN_SERIF_OBTUSE_COVE
:
6127 case PAN_SERIF_SQUARE_COVE
:
6128 case PAN_SERIF_OBTUSE_SQUARE_COVE
:
6129 case PAN_SERIF_SQUARE
:
6130 case PAN_SERIF_THIN
:
6131 case PAN_SERIF_BONE
:
6132 case PAN_SERIF_EXAGGERATED
:
6133 case PAN_SERIF_TRIANGLE
:
6134 TM
.tmPitchAndFamily
|= FF_ROMAN
;
6137 case PAN_SERIF_NORMAL_SANS
:
6138 case PAN_SERIF_OBTUSE_SANS
:
6139 case PAN_SERIF_PERP_SANS
:
6140 case PAN_SERIF_FLARED
:
6141 case PAN_SERIF_ROUNDED
:
6142 TM
.tmPitchAndFamily
|= FF_SWISS
;
6149 if(FT_IS_SCALABLE(ft_face
))
6150 TM
.tmPitchAndFamily
|= TMPF_VECTOR
;
6152 if(FT_IS_SFNT(ft_face
))
6154 if (font
->ntmFlags
& NTM_PS_OPENTYPE
)
6155 TM
.tmPitchAndFamily
|= TMPF_DEVICE
;
6157 TM
.tmPitchAndFamily
|= TMPF_TRUETYPE
;
6160 TM
.tmCharSet
= font
->charset
;
6162 font
->potm
->otmFiller
= 0;
6163 memcpy(&font
->potm
->otmPanoseNumber
, pOS2
->panose
, PANOSE_COUNT
);
6164 font
->potm
->otmfsSelection
= pOS2
->fsSelection
;
6165 font
->potm
->otmfsType
= pOS2
->fsType
;
6166 font
->potm
->otmsCharSlopeRise
= pHori
->caret_Slope_Rise
;
6167 font
->potm
->otmsCharSlopeRun
= pHori
->caret_Slope_Run
;
6168 font
->potm
->otmItalicAngle
= 0; /* POST table */
6169 font
->potm
->otmEMSquare
= ft_face
->units_per_EM
;
6170 font
->potm
->otmAscent
= (pFT_MulFix(pOS2
->sTypoAscender
, y_scale
) + 32) >> 6;
6171 font
->potm
->otmDescent
= (pFT_MulFix(pOS2
->sTypoDescender
, y_scale
) + 32) >> 6;
6172 font
->potm
->otmLineGap
= (pFT_MulFix(pOS2
->sTypoLineGap
, y_scale
) + 32) >> 6;
6173 font
->potm
->otmsCapEmHeight
= (pFT_MulFix(pOS2
->sCapHeight
, y_scale
) + 32) >> 6;
6174 font
->potm
->otmsXHeight
= (pFT_MulFix(pOS2
->sxHeight
, y_scale
) + 32) >> 6;
6175 font
->potm
->otmrcFontBox
.left
= (pFT_MulFix(ft_face
->bbox
.xMin
, x_scale
) + 32) >> 6;
6176 font
->potm
->otmrcFontBox
.right
= (pFT_MulFix(ft_face
->bbox
.xMax
, x_scale
) + 32) >> 6;
6177 font
->potm
->otmrcFontBox
.top
= (pFT_MulFix(ft_face
->bbox
.yMax
, y_scale
) + 32) >> 6;
6178 font
->potm
->otmrcFontBox
.bottom
= (pFT_MulFix(ft_face
->bbox
.yMin
, y_scale
) + 32) >> 6;
6179 font
->potm
->otmMacAscent
= TM
.tmAscent
;
6180 font
->potm
->otmMacDescent
= -TM
.tmDescent
;
6181 font
->potm
->otmMacLineGap
= font
->potm
->otmLineGap
;
6182 font
->potm
->otmusMinimumPPEM
= 0; /* TT Header */
6183 font
->potm
->otmptSubscriptSize
.x
= (pFT_MulFix(pOS2
->ySubscriptXSize
, x_scale
) + 32) >> 6;
6184 font
->potm
->otmptSubscriptSize
.y
= (pFT_MulFix(pOS2
->ySubscriptYSize
, y_scale
) + 32) >> 6;
6185 font
->potm
->otmptSubscriptOffset
.x
= (pFT_MulFix(pOS2
->ySubscriptXOffset
, x_scale
) + 32) >> 6;
6186 font
->potm
->otmptSubscriptOffset
.y
= (pFT_MulFix(pOS2
->ySubscriptYOffset
, y_scale
) + 32) >> 6;
6187 font
->potm
->otmptSuperscriptSize
.x
= (pFT_MulFix(pOS2
->ySuperscriptXSize
, x_scale
) + 32) >> 6;
6188 font
->potm
->otmptSuperscriptSize
.y
= (pFT_MulFix(pOS2
->ySuperscriptYSize
, y_scale
) + 32) >> 6;
6189 font
->potm
->otmptSuperscriptOffset
.x
= (pFT_MulFix(pOS2
->ySuperscriptXOffset
, x_scale
) + 32) >> 6;
6190 font
->potm
->otmptSuperscriptOffset
.y
= (pFT_MulFix(pOS2
->ySuperscriptYOffset
, y_scale
) + 32) >> 6;
6191 font
->potm
->otmsStrikeoutSize
= (pFT_MulFix(pOS2
->yStrikeoutSize
, y_scale
) + 32) >> 6;
6192 font
->potm
->otmsStrikeoutPosition
= (pFT_MulFix(pOS2
->yStrikeoutPosition
, y_scale
) + 32) >> 6;
6194 font
->potm
->otmsUnderscoreSize
= 0;
6195 font
->potm
->otmsUnderscorePosition
= 0;
6197 font
->potm
->otmsUnderscoreSize
= (pFT_MulFix(pPost
->underlineThickness
, y_scale
) + 32) >> 6;
6198 font
->potm
->otmsUnderscorePosition
= (pFT_MulFix(pPost
->underlinePosition
, y_scale
) + 32) >> 6;
6202 /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
6203 cp
= (char*)font
->potm
+ sizeof(*font
->potm
);
6204 font
->potm
->otmpFamilyName
= (LPSTR
)(cp
- (char*)font
->potm
);
6205 strcpyW((WCHAR
*)cp
, family_nameW
);
6207 font
->potm
->otmpStyleName
= (LPSTR
)(cp
- (char*)font
->potm
);
6208 strcpyW((WCHAR
*)cp
, style_nameW
);
6210 font
->potm
->otmpFaceName
= (LPSTR
)(cp
- (char*)font
->potm
);
6211 strcpyW((WCHAR
*)cp
, family_nameW
);
6212 if (ft_face
->style_flags
& (FT_STYLE_FLAG_ITALIC
| FT_STYLE_FLAG_BOLD
)) {
6213 strcatW((WCHAR
*)cp
, spaceW
);
6214 strcatW((WCHAR
*)cp
, style_nameW
);
6215 cp
+= lenfam
+ lensty
;
6218 font
->potm
->otmpFullName
= (LPSTR
)(cp
- (char*)font
->potm
);
6219 strcpyW((WCHAR
*)cp
, family_nameW
);
6220 strcatW((WCHAR
*)cp
, spaceW
);
6221 strcatW((WCHAR
*)cp
, style_nameW
);
6225 HeapFree(GetProcessHeap(), 0, style_nameW
);
6226 HeapFree(GetProcessHeap(), 0, family_nameW
);
6230 /*************************************************************
6231 * freetype_GetGlyphOutline
6233 static DWORD
freetype_GetGlyphOutline( PHYSDEV dev
, UINT glyph
, UINT format
,
6234 LPGLYPHMETRICS lpgm
, DWORD buflen
, LPVOID buf
, const MAT2
*lpmat
)
6236 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6241 dev
= GET_NEXT_PHYSDEV( dev
, pGetGlyphOutline
);
6242 return dev
->funcs
->pGetGlyphOutline( dev
, glyph
, format
, lpgm
, buflen
, buf
, lpmat
);
6246 EnterCriticalSection( &freetype_cs
);
6247 ret
= get_glyph_outline( physdev
->font
, glyph
, format
, lpgm
, buflen
, buf
, lpmat
);
6248 LeaveCriticalSection( &freetype_cs
);
6252 /*************************************************************
6253 * freetype_GetTextMetrics
6255 static BOOL
freetype_GetTextMetrics( PHYSDEV dev
, TEXTMETRICW
*metrics
)
6257 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6262 dev
= GET_NEXT_PHYSDEV( dev
, pGetTextMetrics
);
6263 return dev
->funcs
->pGetTextMetrics( dev
, metrics
);
6267 EnterCriticalSection( &freetype_cs
);
6268 ret
= get_text_metrics( physdev
->font
, metrics
);
6269 LeaveCriticalSection( &freetype_cs
);
6273 /*************************************************************
6274 * freetype_GetOutlineTextMetrics
6276 static UINT
freetype_GetOutlineTextMetrics( PHYSDEV dev
, UINT cbSize
, OUTLINETEXTMETRICW
*potm
)
6278 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6283 dev
= GET_NEXT_PHYSDEV( dev
, pGetOutlineTextMetrics
);
6284 return dev
->funcs
->pGetOutlineTextMetrics( dev
, cbSize
, potm
);
6287 TRACE("font=%p\n", physdev
->font
);
6289 if (!FT_IS_SCALABLE( physdev
->font
->ft_face
)) return 0;
6292 EnterCriticalSection( &freetype_cs
);
6294 if (physdev
->font
->potm
|| get_outline_text_metrics( physdev
->font
))
6296 if(cbSize
>= physdev
->font
->potm
->otmSize
)
6298 memcpy(potm
, physdev
->font
->potm
, physdev
->font
->potm
->otmSize
);
6299 scale_outline_font_metrics(physdev
->font
, potm
);
6301 ret
= physdev
->font
->potm
->otmSize
;
6303 LeaveCriticalSection( &freetype_cs
);
6307 static BOOL
load_child_font(GdiFont
*font
, CHILD_FONT
*child
)
6309 HFONTLIST
*hfontlist
;
6310 child
->font
= alloc_font();
6311 child
->font
->ft_face
= OpenFontFace(child
->font
, child
->face
, 0, -font
->ppem
);
6312 if(!child
->font
->ft_face
)
6314 free_font(child
->font
);
6319 child
->font
->font_desc
= font
->font_desc
;
6320 child
->font
->ntmFlags
= child
->face
->ntmFlags
;
6321 child
->font
->orientation
= font
->orientation
;
6322 child
->font
->scale_y
= font
->scale_y
;
6323 hfontlist
= HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist
));
6324 hfontlist
->hfont
= CreateFontIndirectW(&font
->font_desc
.lf
);
6325 child
->font
->name
= strdupW(child
->face
->family
->FamilyName
);
6326 list_add_head(&child
->font
->hfontlist
, &hfontlist
->entry
);
6327 child
->font
->base_font
= font
;
6328 list_add_head(&child_font_list
, &child
->font
->entry
);
6329 TRACE("created child font hfont %p for base %p child %p\n", hfontlist
->hfont
, font
, child
->font
);
6333 static BOOL
get_glyph_index_linked(GdiFont
*font
, UINT c
, GdiFont
**linked_font
, FT_UInt
*glyph
)
6336 CHILD_FONT
*child_font
;
6339 font
= font
->base_font
;
6341 *linked_font
= font
;
6343 if((*glyph
= get_glyph_index(font
, c
)))
6346 LIST_FOR_EACH_ENTRY(child_font
, &font
->child_fonts
, CHILD_FONT
, entry
)
6348 if(!child_font
->font
)
6349 if(!load_child_font(font
, child_font
))
6352 if(!child_font
->font
->ft_face
)
6354 g
= get_glyph_index(child_font
->font
, c
);
6358 *linked_font
= child_font
->font
;
6365 /*************************************************************
6366 * freetype_GetCharWidth
6368 static BOOL
freetype_GetCharWidth( PHYSDEV dev
, UINT firstChar
, UINT lastChar
, LPINT buffer
)
6370 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
6373 FT_UInt glyph_index
;
6374 GdiFont
*linked_font
;
6375 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6379 dev
= GET_NEXT_PHYSDEV( dev
, pGetCharWidth
);
6380 return dev
->funcs
->pGetCharWidth( dev
, firstChar
, lastChar
, buffer
);
6383 TRACE("%p, %d, %d, %p\n", physdev
->font
, firstChar
, lastChar
, buffer
);
6386 EnterCriticalSection( &freetype_cs
);
6387 for(c
= firstChar
; c
<= lastChar
; c
++) {
6388 get_glyph_index_linked(physdev
->font
, c
, &linked_font
, &glyph_index
);
6389 get_glyph_outline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
6390 &gm
, 0, NULL
, &identity
);
6391 buffer
[c
- firstChar
] = FONT_GM(linked_font
,glyph_index
)->adv
;
6393 LeaveCriticalSection( &freetype_cs
);
6397 /*************************************************************
6398 * freetype_GetCharABCWidths
6400 static BOOL
freetype_GetCharABCWidths( PHYSDEV dev
, UINT firstChar
, UINT lastChar
, LPABC buffer
)
6402 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
6405 FT_UInt glyph_index
;
6406 GdiFont
*linked_font
;
6407 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6411 dev
= GET_NEXT_PHYSDEV( dev
, pGetCharABCWidths
);
6412 return dev
->funcs
->pGetCharABCWidths( dev
, firstChar
, lastChar
, buffer
);
6415 TRACE("%p, %d, %d, %p\n", physdev
->font
, firstChar
, lastChar
, buffer
);
6417 if(!FT_IS_SCALABLE(physdev
->font
->ft_face
))
6421 EnterCriticalSection( &freetype_cs
);
6423 for(c
= firstChar
; c
<= lastChar
; c
++) {
6424 get_glyph_index_linked(physdev
->font
, c
, &linked_font
, &glyph_index
);
6425 get_glyph_outline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
6426 &gm
, 0, NULL
, &identity
);
6427 buffer
[c
- firstChar
].abcA
= FONT_GM(linked_font
,glyph_index
)->lsb
;
6428 buffer
[c
- firstChar
].abcB
= FONT_GM(linked_font
,glyph_index
)->bbx
;
6429 buffer
[c
- firstChar
].abcC
= FONT_GM(linked_font
,glyph_index
)->adv
- FONT_GM(linked_font
,glyph_index
)->lsb
-
6430 FONT_GM(linked_font
,glyph_index
)->bbx
;
6432 LeaveCriticalSection( &freetype_cs
);
6436 /*************************************************************
6437 * freetype_GetCharABCWidthsI
6439 static BOOL
freetype_GetCharABCWidthsI( PHYSDEV dev
, UINT firstChar
, UINT count
, LPWORD pgi
, LPABC buffer
)
6441 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
6444 FT_UInt glyph_index
;
6445 GdiFont
*linked_font
;
6446 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6450 dev
= GET_NEXT_PHYSDEV( dev
, pGetCharABCWidthsI
);
6451 return dev
->funcs
->pGetCharABCWidthsI( dev
, firstChar
, count
, pgi
, buffer
);
6454 if(!FT_HAS_HORIZONTAL(physdev
->font
->ft_face
))
6458 EnterCriticalSection( &freetype_cs
);
6460 get_glyph_index_linked(physdev
->font
, 'a', &linked_font
, &glyph_index
);
6462 for(c
= firstChar
; c
< firstChar
+count
; c
++) {
6463 get_glyph_outline(linked_font
, c
, GGO_METRICS
| GGO_GLYPH_INDEX
,
6464 &gm
, 0, NULL
, &identity
);
6465 buffer
[c
- firstChar
].abcA
= FONT_GM(linked_font
,c
)->lsb
;
6466 buffer
[c
- firstChar
].abcB
= FONT_GM(linked_font
,c
)->bbx
;
6467 buffer
[c
- firstChar
].abcC
= FONT_GM(linked_font
,c
)->adv
- FONT_GM(linked_font
,c
)->lsb
6468 - FONT_GM(linked_font
,c
)->bbx
;
6471 for(c
= 0; c
< count
; c
++) {
6472 get_glyph_outline(linked_font
, pgi
[c
], GGO_METRICS
| GGO_GLYPH_INDEX
,
6473 &gm
, 0, NULL
, &identity
);
6474 buffer
[c
].abcA
= FONT_GM(linked_font
,pgi
[c
])->lsb
;
6475 buffer
[c
].abcB
= FONT_GM(linked_font
,pgi
[c
])->bbx
;
6476 buffer
[c
].abcC
= FONT_GM(linked_font
,pgi
[c
])->adv
6477 - FONT_GM(linked_font
,pgi
[c
])->lsb
- FONT_GM(linked_font
,pgi
[c
])->bbx
;
6480 LeaveCriticalSection( &freetype_cs
);
6484 /*************************************************************
6485 * freetype_GetTextExtentExPoint
6487 static BOOL
freetype_GetTextExtentExPoint( PHYSDEV dev
, LPCWSTR wstr
, INT count
,
6488 INT max_ext
, LPINT pnfit
, LPINT dxs
, LPSIZE size
)
6490 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
6495 FT_UInt glyph_index
;
6496 GdiFont
*linked_font
;
6497 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6501 dev
= GET_NEXT_PHYSDEV( dev
, pGetTextExtentExPoint
);
6502 return dev
->funcs
->pGetTextExtentExPoint( dev
, wstr
, count
, max_ext
, pnfit
, dxs
, size
);
6505 TRACE("%p, %s, %d, %d, %p\n", physdev
->font
, debugstr_wn(wstr
, count
), count
, max_ext
, size
);
6508 EnterCriticalSection( &freetype_cs
);
6511 get_text_metrics( physdev
->font
, &tm
);
6512 size
->cy
= tm
.tmHeight
;
6514 for(idx
= 0; idx
< count
; idx
++) {
6515 get_glyph_index_linked( physdev
->font
, wstr
[idx
], &linked_font
, &glyph_index
);
6516 get_glyph_outline(linked_font
, glyph_index
, GGO_METRICS
| GGO_GLYPH_INDEX
,
6517 &gm
, 0, NULL
, &identity
);
6518 size
->cx
+= FONT_GM(linked_font
,glyph_index
)->adv
;
6520 if (! pnfit
|| ext
<= max_ext
) {
6530 LeaveCriticalSection( &freetype_cs
);
6531 TRACE("return %d, %d, %d\n", size
->cx
, size
->cy
, nfit
);
6535 /*************************************************************
6536 * freetype_GetTextExtentExPointI
6538 static BOOL
freetype_GetTextExtentExPointI( PHYSDEV dev
, const WORD
*indices
, INT count
,
6539 INT max_ext
, LPINT pnfit
, LPINT dxs
, LPSIZE size
)
6541 static const MAT2 identity
= { {0,1},{0,0},{0,0},{0,1} };
6546 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6550 dev
= GET_NEXT_PHYSDEV( dev
, pGetTextExtentExPointI
);
6551 return dev
->funcs
->pGetTextExtentExPointI( dev
, indices
, count
, max_ext
, pnfit
, dxs
, size
);
6554 TRACE("%p, %p, %d, %d, %p\n", physdev
->font
, indices
, count
, max_ext
, size
);
6557 EnterCriticalSection( &freetype_cs
);
6560 get_text_metrics(physdev
->font
, &tm
);
6561 size
->cy
= tm
.tmHeight
;
6563 for(idx
= 0; idx
< count
; idx
++) {
6564 get_glyph_outline(physdev
->font
, indices
[idx
], GGO_METRICS
| GGO_GLYPH_INDEX
, &gm
, 0, NULL
, &identity
);
6565 size
->cx
+= FONT_GM(physdev
->font
,indices
[idx
])->adv
;
6567 if (! pnfit
|| ext
<= max_ext
) {
6577 LeaveCriticalSection( &freetype_cs
);
6578 TRACE("return %d, %d, %d\n", size
->cx
, size
->cy
, nfit
);
6582 /*************************************************************
6583 * freetype_GetFontData
6585 static DWORD
freetype_GetFontData( PHYSDEV dev
, DWORD table
, DWORD offset
, LPVOID buf
, DWORD cbData
)
6587 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6591 dev
= GET_NEXT_PHYSDEV( dev
, pGetFontData
);
6592 return dev
->funcs
->pGetFontData( dev
, table
, offset
, buf
, cbData
);
6595 TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
6596 physdev
->font
, LOBYTE(LOWORD(table
)), HIBYTE(LOWORD(table
)),
6597 LOBYTE(HIWORD(table
)), HIBYTE(HIWORD(table
)), offset
, buf
, cbData
);
6599 return get_font_data( physdev
->font
, table
, offset
, buf
, cbData
);
6602 /*************************************************************
6603 * freetype_GetTextFace
6605 static INT
freetype_GetTextFace( PHYSDEV dev
, INT count
, LPWSTR str
)
6608 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6612 dev
= GET_NEXT_PHYSDEV( dev
, pGetTextFace
);
6613 return dev
->funcs
->pGetTextFace( dev
, count
, str
);
6616 n
= strlenW(physdev
->font
->name
) + 1;
6619 lstrcpynW(str
, physdev
->font
->name
, count
);
6625 /*************************************************************
6626 * freetype_GetTextCharsetInfo
6628 static UINT
freetype_GetTextCharsetInfo( PHYSDEV dev
, LPFONTSIGNATURE fs
, DWORD flags
)
6630 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6634 dev
= GET_NEXT_PHYSDEV( dev
, pGetTextCharsetInfo
);
6635 return dev
->funcs
->pGetTextCharsetInfo( dev
, fs
, flags
);
6637 if (fs
) *fs
= physdev
->font
->fs
;
6638 return physdev
->font
->charset
;
6641 BOOL
WineEngGetLinkedHFont(DC
*dc
, WCHAR c
, HFONT
*new_hfont
, UINT
*glyph
)
6643 GdiFont
*font
= dc
->gdiFont
, *linked_font
;
6644 struct list
*first_hfont
;
6648 EnterCriticalSection( &freetype_cs
);
6649 ret
= get_glyph_index_linked(font
, c
, &linked_font
, glyph
);
6650 TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph
, linked_font
);
6651 if(font
== linked_font
)
6652 *new_hfont
= dc
->hFont
;
6655 first_hfont
= list_head(&linked_font
->hfontlist
);
6656 *new_hfont
= LIST_ENTRY(first_hfont
, struct tagHFONTLIST
, entry
)->hfont
;
6658 LeaveCriticalSection( &freetype_cs
);
6662 /* Retrieve a list of supported Unicode ranges for a given font.
6663 * Can be called with NULL gs to calculate the buffer size. Returns
6664 * the number of ranges found.
6666 static DWORD
get_font_unicode_ranges(FT_Face face
, GLYPHSET
*gs
)
6668 DWORD num_ranges
= 0;
6670 if (face
->charmap
->encoding
== FT_ENCODING_UNICODE
)
6673 FT_ULong char_code
, char_code_prev
;
6676 char_code_prev
= char_code
= pFT_Get_First_Char(face
, &glyph_code
);
6678 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
6679 face
->num_glyphs
, glyph_code
, char_code
);
6681 if (!glyph_code
) return 0;
6685 gs
->ranges
[0].wcLow
= (USHORT
)char_code
;
6686 gs
->ranges
[0].cGlyphs
= 0;
6687 gs
->cGlyphsSupported
= 0;
6693 if (char_code
< char_code_prev
)
6695 ERR("expected increasing char code from FT_Get_Next_Char\n");
6698 if (char_code
- char_code_prev
> 1)
6703 gs
->ranges
[num_ranges
- 1].wcLow
= (USHORT
)char_code
;
6704 gs
->ranges
[num_ranges
- 1].cGlyphs
= 1;
6705 gs
->cGlyphsSupported
++;
6710 gs
->ranges
[num_ranges
- 1].cGlyphs
++;
6711 gs
->cGlyphsSupported
++;
6713 char_code_prev
= char_code
;
6714 char_code
= pFT_Get_Next_Char(face
, char_code
, &glyph_code
);
6718 FIXME("encoding %u not supported\n", face
->charmap
->encoding
);
6723 /*************************************************************
6724 * freetype_GetFontUnicodeRanges
6726 static DWORD
freetype_GetFontUnicodeRanges( PHYSDEV dev
, LPGLYPHSET glyphset
)
6728 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6729 DWORD size
, num_ranges
;
6733 dev
= GET_NEXT_PHYSDEV( dev
, pGetFontUnicodeRanges
);
6734 return dev
->funcs
->pGetFontUnicodeRanges( dev
, glyphset
);
6737 num_ranges
= get_font_unicode_ranges(physdev
->font
->ft_face
, glyphset
);
6738 size
= sizeof(GLYPHSET
) + sizeof(WCRANGE
) * (num_ranges
- 1);
6741 glyphset
->cbThis
= size
;
6742 glyphset
->cRanges
= num_ranges
;
6743 glyphset
->flAccel
= 0;
6748 /*************************************************************
6749 * freetype_FontIsLinked
6751 static BOOL
freetype_FontIsLinked( PHYSDEV dev
)
6753 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6758 dev
= GET_NEXT_PHYSDEV( dev
, pFontIsLinked
);
6759 return dev
->funcs
->pFontIsLinked( dev
);
6763 EnterCriticalSection( &freetype_cs
);
6764 ret
= !list_empty(&physdev
->font
->child_fonts
);
6765 LeaveCriticalSection( &freetype_cs
);
6769 static BOOL
is_hinting_enabled(void)
6771 /* Use the >= 2.2.0 function if available */
6772 if(pFT_Get_TrueType_Engine_Type
)
6774 FT_TrueTypeEngineType type
= pFT_Get_TrueType_Engine_Type(library
);
6775 return type
== FT_TRUETYPE_ENGINE_TYPE_PATENTED
;
6777 #ifdef FT_DRIVER_HAS_HINTER
6782 /* otherwise if we've been compiled with < 2.2.0 headers
6783 use the internal macro */
6784 mod
= pFT_Get_Module(library
, "truetype");
6785 if(mod
&& FT_DRIVER_HAS_HINTER(mod
))
6793 static BOOL
is_subpixel_rendering_enabled( void )
6795 #ifdef HAVE_FREETYPE_FTLCDFIL_H
6796 return pFT_Library_SetLcdFilter
&&
6797 pFT_Library_SetLcdFilter( NULL
, 0 ) != FT_Err_Unimplemented_Feature
;
6803 /*************************************************************************
6804 * GetRasterizerCaps (GDI32.@)
6806 BOOL WINAPI
GetRasterizerCaps( LPRASTERIZER_STATUS lprs
, UINT cbNumBytes
)
6808 static int hinting
= -1;
6809 static int subpixel
= -1;
6813 hinting
= is_hinting_enabled();
6814 TRACE("hinting is %senabled\n", hinting
? "" : "NOT ");
6817 if ( subpixel
== -1 )
6819 subpixel
= is_subpixel_rendering_enabled();
6820 TRACE("subpixel rendering is %senabled\n", subpixel
? "" : "NOT ");
6823 lprs
->nSize
= sizeof(RASTERIZER_STATUS
);
6824 lprs
->wFlags
= TT_AVAILABLE
| TT_ENABLED
| (hinting
? WINE_TT_HINTER_ENABLED
: 0);
6826 lprs
->wFlags
|= WINE_TT_SUBPIXEL_RENDERING_ENABLED
;
6827 lprs
->nLanguageID
= 0;
6831 /*************************************************************
6832 * freetype_GdiRealizationInfo
6834 static BOOL
freetype_GdiRealizationInfo( PHYSDEV dev
, void *ptr
)
6836 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6837 realization_info_t
*info
= ptr
;
6841 dev
= GET_NEXT_PHYSDEV( dev
, pGdiRealizationInfo
);
6842 return dev
->funcs
->pGdiRealizationInfo( dev
, ptr
);
6845 FIXME("(%p, %p): stub!\n", physdev
->font
, info
);
6848 if(FT_IS_SCALABLE(physdev
->font
->ft_face
))
6851 info
->cache_num
= physdev
->font
->cache_num
;
6852 info
->unknown2
= -1;
6856 /*************************************************************************
6857 * Kerning support for TrueType fonts
6859 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
6861 struct TT_kern_table
6867 struct TT_kern_subtable
6876 USHORT horizontal
: 1;
6878 USHORT cross_stream
: 1;
6879 USHORT override
: 1;
6880 USHORT reserved1
: 4;
6886 struct TT_format0_kern_subtable
6890 USHORT entrySelector
;
6901 static DWORD
parse_format0_kern_subtable(GdiFont
*font
,
6902 const struct TT_format0_kern_subtable
*tt_f0_ks
,
6903 const USHORT
*glyph_to_char
,
6904 KERNINGPAIR
*kern_pair
, DWORD cPairs
)
6907 const struct TT_kern_pair
*tt_kern_pair
;
6909 TRACE("font height %d, units_per_EM %d\n", font
->ppem
, font
->ft_face
->units_per_EM
);
6911 nPairs
= GET_BE_WORD(tt_f0_ks
->nPairs
);
6913 TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
6914 nPairs
, GET_BE_WORD(tt_f0_ks
->searchRange
),
6915 GET_BE_WORD(tt_f0_ks
->entrySelector
), GET_BE_WORD(tt_f0_ks
->rangeShift
));
6917 if (!kern_pair
|| !cPairs
)
6920 tt_kern_pair
= (const struct TT_kern_pair
*)(tt_f0_ks
+ 1);
6922 nPairs
= min(nPairs
, cPairs
);
6924 for (i
= 0; i
< nPairs
; i
++)
6926 kern_pair
->wFirst
= glyph_to_char
[GET_BE_WORD(tt_kern_pair
[i
].left
)];
6927 kern_pair
->wSecond
= glyph_to_char
[GET_BE_WORD(tt_kern_pair
[i
].right
)];
6928 /* this algorithm appears to better match what Windows does */
6929 kern_pair
->iKernAmount
= (short)GET_BE_WORD(tt_kern_pair
[i
].value
) * font
->ppem
;
6930 if (kern_pair
->iKernAmount
< 0)
6932 kern_pair
->iKernAmount
-= font
->ft_face
->units_per_EM
/ 2;
6933 kern_pair
->iKernAmount
-= font
->ppem
;
6935 else if (kern_pair
->iKernAmount
> 0)
6937 kern_pair
->iKernAmount
+= font
->ft_face
->units_per_EM
/ 2;
6938 kern_pair
->iKernAmount
+= font
->ppem
;
6940 kern_pair
->iKernAmount
/= font
->ft_face
->units_per_EM
;
6942 TRACE("left %u right %u value %d\n",
6943 kern_pair
->wFirst
, kern_pair
->wSecond
, kern_pair
->iKernAmount
);
6947 TRACE("copied %u entries\n", nPairs
);
6951 /*************************************************************
6952 * freetype_GetKerningPairs
6954 static DWORD
freetype_GetKerningPairs( PHYSDEV dev
, DWORD cPairs
, KERNINGPAIR
*kern_pair
)
6958 const struct TT_kern_table
*tt_kern_table
;
6959 const struct TT_kern_subtable
*tt_kern_subtable
;
6961 USHORT
*glyph_to_char
;
6963 struct freetype_physdev
*physdev
= get_freetype_dev( dev
);
6965 if (!(font
= physdev
->font
))
6967 dev
= GET_NEXT_PHYSDEV( dev
, pGetKerningPairs
);
6968 return dev
->funcs
->pGetKerningPairs( dev
, cPairs
, kern_pair
);
6972 EnterCriticalSection( &freetype_cs
);
6973 if (font
->total_kern_pairs
!= (DWORD
)-1)
6975 if (cPairs
&& kern_pair
)
6977 cPairs
= min(cPairs
, font
->total_kern_pairs
);
6978 memcpy(kern_pair
, font
->kern_pairs
, cPairs
* sizeof(*kern_pair
));
6980 else cPairs
= font
->total_kern_pairs
;
6982 LeaveCriticalSection( &freetype_cs
);
6986 font
->total_kern_pairs
= 0;
6988 length
= get_font_data(font
, MS_KERN_TAG
, 0, NULL
, 0);
6990 if (length
== GDI_ERROR
)
6992 TRACE("no kerning data in the font\n");
6993 LeaveCriticalSection( &freetype_cs
);
6997 buf
= HeapAlloc(GetProcessHeap(), 0, length
);
7000 WARN("Out of memory\n");
7001 LeaveCriticalSection( &freetype_cs
);
7005 get_font_data(font
, MS_KERN_TAG
, 0, buf
, length
);
7007 /* build a glyph index to char code map */
7008 glyph_to_char
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(USHORT
) * 65536);
7011 WARN("Out of memory allocating a glyph index to char code map\n");
7012 HeapFree(GetProcessHeap(), 0, buf
);
7013 LeaveCriticalSection( &freetype_cs
);
7017 if (font
->ft_face
->charmap
->encoding
== FT_ENCODING_UNICODE
)
7023 char_code
= pFT_Get_First_Char(font
->ft_face
, &glyph_code
);
7025 TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
7026 font
->ft_face
->num_glyphs
, glyph_code
, char_code
);
7030 /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? " !" : "" );*/
7032 /* FIXME: This doesn't match what Windows does: it does some fancy
7033 * things with duplicate glyph index to char code mappings, while
7034 * we just avoid overriding existing entries.
7036 if (glyph_code
<= 65535 && !glyph_to_char
[glyph_code
])
7037 glyph_to_char
[glyph_code
] = (USHORT
)char_code
;
7039 char_code
= pFT_Get_Next_Char(font
->ft_face
, char_code
, &glyph_code
);
7046 FIXME("encoding %u not supported\n", font
->ft_face
->charmap
->encoding
);
7047 for (n
= 0; n
<= 65535; n
++)
7048 glyph_to_char
[n
] = (USHORT
)n
;
7051 tt_kern_table
= buf
;
7052 nTables
= GET_BE_WORD(tt_kern_table
->nTables
);
7053 TRACE("version %u, nTables %u\n",
7054 GET_BE_WORD(tt_kern_table
->version
), nTables
);
7056 tt_kern_subtable
= (const struct TT_kern_subtable
*)(tt_kern_table
+ 1);
7058 for (i
= 0; i
< nTables
; i
++)
7060 struct TT_kern_subtable tt_kern_subtable_copy
;
7062 tt_kern_subtable_copy
.version
= GET_BE_WORD(tt_kern_subtable
->version
);
7063 tt_kern_subtable_copy
.length
= GET_BE_WORD(tt_kern_subtable
->length
);
7064 tt_kern_subtable_copy
.coverage
.word
= GET_BE_WORD(tt_kern_subtable
->coverage
.word
);
7066 TRACE("version %u, length %u, coverage %u, subtable format %u\n",
7067 tt_kern_subtable_copy
.version
, tt_kern_subtable_copy
.length
,
7068 tt_kern_subtable_copy
.coverage
.word
, tt_kern_subtable_copy
.coverage
.bits
.format
);
7070 /* According to the TrueType specification this is the only format
7071 * that will be properly interpreted by Windows and OS/2
7073 if (tt_kern_subtable_copy
.coverage
.bits
.format
== 0)
7075 DWORD new_chunk
, old_total
= font
->total_kern_pairs
;
7077 new_chunk
= parse_format0_kern_subtable(font
, (const struct TT_format0_kern_subtable
*)(tt_kern_subtable
+ 1),
7078 glyph_to_char
, NULL
, 0);
7079 font
->total_kern_pairs
+= new_chunk
;
7081 if (!font
->kern_pairs
)
7082 font
->kern_pairs
= HeapAlloc(GetProcessHeap(), 0,
7083 font
->total_kern_pairs
* sizeof(*font
->kern_pairs
));
7085 font
->kern_pairs
= HeapReAlloc(GetProcessHeap(), 0, font
->kern_pairs
,
7086 font
->total_kern_pairs
* sizeof(*font
->kern_pairs
));
7088 parse_format0_kern_subtable(font
, (const struct TT_format0_kern_subtable
*)(tt_kern_subtable
+ 1),
7089 glyph_to_char
, font
->kern_pairs
+ old_total
, new_chunk
);
7092 TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy
.coverage
.bits
.format
);
7094 tt_kern_subtable
= (const struct TT_kern_subtable
*)((const char *)tt_kern_subtable
+ tt_kern_subtable_copy
.length
);
7097 HeapFree(GetProcessHeap(), 0, glyph_to_char
);
7098 HeapFree(GetProcessHeap(), 0, buf
);
7100 if (cPairs
&& kern_pair
)
7102 cPairs
= min(cPairs
, font
->total_kern_pairs
);
7103 memcpy(kern_pair
, font
->kern_pairs
, cPairs
* sizeof(*kern_pair
));
7105 else cPairs
= font
->total_kern_pairs
;
7107 LeaveCriticalSection( &freetype_cs
);
7111 static const struct gdi_dc_funcs freetype_funcs
=
7113 NULL
, /* pAbortDoc */
7114 NULL
, /* pAbortPath */
7115 NULL
, /* pAlphaBlend */
7116 NULL
, /* pAngleArc */
7119 NULL
, /* pBeginPath */
7120 NULL
, /* pBlendImage */
7121 NULL
, /* pChoosePixelFormat */
7123 NULL
, /* pCloseFigure */
7124 NULL
, /* pCopyBitmap */
7125 NULL
, /* pCreateBitmap */
7126 NULL
, /* pCreateCompatibleDC */
7127 freetype_CreateDC
, /* pCreateDC */
7128 NULL
, /* pCreateDIBSection */
7129 NULL
, /* pDeleteBitmap */
7130 freetype_DeleteDC
, /* pDeleteDC */
7131 NULL
, /* pDeleteObject */
7132 NULL
, /* pDescribePixelFormat */
7133 NULL
, /* pDeviceCapabilities */
7134 NULL
, /* pEllipse */
7136 NULL
, /* pEndPage */
7137 NULL
, /* pEndPath */
7138 freetype_EnumFonts
, /* pEnumFonts */
7139 NULL
, /* pEnumICMProfiles */
7140 NULL
, /* pExcludeClipRect */
7141 NULL
, /* pExtDeviceMode */
7142 NULL
, /* pExtEscape */
7143 NULL
, /* pExtFloodFill */
7144 NULL
, /* pExtSelectClipRgn */
7145 NULL
, /* pExtTextOut */
7146 NULL
, /* pFillPath */
7147 NULL
, /* pFillRgn */
7148 NULL
, /* pFlattenPath */
7149 freetype_FontIsLinked
, /* pFontIsLinked */
7150 NULL
, /* pFrameRgn */
7151 NULL
, /* pGdiComment */
7152 freetype_GdiRealizationInfo
, /* pGdiRealizationInfo */
7153 freetype_GetCharABCWidths
, /* pGetCharABCWidths */
7154 freetype_GetCharABCWidthsI
, /* pGetCharABCWidthsI */
7155 freetype_GetCharWidth
, /* pGetCharWidth */
7156 NULL
, /* pGetDeviceCaps */
7157 NULL
, /* pGetDeviceGammaRamp */
7158 freetype_GetFontData
, /* pGetFontData */
7159 freetype_GetFontUnicodeRanges
, /* pGetFontUnicodeRanges */
7160 freetype_GetGlyphIndices
, /* pGetGlyphIndices */
7161 freetype_GetGlyphOutline
, /* pGetGlyphOutline */
7162 NULL
, /* pGetICMProfile */
7163 NULL
, /* pGetImage */
7164 freetype_GetKerningPairs
, /* pGetKerningPairs */
7165 NULL
, /* pGetNearestColor */
7166 freetype_GetOutlineTextMetrics
, /* pGetOutlineTextMetrics */
7167 NULL
, /* pGetPixel */
7168 NULL
, /* pGetPixelFormat */
7169 NULL
, /* pGetSystemPaletteEntries */
7170 freetype_GetTextCharsetInfo
, /* pGetTextCharsetInfo */
7171 freetype_GetTextExtentExPoint
, /* pGetTextExtentExPoint */
7172 freetype_GetTextExtentExPointI
, /* pGetTextExtentExPointI */
7173 freetype_GetTextFace
, /* pGetTextFace */
7174 freetype_GetTextMetrics
, /* pGetTextMetrics */
7175 NULL
, /* pGradientFill */
7176 NULL
, /* pIntersectClipRect */
7177 NULL
, /* pInvertRgn */
7179 NULL
, /* pModifyWorldTransform */
7181 NULL
, /* pOffsetClipRgn */
7182 NULL
, /* pOffsetViewportOrg */
7183 NULL
, /* pOffsetWindowOrg */
7184 NULL
, /* pPaintRgn */
7187 NULL
, /* pPolyBezier */
7188 NULL
, /* pPolyBezierTo */
7189 NULL
, /* pPolyDraw */
7190 NULL
, /* pPolyPolygon */
7191 NULL
, /* pPolyPolyline */
7192 NULL
, /* pPolygon */
7193 NULL
, /* pPolyline */
7194 NULL
, /* pPolylineTo */
7195 NULL
, /* pPutImage */
7196 NULL
, /* pRealizeDefaultPalette */
7197 NULL
, /* pRealizePalette */
7198 NULL
, /* pRectangle */
7199 NULL
, /* pResetDC */
7200 NULL
, /* pRestoreDC */
7201 NULL
, /* pRoundRect */
7203 NULL
, /* pScaleViewportExt */
7204 NULL
, /* pScaleWindowExt */
7205 NULL
, /* pSelectBitmap */
7206 NULL
, /* pSelectBrush */
7207 NULL
, /* pSelectClipPath */
7208 freetype_SelectFont
, /* pSelectFont */
7209 NULL
, /* pSelectPalette */
7210 NULL
, /* pSelectPen */
7211 NULL
, /* pSetArcDirection */
7212 NULL
, /* pSetBkColor */
7213 NULL
, /* pSetBkMode */
7214 NULL
, /* pSetDCBrushColor */
7215 NULL
, /* pSetDCPenColor */
7216 NULL
, /* pSetDIBColorTable */
7217 NULL
, /* pSetDIBitsToDevice */
7218 NULL
, /* pSetDeviceClipping */
7219 NULL
, /* pSetDeviceGammaRamp */
7220 NULL
, /* pSetLayout */
7221 NULL
, /* pSetMapMode */
7222 NULL
, /* pSetMapperFlags */
7223 NULL
, /* pSetPixel */
7224 NULL
, /* pSetPixelFormat */
7225 NULL
, /* pSetPolyFillMode */
7226 NULL
, /* pSetROP2 */
7227 NULL
, /* pSetRelAbs */
7228 NULL
, /* pSetStretchBltMode */
7229 NULL
, /* pSetTextAlign */
7230 NULL
, /* pSetTextCharacterExtra */
7231 NULL
, /* pSetTextColor */
7232 NULL
, /* pSetTextJustification */
7233 NULL
, /* pSetViewportExt */
7234 NULL
, /* pSetViewportOrg */
7235 NULL
, /* pSetWindowExt */
7236 NULL
, /* pSetWindowOrg */
7237 NULL
, /* pSetWorldTransform */
7238 NULL
, /* pStartDoc */
7239 NULL
, /* pStartPage */
7240 NULL
, /* pStretchBlt */
7241 NULL
, /* pStretchDIBits */
7242 NULL
, /* pStrokeAndFillPath */
7243 NULL
, /* pStrokePath */
7244 NULL
, /* pSwapBuffers */
7245 NULL
, /* pUnrealizePalette */
7246 NULL
, /* pWidenPath */
7247 /* OpenGL not supported */
7250 #else /* HAVE_FREETYPE */
7252 /*************************************************************************/
7254 BOOL
WineEngInit(void)
7258 BOOL
WineEngDestroyFontInstance(HFONT hfont
)
7263 INT
WineEngAddFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
7265 FIXME("(%s, %x, %p): stub\n", debugstr_w(file
), flags
, pdv
);
7269 INT
WineEngRemoveFontResourceEx(LPCWSTR file
, DWORD flags
, PVOID pdv
)
7271 FIXME("(%s, %x, %p): stub\n", debugstr_w(file
), flags
, pdv
);
7275 HANDLE
WineEngAddFontMemResourceEx(PVOID pbFont
, DWORD cbFont
, PVOID pdv
, DWORD
*pcFonts
)
7277 FIXME("(%p, %u, %p, %p): stub\n", pbFont
, cbFont
, pdv
, pcFonts
);
7281 BOOL
WineEngGetLinkedHFont(DC
*dc
, WCHAR c
, HFONT
*new_hfont
, UINT
*glyph
)
7286 /*************************************************************************
7287 * GetRasterizerCaps (GDI32.@)
7289 BOOL WINAPI
GetRasterizerCaps( LPRASTERIZER_STATUS lprs
, UINT cbNumBytes
)
7291 lprs
->nSize
= sizeof(RASTERIZER_STATUS
);
7293 lprs
->nLanguageID
= 0;
7297 #endif /* HAVE_FREETYPE */