git.oblomov.eu Git - wine/blob - dlls/gdi32/freetype.c

   1 /*
   2  * FreeType font engine interface
   3  *
   4  * Copyright 2001 Huw D M Davies for CodeWeavers.
   5  * Copyright 2006 Dmitry Timoshkov for CodeWeavers.
   6  *
   7  * This file contains the WineEng* functions.
   8  *
   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.
  13  *
  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.
  18  *
  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
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #ifdef HAVE_SYS_STAT_H
  30 # include <sys/stat.h>
  31 #endif
  32 #ifdef HAVE_SYS_MMAN_H
  33 # include <sys/mman.h>
  34 #endif
  35 #include <string.h>
  36 #ifdef HAVE_DIRENT_H
  37 # include <dirent.h>
  38 #endif
  39 #include <stdio.h>
  40 #include <assert.h>
  41
  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>
  60 #undef LoadResource
  61 #undef CompareString
  62 #undef GetCurrentThread
  63 #undef _CDECL
  64 #undef DPRINTF
  65 #undef GetCurrentProcess
  66 #undef AnimatePalette
  67 #undef EqualRgn
  68 #undef FillRgn
  69 #undef FrameRgn
  70 #undef GetPixel
  71 #undef InvertRgn
  72 #undef LineTo
  73 #undef OffsetRgn
  74 #undef PaintRgn
  75 #undef Polygon
  76 #undef ResizePalette
  77 #undef SetRectRgn
  78 #endif /* HAVE_CARBON_CARBON_H */
  79
  80 #include "windef.h"
  81 #include "winbase.h"
  82 #include "winternl.h"
  83 #include "winerror.h"
  84 #include "winreg.h"
  85 #include "wingdi.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"
  91
  92 #include "resource.h"
  93
  94 WINE_DEFAULT_DEBUG_CHANNEL(font);
  95
  96 #ifdef HAVE_FREETYPE
  97
  98 #ifdef HAVE_FT2BUILD_H
  99 #include <ft2build.h>
 100 #endif
 101 #ifdef HAVE_FREETYPE_FREETYPE_H
 102 #include <freetype/freetype.h>
 103 #endif
 104 #ifdef HAVE_FREETYPE_FTGLYPH_H
 105 #include <freetype/ftglyph.h>
 106 #endif
 107 #ifdef HAVE_FREETYPE_TTTABLES_H
 108 #include <freetype/tttables.h>
 109 #endif
 110 #ifdef HAVE_FREETYPE_FTTYPES_H
 111 #include <freetype/fttypes.h>
 112 #endif
 113 #ifdef HAVE_FREETYPE_FTSNAMES_H
 114 #include <freetype/ftsnames.h>
 115 #endif
 116 #ifdef HAVE_FREETYPE_TTNAMEID_H
 117 #include <freetype/ttnameid.h>
 118 #endif
 119 #ifdef HAVE_FREETYPE_FTOUTLN_H
 120 #include <freetype/ftoutln.h>
 121 #endif
 122 #ifdef HAVE_FREETYPE_FTTRIGON_H
 123 #include <freetype/fttrigon.h>
 124 #endif
 125 #ifdef HAVE_FREETYPE_FTWINFNT_H
 126 #include <freetype/ftwinfnt.h>
 127 #endif
 128 #ifdef HAVE_FREETYPE_FTMODAPI_H
 129 #include <freetype/ftmodapi.h>
 130 #endif
 131 #ifdef HAVE_FREETYPE_FTLCDFIL_H
 132 #include <freetype/ftlcdfil.h>
 133 #endif
 134
 135 #ifndef HAVE_FT_TRUETYPEENGINETYPE
 136 typedef enum
 137 {
 138     FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
 139     FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
 140     FT_TRUETYPE_ENGINE_TYPE_PATENTED
 141 } FT_TrueTypeEngineType;
 142 #endif
 143
 144 static FT_Library library = 0;
 145 typedef struct
 146 {
 147     FT_Int major;
 148     FT_Int minor;
 149     FT_Int patch;
 150 } FT_Version_t;
 151 static FT_Version_t FT_Version;
 152 static DWORD FT_SimpleVersion;
 153
 154 static void *ft_handle = NULL;
 155
 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
 173 #else
 174 MAKE_FUNCPTR(FT_MulFix);
 175 #endif
 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);
 190 #endif
 191
 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);
 205 #endif
 206
 207 #undef MAKE_FUNCPTR
 208
 209 #ifndef FT_MAKE_TAG
 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) )
 213 #endif
 214
 215 #ifndef ft_encoding_none
 216 #define FT_ENCODING_NONE ft_encoding_none
 217 #endif
 218 #ifndef ft_encoding_ms_symbol
 219 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
 220 #endif
 221 #ifndef ft_encoding_unicode
 222 #define FT_ENCODING_UNICODE ft_encoding_unicode
 223 #endif
 224 #ifndef ft_encoding_apple_roman
 225 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
 226 #endif
 227
 228 #ifdef WORDS_BIGENDIAN
 229 #define GET_BE_WORD(x) (x)
 230 #else
 231 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
 232 #endif
 233
 234 /* This is basically a copy of FT_Bitmap_Size with an extra element added */
 235 typedef struct {
 236     FT_Short height;
 237     FT_Short width;
 238     FT_Pos size;
 239     FT_Pos x_ppem;
 240     FT_Pos y_ppem;
 241     FT_Short internal_leading;
 242 } Bitmap_Size;
 243
 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. */
 247 typedef struct {
 248     FT_Short height, width;
 249     FT_Pos size, x_ppem, y_ppem;
 250 } My_FT_Bitmap_Size;
 251
 252 struct enum_data
 253 {
 254     ENUMLOGFONTEXW elf;
 255     NEWTEXTMETRICEXW ntm;
 256     DWORD type;
 257 };
 258
 259 typedef struct tagFace {
 260     struct list entry;
 261     WCHAR *StyleName;
 262     WCHAR *FullName;
 263     char *file;
 264     void *font_data_ptr;
 265     DWORD font_data_size;
 266     FT_Long face_index;
 267     FONTSIGNATURE fs;
 268     DWORD ntmFlags;
 269     FT_Fixed font_version;
 270     BOOL scalable;
 271     BOOL vertical;
 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;
 277 } Face;
 278
 279 typedef struct tagFamily {
 280     struct list entry;
 281     WCHAR *FamilyName;
 282     WCHAR *EnglishName;
 283     struct list faces;
 284     struct list *replacement;
 285 } Family;
 286
 287 typedef struct {
 288     GLYPHMETRICS gm;
 289     INT adv; /* These three hold to widths of the unrotated chars */
 290     INT lsb;
 291     INT bbx;
 292     BOOL init;
 293 } GM;
 294
 295 typedef struct {
 296     FLOAT eM11, eM12;
 297     FLOAT eM21, eM22;
 298 } FMAT2;
 299
 300 typedef struct {
 301     DWORD hash;
 302     LOGFONTW lf;
 303     FMAT2 matrix;
 304     BOOL can_use_bitmap;
 305 } FONT_DESC;
 306
 307 typedef struct tagHFONTLIST {
 308     struct list entry;
 309     HFONT hfont;
 310 } HFONTLIST;
 311
 312 typedef struct {
 313     struct list entry;
 314     Face *face;
 315     GdiFont *font;
 316 } CHILD_FONT;
 317
 318 struct tagGdiFont {
 319     struct list entry;
 320     GM **gm;
 321     DWORD gmsize;
 322     struct list hfontlist;
 323     OUTLINETEXTMETRICW *potm;
 324     DWORD total_kern_pairs;
 325     KERNINGPAIR *kern_pairs;
 326     struct list child_fonts;
 327
 328     /* the following members can be accessed without locking, they are never modified after creation */
 329     FT_Face ft_face;
 330     struct font_mapping *mapping;
 331     LPWSTR name;
 332     int charset;
 333     int codepage;
 334     BOOL fake_italic;
 335     BOOL fake_bold;
 336     BYTE underline;
 337     BYTE strikeout;
 338     INT orientation;
 339     FONT_DESC font_desc;
 340     LONG aveWidth, ppem;
 341     double scale_y;
 342     SHORT yMax;
 343     SHORT yMin;
 344     DWORD ntmFlags;
 345     FONTSIGNATURE fs;
 346     GdiFont *base_font;
 347     VOID *GSUB_Table;
 348     DWORD cache_num;
 349 };
 350
 351 typedef struct {
 352     struct list entry;
 353     const WCHAR *font_name;
 354     FONTSIGNATURE fs;
 355     struct list links;
 356 } SYSTEM_LINKS;
 357
 358 struct enum_charset_element {
 359     DWORD mask;
 360     DWORD charset;
 361     WCHAR name[LF_FACESIZE];
 362 };
 363
 364 struct enum_charset_list {
 365     DWORD total;
 366     struct enum_charset_element element[32];
 367 };
 368
 369 #define GM_BLOCK_SIZE 128
 370 #define FONT_GM(font,idx) (&(font)->gm[(idx) / GM_BLOCK_SIZE][(idx) % GM_BLOCK_SIZE])
 371
 372 static struct list gdi_font_list = LIST_INIT(gdi_font_list);
 373 static struct list unused_gdi_font_list = LIST_INIT(unused_gdi_font_list);
 374 #define UNUSED_CACHE_SIZE 10
 375 static struct list child_font_list = LIST_INIT(child_font_list);
 376 static struct list system_links = LIST_INIT(system_links);
 377
 378 static struct list font_subst_list = LIST_INIT(font_subst_list);
 379
 380 static struct list font_list = LIST_INIT(font_list);
 381
 382 struct freetype_physdev
 383 {
 384     struct gdi_physdev dev;
 385     GdiFont           *font;
 386 };
 387
 388 static inline struct freetype_physdev *get_freetype_dev( PHYSDEV dev )
 389 {
 390     return (struct freetype_physdev *)dev;
 391 }
 392
 393 static const struct gdi_dc_funcs freetype_funcs;
 394
 395 static const WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
 396 static const WCHAR defSans[] = {'A','r','i','a','l','\0'};
 397 static const WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
 398
 399 static const WCHAR fontsW[] = {'\\','f','o','n','t','s','\0'};
 400 static const WCHAR win9x_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 401                                            'W','i','n','d','o','w','s','\\',
 402                                            'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 403                                            'F','o','n','t','s','\0'};
 404
 405 static const WCHAR winnt_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 406                                            'W','i','n','d','o','w','s',' ','N','T','\\',
 407                                            'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 408                                            'F','o','n','t','s','\0'};
 409
 410 static const WCHAR system_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
 411 static const WCHAR FixedSys_Value[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
 412 static const WCHAR System_Value[] = {'F','O','N','T','S','.','F','O','N','\0'};
 413 static const WCHAR OEMFont_Value[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
 414
 415 static const WCHAR * const SystemFontValues[] = {
 416     System_Value,
 417     OEMFont_Value,
 418     FixedSys_Value,
 419     NULL
 420 };
 421
 422 static const WCHAR external_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
 423                                                'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
 424
 425 /* Interesting and well-known (frequently-assumed!) font names */
 426 static const WCHAR Lucida_Sans_Unicode[] = {'L','u','c','i','d','a',' ','S','a','n','s',' ','U','n','i','c','o','d','e',0};
 427 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 };
 428 static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
 429 static const WCHAR MS_UI_Gothic[] = {'M','S',' ','U','I',' ','G','o','t','h','i','c',0};
 430 static const WCHAR SimSun[] = {'S','i','m','S','u','n',0};
 431 static const WCHAR Gulim[] = {'G','u','l','i','m',0};
 432 static const WCHAR PMingLiU[] = {'P','M','i','n','g','L','i','U',0};
 433 static const WCHAR Batang[] = {'B','a','t','a','n','g',0};
 434
 435 static const WCHAR arial[] = {'A','r','i','a','l',0};
 436 static const WCHAR bitstream_vera_sans[] = {'B','i','t','s','t','r','e','a','m',' ','V','e','r','a',' ','S','a','n','s',0};
 437 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};
 438 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};
 439 static const WCHAR courier_new[] = {'C','o','u','r','i','e','r',' ','N','e','w',0};
 440 static const WCHAR liberation_mono[] = {'L','i','b','e','r','a','t','i','o','n',' ','M','o','n','o',0};
 441 static const WCHAR liberation_sans[] = {'L','i','b','e','r','a','t','i','o','n',' ','S','a','n','s',0};
 442 static const WCHAR liberation_serif[] = {'L','i','b','e','r','a','t','i','o','n',' ','S','e','r','i','f',0};
 443 static const WCHAR times_new_roman[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n',0};
 444 static const WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
 445
 446 static const WCHAR *default_serif_list[] =
 447 {
 448     times_new_roman,
 449     liberation_serif,
 450     bitstream_vera_serif,
 451     NULL
 452 };
 453
 454 static const WCHAR *default_fixed_list[] =
 455 {
 456     courier_new,
 457     liberation_mono,
 458     bitstream_vera_sans_mono,
 459     NULL
 460 };
 461
 462 static const WCHAR *default_sans_list[] =
 463 {
 464     arial,
 465     liberation_sans,
 466     bitstream_vera_sans,
 467     NULL
 468 };
 469
 470 typedef struct {
 471     WCHAR *name;
 472     INT charset;
 473 } NameCs;
 474
 475 typedef struct tagFontSubst {
 476     struct list entry;
 477     NameCs from;
 478     NameCs to;
 479 } FontSubst;
 480
 481 /* Registry font cache key and value names */
 482 static const WCHAR wine_fonts_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
 483                                        'F','o','n','t','s',0};
 484 static const WCHAR wine_fonts_cache_key[] = {'C','a','c','h','e',0};
 485 static const WCHAR english_name_value[] = {'E','n','g','l','i','s','h',' ','N','a','m','e',0};
 486 static const WCHAR face_index_value[] = {'I','n','d','e','x',0};
 487 static const WCHAR face_ntmflags_value[] = {'N','t','m','f','l','a','g','s',0};
 488 static const WCHAR face_version_value[] = {'V','e','r','s','i','o','n',0};
 489 static const WCHAR face_vertical_value[] = {'V','e','r','t','i','c','a','l',0};
 490 static const WCHAR face_height_value[] = {'H','e','i','g','h','t',0};
 491 static const WCHAR face_width_value[] = {'W','i','d','t','h',0};
 492 static const WCHAR face_size_value[] = {'S','i','z','e',0};
 493 static const WCHAR face_x_ppem_value[] = {'X','p','p','e','m',0};
 494 static const WCHAR face_y_ppem_value[] = {'Y','p','p','e','m',0};
 495 static const WCHAR face_internal_leading_value[] = {'I','n','t','e','r','n','a','l',' ','L','e','a','d','i','n','g',0};
 496 static const WCHAR face_font_sig_value[] = {'F','o','n','t',' ','S','i','g','n','a','t','u','r','e',0};
 497 static const WCHAR face_full_name_value[] = {'F','u','l','l',' ','N','a','m','e','\0'};
 498
 499
 500 struct font_mapping
 501 {
 502     struct list entry;
 503     int         refcount;
 504     dev_t       dev;
 505     ino_t       ino;
 506     void       *data;
 507     size_t      size;
 508 };
 509
 510 static struct list mappings_list = LIST_INIT( mappings_list );
 511
 512 static CRITICAL_SECTION freetype_cs;
 513 static CRITICAL_SECTION_DEBUG critsect_debug =
 514 {
 515     0, 0, &freetype_cs,
 516     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 517       0, 0, { (DWORD_PTR)(__FILE__ ": freetype_cs") }
 518 };
 519 static CRITICAL_SECTION freetype_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 520
 521 static const WCHAR font_mutex_nameW[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
 522
 523 static const WCHAR szDefaultFallbackLink[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0};
 524 static BOOL use_default_fallback = FALSE;
 525
 526 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph);
 527 static BOOL get_outline_text_metrics(GdiFont *font);
 528 static BOOL get_text_metrics(GdiFont *font, LPTEXTMETRICW ptm);
 529
 530 static const WCHAR system_link[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 531                                     'W','i','n','d','o','w','s',' ','N','T','\\',
 532                                     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
 533                                     'S','y','s','t','e','m','L','i','n','k',0};
 534
 535 static const WCHAR internal_system_link[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
 536                                     'F','o','n','t','L','i','n','k','\\',
 537                                     'S','y','s','t','e','m','L','i','n','k',0};
 538
 539 /****************************************
 540  *   Notes on .fon files
 541  *
 542  * The fonts System, FixedSys and Terminal are special.  There are typically multiple
 543  * versions installed for different resolutions and codepages.  Windows stores which one to use
 544  * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
 545  *    Key            Meaning
 546  *  FIXEDFON.FON    FixedSys
 547  *  FONTS.FON       System
 548  *  OEMFONT.FON     Terminal
 549  *  LogPixels       Current dpi set by the display control panel applet
 550  *                  (HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontDPI
 551  *                  also has a LogPixels value that appears to mirror this)
 552  *
 553  * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
 554  * (vgaoem.fon would be your oemfont.fon if you have a US setup).
 555  * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
 556  * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
 557  * so that makes sense.
 558  *
 559  * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
 560  * to be mapped into the registry on Windows 2000 at least).
 561  * I have
 562  * woafont=app850.fon
 563  * ega80woa.fon=ega80850.fon
 564  * ega40woa.fon=ega40850.fon
 565  * cga80woa.fon=cga80850.fon
 566  * cga40woa.fon=cga40850.fon
 567  */
 568
 569 /* These are all structures needed for the GSUB table */
 570
 571 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
 572 #define TATEGAKI_LOWER_BOUND  0x02F1
 573
 574 typedef struct {
 575     DWORD version;
 576     WORD ScriptList;
 577     WORD FeatureList;
 578     WORD LookupList;
 579 } GSUB_Header;
 580
 581 typedef struct {
 582     CHAR ScriptTag[4];
 583     WORD Script;
 584 } GSUB_ScriptRecord;
 585
 586 typedef struct {
 587     WORD ScriptCount;
 588     GSUB_ScriptRecord ScriptRecord[1];
 589 } GSUB_ScriptList;
 590
 591 typedef struct {
 592     CHAR LangSysTag[4];
 593     WORD LangSys;
 594 } GSUB_LangSysRecord;
 595
 596 typedef struct {
 597     WORD DefaultLangSys;
 598     WORD LangSysCount;
 599     GSUB_LangSysRecord LangSysRecord[1];
 600 } GSUB_Script;
 601
 602 typedef struct {
 603     WORD LookupOrder; /* Reserved */
 604     WORD ReqFeatureIndex;
 605     WORD FeatureCount;
 606     WORD FeatureIndex[1];
 607 } GSUB_LangSys;
 608
 609 typedef struct {
 610     CHAR FeatureTag[4];
 611     WORD Feature;
 612 } GSUB_FeatureRecord;
 613
 614 typedef struct {
 615     WORD FeatureCount;
 616     GSUB_FeatureRecord FeatureRecord[1];
 617 } GSUB_FeatureList;
 618
 619 typedef struct {
 620     WORD FeatureParams; /* Reserved */
 621     WORD LookupCount;
 622     WORD LookupListIndex[1];
 623 } GSUB_Feature;
 624
 625 typedef struct {
 626     WORD LookupCount;
 627     WORD Lookup[1];
 628 } GSUB_LookupList;
 629
 630 typedef struct {
 631     WORD LookupType;
 632     WORD LookupFlag;
 633     WORD SubTableCount;
 634     WORD SubTable[1];
 635 } GSUB_LookupTable;
 636
 637 typedef struct {
 638     WORD CoverageFormat;
 639     WORD GlyphCount;
 640     WORD GlyphArray[1];
 641 } GSUB_CoverageFormat1;
 642
 643 typedef struct {
 644     WORD Start;
 645     WORD End;
 646     WORD StartCoverageIndex;
 647 } GSUB_RangeRecord;
 648
 649 typedef struct {
 650     WORD CoverageFormat;
 651     WORD RangeCount;
 652     GSUB_RangeRecord RangeRecord[1];
 653 } GSUB_CoverageFormat2;
 654
 655 typedef struct {
 656     WORD SubstFormat; /* = 1 */
 657     WORD Coverage;
 658     WORD DeltaGlyphID;
 659 } GSUB_SingleSubstFormat1;
 660
 661 typedef struct {
 662     WORD SubstFormat; /* = 2 */
 663     WORD Coverage;
 664     WORD GlyphCount;
 665     WORD Substitute[1];
 666 }GSUB_SingleSubstFormat2;
 667
 668 #ifdef HAVE_CARBON_CARBON_H
 669 static char *find_cache_dir(void)
 670 {
 671     FSRef ref;
 672     OSErr err;
 673     static char cached_path[MAX_PATH];
 674     static const char *wine = "/Wine", *fonts = "/Fonts";
 675
 676     if(*cached_path) return cached_path;
 677
 678     err = FSFindFolder(kUserDomain, kCachedDataFolderType, kCreateFolder, &ref);
 679     if(err != noErr)
 680     {
 681         WARN("can't create cached data folder\n");
 682         return NULL;
 683     }
 684     err = FSRefMakePath(&ref, (unsigned char*)cached_path, sizeof(cached_path));
 685     if(err != noErr)
 686     {
 687         WARN("can't create cached data path\n");
 688         *cached_path = '\0';
 689         return NULL;
 690     }
 691     if(strlen(cached_path) + strlen(wine) + strlen(fonts) + 1 > sizeof(cached_path))
 692     {
 693         ERR("Could not create full path\n");
 694         *cached_path = '\0';
 695         return NULL;
 696     }
 697     strcat(cached_path, wine);
 698
 699     if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
 700     {
 701         WARN("Couldn't mkdir %s\n", cached_path);
 702         *cached_path = '\0';
 703         return NULL;
 704     }
 705     strcat(cached_path, fonts);
 706     if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
 707     {
 708         WARN("Couldn't mkdir %s\n", cached_path);
 709         *cached_path = '\0';
 710         return NULL;
 711     }
 712     return cached_path;
 713 }
 714
 715 /******************************************************************
 716  *            expand_mac_font
 717  *
 718  * Extracts individual TrueType font files from a Mac suitcase font
 719  * and saves them into the user's caches directory (see
 720  * find_cache_dir()).
 721  * Returns a NULL terminated array of filenames.
 722  *
 723  * We do this because they are apps that try to read ttf files
 724  * themselves and they don't like Mac suitcase files.
 725  */
 726 static char **expand_mac_font(const char *path)
 727 {
 728     FSRef ref;
 729     SInt16 res_ref;
 730     OSStatus s;
 731     unsigned int idx;
 732     const char *out_dir;
 733     const char *filename;
 734     int output_len;
 735     struct {
 736         char **array;
 737         unsigned int size, max_size;
 738     } ret;
 739
 740     TRACE("path %s\n", path);
 741
 742     s = FSPathMakeRef((unsigned char*)path, &ref, FALSE);
 743     if(s != noErr)
 744     {
 745         WARN("failed to get ref\n");
 746         return NULL;
 747     }
 748
 749     s = FSOpenResourceFile(&ref, 0, NULL, fsRdPerm, &res_ref);
 750     if(s != noErr)
 751     {
 752         TRACE("no data fork, so trying resource fork\n");
 753         res_ref = FSOpenResFile(&ref, fsRdPerm);
 754         if(res_ref == -1)
 755         {
 756             TRACE("unable to open resource fork\n");
 757             return NULL;
 758         }
 759     }
 760
 761     ret.size = 0;
 762     ret.max_size = 10;
 763     ret.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.max_size * sizeof(*ret.array));
 764     if(!ret.array)
 765     {
 766         CloseResFile(res_ref);
 767         return NULL;
 768     }
 769
 770     out_dir = find_cache_dir();
 771
 772     filename = strrchr(path, '/');
 773     if(!filename) filename = path;
 774     else filename++;
 775
 776     /* output filename has the form out_dir/filename_%04x.ttf */
 777     output_len = strlen(out_dir) + 1 + strlen(filename) + 5 + 5;
 778
 779     UseResFile(res_ref);
 780     idx = 1;
 781     while(1)
 782     {
 783         FamRec *fam_rec;
 784         unsigned short *num_faces_ptr, num_faces, face;
 785         AsscEntry *assoc;
 786         Handle fond;
 787         ResType fond_res = FT_MAKE_TAG('F','O','N','D');
 788
 789         fond = Get1IndResource(fond_res, idx);
 790         if(!fond) break;
 791         TRACE("got fond resource %d\n", idx);
 792         HLock(fond);
 793
 794         fam_rec = *(FamRec**)fond;
 795         num_faces_ptr = (unsigned short *)(fam_rec + 1);
 796         num_faces = GET_BE_WORD(*num_faces_ptr);
 797         num_faces++;
 798         assoc = (AsscEntry*)(num_faces_ptr + 1);
 799         TRACE("num faces %04x\n", num_faces);
 800         for(face = 0; face < num_faces; face++, assoc++)
 801         {
 802             Handle sfnt;
 803             ResType sfnt_res = FT_MAKE_TAG('s','f','n','t');
 804             unsigned short size, font_id;
 805             char *output;
 806
 807             size = GET_BE_WORD(assoc->fontSize);
 808             font_id = GET_BE_WORD(assoc->fontID);
 809             if(size != 0)
 810             {
 811                 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id, size);
 812                 continue;
 813             }
 814
 815             TRACE("trying to load sfnt id %04x\n", font_id);
 816             sfnt = GetResource(sfnt_res, font_id);
 817             if(!sfnt)
 818             {
 819                 TRACE("can't get sfnt resource %04x\n", font_id);
 820                 continue;
 821             }
 822
 823             output = HeapAlloc(GetProcessHeap(), 0, output_len);
 824             if(output)
 825             {
 826                 int fd;
 827
 828                 sprintf(output, "%s/%s_%04x.ttf", out_dir, filename, font_id);
 829
 830                 fd = open(output, O_CREAT | O_EXCL | O_WRONLY, 0600);
 831                 if(fd != -1 || errno == EEXIST)
 832                 {
 833                     if(fd != -1)
 834                     {
 835                         unsigned char *sfnt_data;
 836
 837                         HLock(sfnt);
 838                         sfnt_data = *(unsigned char**)sfnt;
 839                         write(fd, sfnt_data, GetHandleSize(sfnt));
 840                         HUnlock(sfnt);
 841                         close(fd);
 842                     }
 843                     if(ret.size >= ret.max_size - 1) /* Always want the last element to be NULL */
 844                     {
 845                         ret.max_size *= 2;
 846                         ret.array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.array, ret.max_size * sizeof(*ret.array));
 847                     }
 848                     ret.array[ret.size++] = output;
 849                 }
 850                 else
 851                 {
 852                     WARN("unable to create %s\n", output);
 853                     HeapFree(GetProcessHeap(), 0, output);
 854                 }
 855             }
 856             ReleaseResource(sfnt);
 857         }
 858         HUnlock(fond);
 859         ReleaseResource(fond);
 860         idx++;
 861     }
 862     CloseResFile(res_ref);
 863
 864     return ret.array;
 865 }
 866
 867 #endif /* HAVE_CARBON_CARBON_H */
 868
 869 static inline BOOL is_win9x(void)
 870 {
 871     return GetVersion() & 0x80000000;
 872 }
 873 /*
 874    This function builds an FT_Fixed from a double. It fails if the absolute
 875    value of the float number is greater than 32768.
 876 */
 877 static inline FT_Fixed FT_FixedFromFloat(double f)
 878 {
 879         return f * 0x10000;
 880 }
 881
 882 /*
 883    This function builds an FT_Fixed from a FIXED. It simply put f.value
 884    in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
 885 */
 886 static inline FT_Fixed FT_FixedFromFIXED(FIXED f)
 887 {
 888     return (FT_Fixed)((int)f.value << 16 | (unsigned int)f.fract);
 889 }
 890
 891
 892 static const struct list *get_face_list_from_family(const Family *family)
 893 {
 894     if (!list_empty(&family->faces))
 895         return &family->faces;
 896     else
 897         return family->replacement;
 898 }
 899
 900 static Face *find_face_from_filename(const WCHAR *file_name, const WCHAR *face_name)
 901 {
 902     Family *family;
 903     Face *face;
 904     const char *file;
 905     DWORD len = WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, NULL, 0, NULL, NULL);
 906     char *file_nameA = HeapAlloc(GetProcessHeap(), 0, len);
 907
 908     WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, file_nameA, len, NULL, NULL);
 909     TRACE("looking for file %s name %s\n", debugstr_a(file_nameA), debugstr_w(face_name));
 910
 911     LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
 912     {
 913         const struct list *face_list;
 914         if(face_name && strcmpiW(face_name, family->FamilyName))
 915             continue;
 916         face_list = get_face_list_from_family(family);
 917         LIST_FOR_EACH_ENTRY(face, face_list, Face, entry)
 918         {
 919             if (!face->file)
 920                 continue;
 921             file = strrchr(face->file, '/');
 922             if(!file)
 923                 file = face->file;
 924             else
 925                 file++;
 926             if(!strcasecmp(file, file_nameA))
 927             {
 928                 HeapFree(GetProcessHeap(), 0, file_nameA);
 929                 return face;
 930             }
 931         }
 932     }
 933     HeapFree(GetProcessHeap(), 0, file_nameA);
 934     return NULL;
 935 }
 936
 937 static Family *find_family_from_name(const WCHAR *name)
 938 {
 939     Family *family;
 940
 941     LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
 942     {
 943         if(!strcmpiW(family->FamilyName, name))
 944             return family;
 945     }
 946
 947     return NULL;
 948 }
 949
 950 static Family *find_family_from_any_name(const WCHAR *name)
 951 {
 952     Family *family;
 953
 954     LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
 955     {
 956         if(!strcmpiW(family->FamilyName, name))
 957             return family;
 958         if(family->EnglishName && !strcmpiW(family->EnglishName, name))
 959             return family;
 960     }
 961
 962     return NULL;
 963 }
 964
 965 static void DumpSubstList(void)
 966 {
 967     FontSubst *psub;
 968
 969     LIST_FOR_EACH_ENTRY(psub, &font_subst_list, FontSubst, entry)
 970     {
 971         if(psub->from.charset != -1 || psub->to.charset != -1)
 972             TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
 973               psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
 974         else
 975             TRACE("%s -> %s\n", debugstr_w(psub->from.name),
 976                   debugstr_w(psub->to.name));
 977     }
 978     return;
 979 }
 980
 981 static LPWSTR strdupW(LPCWSTR p)
 982 {
 983     LPWSTR ret;
 984     DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
 985     ret = HeapAlloc(GetProcessHeap(), 0, len);
 986     memcpy(ret, p, len);
 987     return ret;
 988 }
 989
 990 static LPSTR strdupA(LPCSTR p)
 991 {
 992     LPSTR ret;
 993     DWORD len = (strlen(p) + 1);
 994     ret = HeapAlloc(GetProcessHeap(), 0, len);
 995     memcpy(ret, p, len);
 996     return ret;
 997 }
 998
 999 static FontSubst *get_font_subst(const struct list *subst_list, const WCHAR *from_name,
1000                                  INT from_charset)
1001 {
1002     FontSubst *element;
1003
1004     LIST_FOR_EACH_ENTRY(element, subst_list, FontSubst, entry)
1005     {
1006         if(!strcmpiW(element->from.name, from_name) &&
1007            (element->from.charset == from_charset ||
1008             element->from.charset == -1))
1009             return element;
1010     }
1011
1012     return NULL;
1013 }
1014
1015 #define ADD_FONT_SUBST_FORCE  1
1016
1017 static BOOL add_font_subst(struct list *subst_list, FontSubst *subst, INT flags)
1018 {
1019     FontSubst *from_exist, *to_exist;
1020
1021     from_exist = get_font_subst(subst_list, subst->from.name, subst->from.charset);
1022
1023     if(from_exist && (flags & ADD_FONT_SUBST_FORCE))
1024     {
1025         list_remove(&from_exist->entry);
1026         HeapFree(GetProcessHeap(), 0, &from_exist->from.name);
1027         HeapFree(GetProcessHeap(), 0, &from_exist->to.name);
1028         HeapFree(GetProcessHeap(), 0, from_exist);
1029         from_exist = NULL;
1030     }
1031
1032     if(!from_exist)
1033     {
1034         to_exist = get_font_subst(subst_list, subst->to.name, subst->to.charset);
1035
1036         if(to_exist)
1037         {
1038             HeapFree(GetProcessHeap(), 0, subst->to.name);
1039             subst->to.name = strdupW(to_exist->to.name);
1040         }
1041
1042         list_add_tail(subst_list, &subst->entry);
1043
1044         return TRUE;
1045     }
1046
1047     HeapFree(GetProcessHeap(), 0, subst->from.name);
1048     HeapFree(GetProcessHeap(), 0, subst->to.name);
1049     HeapFree(GetProcessHeap(), 0, subst);
1050     return FALSE;
1051 }
1052
1053 static WCHAR *towstr(UINT cp, const char *str)
1054 {
1055     int len;
1056     WCHAR *wstr;
1057
1058     len = MultiByteToWideChar(cp, 0, str, -1, NULL, 0);
1059     wstr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1060     MultiByteToWideChar(cp, 0, str, -1, wstr, len);
1061     return wstr;
1062 }
1063
1064 static void split_subst_info(NameCs *nc, LPSTR str)
1065 {
1066     CHAR *p = strrchr(str, ',');
1067
1068     nc->charset = -1;
1069     if(p && *(p+1)) {
1070         nc->charset = strtol(p+1, NULL, 10);
1071         *p = '\0';
1072     }
1073     nc->name = towstr(CP_ACP, str);
1074 }
1075
1076 static void LoadSubstList(void)
1077 {
1078     FontSubst *psub;
1079     HKEY hkey;
1080     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1081     LPSTR value;
1082     LPVOID data;
1083
1084     if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
1085                    "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
1086                    &hkey) == ERROR_SUCCESS) {
1087
1088         RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1089                          &valuelen, &datalen, NULL, NULL);
1090
1091         valuelen++; /* returned value doesn't include room for '\0' */
1092         value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
1093         data = HeapAlloc(GetProcessHeap(), 0, datalen);
1094
1095         dlen = datalen;
1096         vlen = valuelen;
1097         while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
1098                             &dlen) == ERROR_SUCCESS) {
1099             TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
1100
1101             psub = HeapAlloc(GetProcessHeap(), 0, sizeof(*psub));
1102             split_subst_info(&psub->from, value);
1103             split_subst_info(&psub->to, data);
1104
1105             /* Win 2000 doesn't allow mapping between different charsets
1106                or mapping of DEFAULT_CHARSET */
1107             if ((psub->from.charset && psub->to.charset != psub->from.charset) ||
1108                psub->to.charset == DEFAULT_CHARSET) {
1109                 HeapFree(GetProcessHeap(), 0, psub->to.name);
1110                 HeapFree(GetProcessHeap(), 0, psub->from.name);
1111                 HeapFree(GetProcessHeap(), 0, psub);
1112             } else {
1113                 add_font_subst(&font_subst_list, psub, 0);
1114             }
1115             /* reset dlen and vlen */
1116             dlen = datalen;
1117             vlen = valuelen;
1118         }
1119         HeapFree(GetProcessHeap(), 0, data);
1120         HeapFree(GetProcessHeap(), 0, value);
1121         RegCloseKey(hkey);
1122     }
1123 }
1124
1125
1126 /*****************************************************************
1127  *       get_name_table_entry
1128  *
1129  * Supply the platform, encoding, language and name ids in req
1130  * and if the name exists the function will fill in the string
1131  * and string_len members.  The string is owned by FreeType so
1132  * don't free it.  Returns TRUE if the name is found else FALSE.
1133  */
1134 static BOOL get_name_table_entry(FT_Face ft_face, FT_SfntName *req)
1135 {
1136     FT_SfntName name;
1137     FT_UInt num_names, name_index;
1138
1139     if(FT_IS_SFNT(ft_face))
1140     {
1141         num_names = pFT_Get_Sfnt_Name_Count(ft_face);
1142
1143         for(name_index = 0; name_index < num_names; name_index++)
1144         {
1145             if(!pFT_Get_Sfnt_Name(ft_face, name_index, &name))
1146             {
1147                 if((name.platform_id == req->platform_id) &&
1148                    (name.encoding_id == req->encoding_id) &&
1149                    (name.language_id == req->language_id) &&
1150                    (name.name_id     == req->name_id))
1151                 {
1152                     req->string = name.string;
1153                     req->string_len = name.string_len;
1154                     return TRUE;
1155                 }
1156             }
1157         }
1158     }
1159     req->string = NULL;
1160     req->string_len = 0;
1161     return FALSE;
1162 }
1163
1164 static WCHAR *get_face_name(FT_Face ft_face, FT_UShort name_id, FT_UShort language_id)
1165 {
1166     WCHAR *ret = NULL;
1167     FT_SfntName name;
1168
1169     name.platform_id = TT_PLATFORM_MICROSOFT;
1170     name.encoding_id = TT_MS_ID_UNICODE_CS;
1171     name.language_id = language_id;
1172     name.name_id     = name_id;
1173
1174     if(get_name_table_entry(ft_face, &name))
1175     {
1176         FT_UInt i;
1177
1178         /* String is not nul terminated and string_len is a byte length. */
1179         ret = HeapAlloc(GetProcessHeap(), 0, name.string_len + 2);
1180         for(i = 0; i < name.string_len / 2; i++)
1181         {
1182             WORD *tmp = (WORD *)&name.string[i * 2];
1183             ret[i] = GET_BE_WORD(*tmp);
1184         }
1185         ret[i] = 0;
1186         TRACE("Got localised name %s\n", debugstr_w(ret));
1187     }
1188
1189     return ret;
1190 }
1191
1192 static inline BOOL faces_equal( const Face *f1, const Face *f2 )
1193 {
1194     if (strcmpiW( f1->StyleName, f2->StyleName )) return FALSE;
1195     if (f1->scalable) return TRUE;
1196     if (f1->size.y_ppem != f2->size.y_ppem) return FALSE;
1197     return !memcmp( &f1->fs, &f2->fs, sizeof(f1->fs) );
1198 }
1199
1200 static inline void free_face( Face *face )
1201 {
1202     HeapFree( GetProcessHeap(), 0, face->file );
1203     HeapFree( GetProcessHeap(), 0, face->StyleName );
1204     HeapFree( GetProcessHeap(), 0, face->FullName );
1205     HeapFree( GetProcessHeap(), 0, face->cached_enum_data );
1206     HeapFree( GetProcessHeap(), 0, face );
1207 }
1208
1209 static inline void free_family( Family *family )
1210 {
1211     Face *face, *cursor2;
1212
1213     LIST_FOR_EACH_ENTRY_SAFE( face, cursor2, &family->faces, Face, entry )
1214     {
1215         list_remove( &face->entry );
1216         free_face( face );
1217     }
1218     HeapFree( GetProcessHeap(), 0, family->FamilyName );
1219     HeapFree( GetProcessHeap(), 0, family->EnglishName );
1220     HeapFree( GetProcessHeap(), 0, family );
1221 }
1222
1223 static inline int style_order(const Face *face)
1224 {
1225     switch (face->ntmFlags & (NTM_REGULAR | NTM_BOLD | NTM_ITALIC))
1226     {
1227     case NTM_REGULAR:
1228         return 0;
1229     case NTM_BOLD:
1230         return 1;
1231     case NTM_ITALIC:
1232         return 2;
1233     case NTM_BOLD | NTM_ITALIC:
1234         return 3;
1235     default:
1236         WARN("Don't know how to order font %s %s with flags 0x%08x\n",
1237              debugstr_w(face->family->FamilyName),
1238              debugstr_w(face->StyleName),
1239              face->ntmFlags);
1240         return 9999;
1241     }
1242 }
1243
1244 static BOOL insert_face_in_family_list( Face *face, Family *family )
1245 {
1246     Face *cursor;
1247
1248     LIST_FOR_EACH_ENTRY( cursor, &family->faces, Face, entry )
1249     {
1250         if (faces_equal( face, cursor ))
1251         {
1252             TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1253                   debugstr_w(family->FamilyName), debugstr_w(face->StyleName),
1254                   cursor->font_version, face->font_version);
1255
1256             if (face->font_version <= cursor->font_version)
1257             {
1258                 TRACE("Original font %s is newer so skipping %s\n",
1259                       debugstr_a(cursor->file), debugstr_a(face->file));
1260                 return FALSE;
1261             }
1262             else
1263             {
1264                 TRACE("Replacing original %s with %s\n",
1265                       debugstr_a(cursor->file), debugstr_a(face->file));
1266                 list_add_before( &cursor->entry, &face->entry );
1267                 face->family = family;
1268                 list_remove( &cursor->entry);
1269                 free_face( cursor );
1270                 return TRUE;
1271             }
1272         }
1273         else
1274             TRACE("Adding new %s\n", debugstr_a(face->file));
1275
1276         if (style_order( face ) < style_order( cursor )) break;
1277     }
1278
1279     list_add_before( &cursor->entry, &face->entry );
1280     face->family = family;
1281     return TRUE;
1282 }
1283
1284 /****************************************************************
1285  * NB This function stores the ptrs to the strings to save copying.
1286  * Don't free them after calling.
1287  */
1288 static Family *create_family( WCHAR *name, WCHAR *english_name )
1289 {
1290     Family * const family = HeapAlloc( GetProcessHeap(), 0, sizeof(*family) );
1291     family->FamilyName = name;
1292     family->EnglishName = english_name;
1293     list_init( &family->faces );
1294     family->replacement = &family->faces;
1295
1296     return family;
1297 }
1298
1299 static LONG reg_load_dword(HKEY hkey, const WCHAR *value, DWORD *data)
1300 {
1301     DWORD type, needed;
1302     LONG r = RegQueryValueExW(hkey, value, NULL, &type, NULL, &needed);
1303     if(r != ERROR_SUCCESS) return r;
1304     if(type != REG_DWORD || needed != sizeof(DWORD)) return ERROR_BAD_CONFIGURATION;
1305     return RegQueryValueExW(hkey, value, NULL, &type, (BYTE*)data, &needed);
1306 }
1307
1308 static inline LONG reg_save_dword(HKEY hkey, const WCHAR *value, DWORD data)
1309 {
1310     return RegSetValueExW(hkey, value, 0, REG_DWORD, (BYTE*)&data, sizeof(DWORD));
1311 }
1312
1313 static void load_face(HKEY hkey_face, WCHAR *face_name, Family *family)
1314 {
1315     DWORD needed;
1316     DWORD num_strikes, max_strike_key_len;
1317
1318     /* If we have a File Name key then this is a real font, not just the parent
1319        key of a bunch of non-scalable strikes */
1320     if(RegQueryValueExA(hkey_face, "File Name", NULL, NULL, NULL, &needed) == ERROR_SUCCESS)
1321     {
1322         Face *face;
1323         face = HeapAlloc(GetProcessHeap(), 0, sizeof(*face));
1324         face->cached_enum_data = NULL;
1325
1326         face->file = HeapAlloc(GetProcessHeap(), 0, needed);
1327         RegQueryValueExA(hkey_face, "File Name", NULL, NULL, (BYTE*)face->file, &needed);
1328
1329         face->StyleName = strdupW(face_name);
1330
1331         if(RegQueryValueExW(hkey_face, face_full_name_value, NULL, NULL, NULL, &needed) == ERROR_SUCCESS)
1332         {
1333             WCHAR *fullName = HeapAlloc(GetProcessHeap(), 0, needed);
1334             RegQueryValueExW(hkey_face, face_full_name_value, NULL, NULL, (BYTE*)fullName, &needed);
1335             face->FullName = fullName;
1336         }
1337         else
1338             face->FullName = NULL;
1339
1340         reg_load_dword(hkey_face, face_index_value, (DWORD*)&face->face_index);
1341         reg_load_dword(hkey_face, face_ntmflags_value, &face->ntmFlags);
1342         reg_load_dword(hkey_face, face_version_value, (DWORD*)&face->font_version);
1343         reg_load_dword(hkey_face, face_vertical_value, (DWORD*)&face->vertical);
1344
1345         needed = sizeof(face->fs);
1346         RegQueryValueExW(hkey_face, face_font_sig_value, NULL, NULL, (BYTE*)&face->fs, &needed);
1347
1348         if(reg_load_dword(hkey_face, face_height_value, (DWORD*)&face->size.height) != ERROR_SUCCESS)
1349         {
1350             face->scalable = TRUE;
1351             memset(&face->size, 0, sizeof(face->size));
1352         }
1353         else
1354         {
1355             face->scalable = FALSE;
1356             reg_load_dword(hkey_face, face_width_value, (DWORD*)&face->size.width);
1357             reg_load_dword(hkey_face, face_size_value, (DWORD*)&face->size.size);
1358             reg_load_dword(hkey_face, face_x_ppem_value, (DWORD*)&face->size.x_ppem);
1359             reg_load_dword(hkey_face, face_y_ppem_value, (DWORD*)&face->size.y_ppem);
1360             reg_load_dword(hkey_face, face_internal_leading_value, (DWORD*)&face->size.internal_leading);
1361
1362             TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1363                   face->size.height, face->size.width, face->size.size >> 6,
1364                   face->size.x_ppem >> 6, face->size.y_ppem >> 6);
1365         }
1366
1367         TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1368               face->fs.fsCsb[0], face->fs.fsCsb[1],
1369               face->fs.fsUsb[0], face->fs.fsUsb[1],
1370               face->fs.fsUsb[2], face->fs.fsUsb[3]);
1371
1372         insert_face_in_family_list(face, family);
1373
1374         TRACE("Added font %s %s\n", debugstr_w(family->FamilyName), debugstr_w(face->StyleName));
1375     }
1376
1377     /* do we have any bitmap strikes? */
1378     RegQueryInfoKeyW(hkey_face, NULL, NULL, NULL, &num_strikes, &max_strike_key_len, NULL, NULL,
1379                      NULL, NULL, NULL, NULL);
1380     if(num_strikes != 0)
1381     {
1382         WCHAR strike_name[10];
1383         DWORD strike_index = 0;
1384
1385         needed = sizeof(strike_name) / sizeof(WCHAR);
1386         while(RegEnumKeyExW(hkey_face, strike_index++, strike_name, &needed,
1387                             NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
1388         {
1389             HKEY hkey_strike;
1390             RegOpenKeyExW(hkey_face, strike_name, 0, KEY_ALL_ACCESS, &hkey_strike);
1391             load_face(hkey_strike, face_name, family);
1392             RegCloseKey(hkey_strike);
1393             needed = sizeof(strike_name) / sizeof(WCHAR);
1394         }
1395     }
1396 }
1397
1398 static void load_font_list_from_cache(HKEY hkey_font_cache)
1399 {
1400     DWORD max_family_key_len, size;
1401     WCHAR *family_name;
1402     DWORD family_index = 0;
1403     Family *family;
1404     HKEY hkey_family;
1405
1406     RegQueryInfoKeyW(hkey_font_cache, NULL, NULL, NULL, NULL, &max_family_key_len, NULL, NULL,
1407                      NULL, NULL, NULL, NULL);
1408     family_name = HeapAlloc(GetProcessHeap(), 0, (max_family_key_len + 1) * sizeof(WCHAR));
1409
1410     size = max_family_key_len + 1;
1411     while(RegEnumKeyExW(hkey_font_cache, family_index++, family_name, &size,
1412                         NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
1413     {
1414         WCHAR *english_family = NULL;
1415         DWORD face_index = 0;
1416         WCHAR *face_name;
1417         DWORD max_face_key_len;
1418
1419         RegOpenKeyExW(hkey_font_cache, family_name, 0, KEY_ALL_ACCESS, &hkey_family);
1420         TRACE("opened family key %s\n", debugstr_w(family_name));
1421         if(RegQueryValueExW(hkey_family, english_name_value, NULL, NULL, NULL, &size) == ERROR_SUCCESS)
1422         {
1423             english_family = HeapAlloc(GetProcessHeap(), 0, size);
1424             RegQueryValueExW(hkey_family, english_name_value, NULL, NULL, (BYTE*)english_family, &size);
1425         }
1426
1427         family = create_family(strdupW(family_name), english_family);
1428         list_add_tail(&font_list, &family->entry);
1429
1430         if(english_family)
1431         {
1432             FontSubst *subst = HeapAlloc(GetProcessHeap(), 0, sizeof(*subst));
1433             subst->from.name = strdupW(english_family);
1434             subst->from.charset = -1;
1435             subst->to.name = strdupW(family_name);
1436             subst->to.charset = -1;
1437             add_font_subst(&font_subst_list, subst, 0);
1438         }
1439
1440         RegQueryInfoKeyW(hkey_family, NULL, NULL, NULL, NULL, &max_face_key_len, NULL, NULL,
1441                          NULL, NULL, NULL, NULL);
1442
1443         face_name = HeapAlloc(GetProcessHeap(), 0, (max_face_key_len + 1) * sizeof(WCHAR));
1444         size = max_face_key_len + 1;
1445         while(RegEnumKeyExW(hkey_family, face_index++, face_name, &size,
1446                             NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
1447         {
1448             HKEY hkey_face;
1449
1450             RegOpenKeyExW(hkey_family, face_name, 0, KEY_ALL_ACCESS, &hkey_face);
1451             load_face(hkey_face, face_name, family);
1452             RegCloseKey(hkey_face);
1453             size = max_face_key_len + 1;
1454         }
1455         HeapFree(GetProcessHeap(), 0, face_name);
1456         RegCloseKey(hkey_family);
1457         size = max_family_key_len + 1;
1458     }
1459
1460     HeapFree(GetProcessHeap(), 0, family_name);
1461 }
1462
1463 static LONG create_font_cache_key(HKEY *hkey, DWORD *disposition)
1464 {
1465     LONG ret;
1466     HKEY hkey_wine_fonts;
1467
1468     /* We don't want to create the fonts key as volatile, so open this first */
1469     ret = RegCreateKeyExW(HKEY_CURRENT_USER, wine_fonts_key, 0, NULL, 0,
1470                           KEY_ALL_ACCESS, NULL, &hkey_wine_fonts, NULL);
1471     if(ret != ERROR_SUCCESS)
1472     {
1473         WARN("Can't create %s\n", debugstr_w(wine_fonts_key));
1474         return ret;
1475     }
1476
1477     ret = RegCreateKeyExW(hkey_wine_fonts, wine_fonts_cache_key, 0, NULL, REG_OPTION_VOLATILE,
1478                           KEY_ALL_ACCESS, NULL, hkey, disposition);
1479     RegCloseKey(hkey_wine_fonts);
1480     return ret;
1481 }
1482
1483 static void add_face_to_cache(Face *face)
1484 {
1485     HKEY hkey_font_cache, hkey_family, hkey_face;
1486     WCHAR *face_key_name;
1487
1488     create_font_cache_key(&hkey_font_cache, NULL);
1489
1490     RegCreateKeyExW(hkey_font_cache, face->family->FamilyName, 0,
1491                     NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey_family, NULL);
1492     if(face->family->EnglishName)
1493         RegSetValueExW(hkey_family, english_name_value, 0, REG_SZ, (BYTE*)face->family->EnglishName,
1494                        (strlenW(face->family->EnglishName) + 1) * sizeof(WCHAR));
1495
1496     if(face->scalable)
1497         face_key_name = face->StyleName;
1498     else
1499     {
1500         static const WCHAR fmtW[] = {'%','s','\\','%','d',0};
1501         face_key_name = HeapAlloc(GetProcessHeap(), 0, (strlenW(face->StyleName) + 10) * sizeof(WCHAR));
1502         sprintfW(face_key_name, fmtW, face->StyleName, face->size.y_ppem);
1503     }
1504     RegCreateKeyExW(hkey_family, face_key_name, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL,
1505                     &hkey_face, NULL);
1506     if(!face->scalable)
1507         HeapFree(GetProcessHeap(), 0, face_key_name);
1508
1509     RegSetValueExA(hkey_face, "File Name", 0, REG_BINARY, (BYTE*)face->file, strlen(face->file) + 1);
1510     if (face->FullName)
1511         RegSetValueExW(hkey_face, face_full_name_value, 0, REG_SZ, (BYTE*)face->FullName,
1512                        (strlenW(face->FullName) + 1) * sizeof(WCHAR));
1513
1514     reg_save_dword(hkey_face, face_index_value, face->face_index);
1515     reg_save_dword(hkey_face, face_ntmflags_value, face->ntmFlags);
1516     reg_save_dword(hkey_face, face_version_value, face->font_version);
1517     reg_save_dword(hkey_face, face_vertical_value, face->vertical);
1518
1519     RegSetValueExW(hkey_face, face_font_sig_value, 0, REG_BINARY, (BYTE*)&face->fs, sizeof(face->fs));
1520
1521     if(!face->scalable)
1522     {
1523         reg_save_dword(hkey_face, face_height_value, face->size.height);
1524         reg_save_dword(hkey_face, face_width_value, face->size.width);
1525         reg_save_dword(hkey_face, face_size_value, face->size.size);
1526         reg_save_dword(hkey_face, face_x_ppem_value, face->size.x_ppem);
1527         reg_save_dword(hkey_face, face_y_ppem_value, face->size.y_ppem);
1528         reg_save_dword(hkey_face, face_internal_leading_value, face->size.internal_leading);
1529     }
1530     RegCloseKey(hkey_face);
1531     RegCloseKey(hkey_family);
1532     RegCloseKey(hkey_font_cache);
1533 }
1534
1535 static WCHAR *prepend_at(WCHAR *family)
1536 {
1537     WCHAR *str;
1538
1539     if (!family)
1540         return NULL;
1541
1542     str = HeapAlloc(GetProcessHeap(), 0, sizeof (WCHAR) * (strlenW(family) + 2));
1543     str[0] = '@';
1544     strcpyW(str + 1, family);
1545     HeapFree(GetProcessHeap(), 0, family);
1546     return str;
1547 }
1548
1549 static void get_family_names( FT_Face ft_face, WCHAR **name, WCHAR **english, BOOL vertical )
1550 {
1551     *english = get_face_name( ft_face, TT_NAME_ID_FONT_FAMILY, TT_MS_LANGID_ENGLISH_UNITED_STATES );
1552     if (!*english) *english = towstr( CP_ACP, ft_face->family_name );
1553
1554     *name = get_face_name( ft_face, TT_NAME_ID_FONT_FAMILY, GetUserDefaultLCID() );
1555     if (!*name)
1556     {
1557         *name = *english;
1558         *english = NULL;
1559     }
1560     else if (!strcmpiW( *name, *english ))
1561     {
1562         HeapFree( GetProcessHeap(), 0, *english );
1563         *english = NULL;
1564     }
1565
1566     if (vertical)
1567     {
1568         *name = prepend_at( *name );
1569         *english = prepend_at( *english );
1570     }
1571 }
1572
1573 static Family *get_family( FT_Face ft_face, BOOL vertical )
1574 {
1575     Family *family;
1576     WCHAR *name, *english_name;
1577
1578     get_family_names( ft_face, &name, &english_name, vertical );
1579
1580     family = find_family_from_name( name );
1581
1582     if (!family)
1583     {
1584         family = create_family( name, english_name );
1585         list_add_tail( &font_list, &family->entry );
1586
1587         if (english_name)
1588         {
1589             FontSubst *subst = HeapAlloc( GetProcessHeap(), 0, sizeof(*subst) );
1590             subst->from.name = strdupW( english_name );
1591             subst->from.charset = -1;
1592             subst->to.name = strdupW( name );
1593             subst->to.charset = -1;
1594             add_font_subst( &font_subst_list, subst, 0 );
1595         }
1596     }
1597     else
1598     {
1599         HeapFree( GetProcessHeap(), 0, name );
1600         HeapFree( GetProcessHeap(), 0, english_name );
1601     }
1602
1603     return family;
1604 }
1605
1606 static inline FT_Fixed get_font_version( FT_Face ft_face )
1607 {
1608     FT_Fixed version = 0;
1609     TT_Header *header;
1610
1611     header = pFT_Get_Sfnt_Table( ft_face, ft_sfnt_head );
1612     if (header) version = header->Font_Revision;
1613
1614     return version;
1615 }
1616
1617 static inline DWORD get_ntm_flags( FT_Face ft_face )
1618 {
1619     DWORD flags = 0;
1620     FT_ULong table_size = 0;
1621
1622     if (ft_face->style_flags & FT_STYLE_FLAG_ITALIC) flags |= NTM_ITALIC;
1623     if (ft_face->style_flags & FT_STYLE_FLAG_BOLD)   flags |= NTM_BOLD;
1624     if (flags == 0) flags = NTM_REGULAR;
1625
1626     if (!pFT_Load_Sfnt_Table( ft_face, FT_MAKE_TAG( 'C','F','F',' ' ), 0, NULL, &table_size ))
1627         flags |= NTM_PS_OPENTYPE;
1628
1629     return flags;
1630 }
1631
1632 static inline int get_bitmap_internal_leading( FT_Face ft_face )
1633 {
1634     int internal_leading = 0;
1635     FT_WinFNT_HeaderRec winfnt_header;
1636
1637     if (!pFT_Get_WinFNT_Header( ft_face, &winfnt_header ))
1638         internal_leading = winfnt_header.internal_leading;
1639
1640     return internal_leading;
1641 }
1642
1643 static inline void get_fontsig( FT_Face ft_face, FONTSIGNATURE *fs )
1644 {
1645     TT_OS2 *os2;
1646     FT_UInt dummy;
1647     CHARSETINFO csi;
1648     FT_WinFNT_HeaderRec winfnt_header;
1649     int i;
1650
1651     memset( fs, 0, sizeof(*fs) );
1652
1653     os2 = pFT_Get_Sfnt_Table( ft_face, ft_sfnt_os2 );
1654     if (os2)
1655     {
1656         fs->fsUsb[0] = os2->ulUnicodeRange1;
1657         fs->fsUsb[1] = os2->ulUnicodeRange2;
1658         fs->fsUsb[2] = os2->ulUnicodeRange3;
1659         fs->fsUsb[3] = os2->ulUnicodeRange4;
1660
1661         if (os2->version == 0)
1662         {
1663             if (pFT_Get_First_Char( ft_face, &dummy ) < 0x100)
1664                 fs->fsCsb[0] = FS_LATIN1;
1665             else
1666                 fs->fsCsb[0] = FS_SYMBOL;
1667         }
1668         else
1669         {
1670             fs->fsCsb[0] = os2->ulCodePageRange1;
1671             fs->fsCsb[1] = os2->ulCodePageRange2;
1672         }
1673     }
1674     else
1675     {
1676         if (!pFT_Get_WinFNT_Header( ft_face, &winfnt_header ))
1677         {
1678             TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header.pixel_height, winfnt_header.charset,
1679                   winfnt_header.vertical_resolution,winfnt_header.horizontal_resolution, winfnt_header.nominal_point_size);
1680             if (TranslateCharsetInfo( (DWORD*)(UINT_PTR)winfnt_header.charset, &csi, TCI_SRCCHARSET ))
1681                 *fs = csi.fs;
1682         }
1683     }
1684
1685     if (fs->fsCsb[0] == 0)
1686     {
1687         /* let's see if we can find any interesting cmaps */
1688         for (i = 0; i < ft_face->num_charmaps; i++)
1689         {
1690             switch (ft_face->charmaps[i]->encoding)
1691             {
1692             case FT_ENCODING_UNICODE:
1693             case FT_ENCODING_APPLE_ROMAN:
1694                 fs->fsCsb[0] |= FS_LATIN1;
1695                 break;
1696             case FT_ENCODING_MS_SYMBOL:
1697                 fs->fsCsb[0] |= FS_SYMBOL;
1698                 break;
1699             default:
1700                 break;
1701             }
1702         }
1703     }
1704 }
1705
1706 #define ADDFONT_EXTERNAL_FONT 0x01
1707 #define ADDFONT_FORCE_BITMAP  0x02
1708 #define ADDFONT_ADD_TO_CACHE  0x04
1709
1710 static Face *create_face( FT_Face ft_face, FT_Long face_index, const char *file, void *font_data_ptr, DWORD font_data_size,
1711                           DWORD flags, BOOL vertical )
1712 {
1713     Face *face = HeapAlloc( GetProcessHeap(), 0, sizeof(*face) );
1714     My_FT_Bitmap_Size *size = (My_FT_Bitmap_Size *)ft_face->available_sizes;
1715
1716     face->StyleName = towstr( CP_ACP, ft_face->style_name );
1717     face->FullName = get_face_name( ft_face, TT_NAME_ID_FULL_NAME, TT_MS_LANGID_ENGLISH_UNITED_STATES );
1718     if (file)
1719     {
1720         face->file = strdupA( file );
1721         face->font_data_ptr = NULL;
1722         face->font_data_size = 0;
1723     }
1724     else
1725     {
1726         face->file = NULL;
1727         face->font_data_ptr = font_data_ptr;
1728         face->font_data_size = font_data_size;
1729     }
1730
1731     face->face_index = face_index;
1732     get_fontsig( ft_face, &face->fs );
1733     face->ntmFlags = get_ntm_flags( ft_face );
1734     face->font_version = get_font_version( ft_face );
1735
1736     if (FT_IS_SCALABLE( ft_face ))
1737     {
1738         memset( &face->size, 0, sizeof(face->size) );
1739         face->scalable = TRUE;
1740     }
1741     else
1742     {
1743         TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1744               size->height, size->width, size->size >> 6,
1745               size->x_ppem >> 6, size->y_ppem >> 6);
1746         face->size.height = size->height;
1747         face->size.width = size->width;
1748         face->size.size = size->size;
1749         face->size.x_ppem = size->x_ppem;
1750         face->size.y_ppem = size->y_ppem;
1751         face->size.internal_leading = get_bitmap_internal_leading( ft_face );
1752         face->scalable = FALSE;
1753     }
1754
1755     face->vertical = vertical;
1756     face->external = (flags & ADDFONT_EXTERNAL_FONT) ? TRUE : FALSE;
1757     face->family = NULL;
1758     face->cached_enum_data = NULL;
1759
1760     TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1761           face->fs.fsCsb[0], face->fs.fsCsb[1],
1762           face->fs.fsUsb[0], face->fs.fsUsb[1],
1763           face->fs.fsUsb[2], face->fs.fsUsb[3]);
1764
1765     return face;
1766 }
1767
1768 static void AddFaceToList(FT_Face ft_face, const char *file, void *font_data_ptr, DWORD font_data_size,
1769                           FT_Long face_index, DWORD flags, BOOL vertical)
1770 {
1771     Face *face;
1772     Family *family;
1773
1774     face = create_face( ft_face, face_index, file, font_data_ptr, font_data_size, flags, vertical );
1775     family = get_family( ft_face, vertical );
1776     if (!insert_face_in_family_list( face, family ))
1777     {
1778         free_face( face );
1779         return;
1780     }
1781
1782     if (flags & ADDFONT_ADD_TO_CACHE)
1783         add_face_to_cache( face );
1784
1785     TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
1786           debugstr_w(face->StyleName));
1787 }
1788
1789 static FT_Face new_ft_face( const char *file, void *font_data_ptr, DWORD font_data_size,
1790                             FT_Long face_index, BOOL allow_bitmap )
1791 {
1792     FT_Error err;
1793     TT_OS2 *pOS2;
1794     FT_Face ft_face;
1795
1796     if (file)
1797     {
1798         TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
1799         err = pFT_New_Face(library, file, face_index, &ft_face);
1800     }
1801     else
1802     {
1803         TRACE("Loading font from ptr %p size %d, index %ld\n", font_data_ptr, font_data_size, face_index);
1804         err = pFT_New_Memory_Face(library, font_data_ptr, font_data_size, face_index, &ft_face);
1805     }
1806
1807     if (err != 0)
1808     {
1809         WARN("Unable to load font %s/%p err = %x\n", debugstr_a(file), font_data_ptr, err);
1810         return NULL;
1811     }
1812
1813     /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1814     if (!FT_IS_SCALABLE( ft_face ) && FT_SimpleVersion < ((2 << 16) | (1 << 8) | (9 << 0)))
1815     {
1816         WARN("FreeType version < 2.1.9, skipping bitmap font %s/%p\n", debugstr_a(file), font_data_ptr);
1817         goto fail;
1818     }
1819
1820     if (!FT_IS_SFNT( ft_face ))
1821     {
1822         if (FT_IS_SCALABLE( ft_face ) || !allow_bitmap )
1823         {
1824             WARN("Ignoring font %s/%p\n", debugstr_a(file), font_data_ptr);
1825             goto fail;
1826         }
1827     }
1828     else
1829     {
1830         if (!(pOS2 = pFT_Get_Sfnt_Table( ft_face, ft_sfnt_os2 )) ||
1831             !pFT_Get_Sfnt_Table( ft_face, ft_sfnt_hhea ) ||
1832             !pFT_Get_Sfnt_Table( ft_face, ft_sfnt_head ))
1833         {
1834             TRACE("Font %s/%p lacks either an OS2, HHEA or HEAD table.\n"
1835                   "Skipping this font.\n", debugstr_a(file), font_data_ptr);
1836             goto fail;
1837         }
1838
1839         /* Wine uses ttfs as an intermediate step in building its bitmap fonts;
1840            we don't want to load these. */
1841         if (!memcmp( pOS2->achVendID, "Wine", sizeof(pOS2->achVendID) ))
1842         {
1843             FT_ULong len = 0;
1844
1845             if (!pFT_Load_Sfnt_Table( ft_face, FT_MAKE_TAG('E','B','S','C'), 0, NULL, &len ))
1846             {
1847                 TRACE("Skipping Wine bitmap-only TrueType font %s\n", debugstr_a(file));
1848                 goto fail;
1849             }
1850         }
1851     }
1852
1853     if (!ft_face->family_name || !ft_face->style_name)
1854     {
1855         TRACE("Font %s/%p lacks either a family or style name\n", debugstr_a(file), font_data_ptr);
1856         goto fail;
1857     }
1858
1859     return ft_face;
1860 fail:
1861     pFT_Done_Face( ft_face );
1862     return NULL;
1863 }
1864
1865 static INT AddFontToList(const char *file, void *font_data_ptr, DWORD font_data_size, DWORD flags)
1866 {
1867     FT_Face ft_face;
1868     FT_Long face_index = 0, num_faces;
1869     INT ret = 0;
1870
1871     /* we always load external fonts from files - otherwise we would get a crash in update_reg_entries */
1872     assert(file || !(flags & ADDFONT_EXTERNAL_FONT));
1873
1874 #ifdef HAVE_CARBON_CARBON_H
1875     if(file)
1876     {
1877         char **mac_list = expand_mac_font(file);
1878         if(mac_list)
1879         {
1880             BOOL had_one = FALSE;
1881             char **cursor;
1882             for(cursor = mac_list; *cursor; cursor++)
1883             {
1884                 had_one = TRUE;
1885                 AddFontToList(*cursor, NULL, 0, flags);
1886                 HeapFree(GetProcessHeap(), 0, *cursor);
1887             }
1888             HeapFree(GetProcessHeap(), 0, mac_list);
1889             if(had_one)
1890                 return 1;
1891         }
1892     }
1893 #endif /* HAVE_CARBON_CARBON_H */
1894
1895     do {
1896         ft_face = new_ft_face( file, font_data_ptr, font_data_size, face_index, flags & ADDFONT_FORCE_BITMAP );
1897         if (!ft_face) return 0;
1898
1899         if(ft_face->family_name[0] == '.') /* Ignore fonts with names beginning with a dot */
1900         {
1901             TRACE("Ignoring %s since its family name begins with a dot\n", debugstr_a(file));
1902             pFT_Done_Face(ft_face);
1903             return 0;
1904         }
1905
1906         AddFaceToList(ft_face, file, font_data_ptr, font_data_size, face_index, flags, FALSE);
1907         ++ret;
1908
1909         if (FT_HAS_VERTICAL(ft_face))
1910         {
1911             AddFaceToList(ft_face, file, font_data_ptr, font_data_size, face_index, flags, TRUE);
1912             ++ret;
1913         }
1914
1915         num_faces = ft_face->num_faces;
1916         pFT_Done_Face(ft_face);
1917     } while(num_faces > ++face_index);
1918     return ret;
1919 }
1920
1921 static void DumpFontList(void)
1922 {
1923     Family *family;
1924     Face *face;
1925     struct list *family_elem_ptr, *face_elem_ptr;
1926
1927     LIST_FOR_EACH(family_elem_ptr, &font_list) {
1928         family = LIST_ENTRY(family_elem_ptr, Family, entry);
1929         TRACE("Family: %s\n", debugstr_w(family->FamilyName));
1930         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1931             face = LIST_ENTRY(face_elem_ptr, Face, entry);
1932             TRACE("\t%s\t%08x", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
1933             if(!face->scalable)
1934                 TRACE(" %d", face->size.height);
1935             TRACE("\n");
1936         }
1937     }
1938     return;
1939 }
1940
1941 /***********************************************************
1942  * The replacement list is a way to map an entire font
1943  * family onto another family.  For example adding
1944  *
1945  * [HKCU\Software\Wine\Fonts\Replacements]
1946  * "Wingdings"="Winedings"
1947  *
1948  * would enumerate the Winedings font both as Winedings and
1949  * Wingdings.  However if a real Wingdings font is present the
1950  * replacement does not take place.
1951  *
1952  */
1953 static void LoadReplaceList(void)
1954 {
1955     HKEY hkey;
1956     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1957     LPWSTR value;
1958     LPVOID data;
1959     CHAR familyA[400];
1960
1961     /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1962     if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
1963     {
1964         RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1965                          &valuelen, &datalen, NULL, NULL);
1966
1967         valuelen++; /* returned value doesn't include room for '\0' */
1968         value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1969         data = HeapAlloc(GetProcessHeap(), 0, datalen);
1970
1971         dlen = datalen;
1972         vlen = valuelen;
1973         while(RegEnumValueW(hkey, i++, value, &vlen, NULL, &type, data,
1974                             &dlen) == ERROR_SUCCESS) {
1975             TRACE("Got %s=%s\n", debugstr_w(value), debugstr_w(data));
1976             /* "NewName"="Oldname" */
1977             WideCharToMultiByte(CP_ACP, 0, value, -1, familyA, sizeof(familyA), NULL, NULL);
1978
1979             if(!find_family_from_any_name(value))
1980             {
1981                 Family * const family = find_family_from_any_name(data);
1982                 if (family != NULL)
1983                 {
1984                     Family * const new_family = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_family));
1985                     if (new_family != NULL)
1986                     {
1987                         TRACE("mapping %s to %s\n", debugstr_w(data), debugstr_w(value));
1988                         new_family->FamilyName = strdupW(value);
1989                         new_family->EnglishName = NULL;
1990                         list_init(&new_family->faces);
1991                         new_family->replacement = &family->faces;
1992                         list_add_tail(&font_list, &new_family->entry);
1993                     }
1994                 }
1995                 else
1996                 {
1997                     TRACE("%s is not available. Skip this replacement.\n", debugstr_w(data));
1998                 }
1999             }
2000             else
2001             {
2002                 TRACE("%s is available. Skip this replacement.\n", debugstr_w(value));
2003             }
2004             /* reset dlen and vlen */
2005             dlen = datalen;
2006             vlen = valuelen;
2007         }
2008         HeapFree(GetProcessHeap(), 0, data);
2009         HeapFree(GetProcessHeap(), 0, value);
2010         RegCloseKey(hkey);
2011     }
2012 }
2013
2014 static const WCHAR *font_links_list[] =
2015 {
2016     Lucida_Sans_Unicode,
2017     Microsoft_Sans_Serif,
2018     Tahoma
2019 };
2020
2021 static const struct font_links_defaults_list
2022 {
2023     /* Keyed off substitution for "MS Shell Dlg" */
2024     const WCHAR *shelldlg;
2025     /* Maximum of four substitutes, plus terminating NULL pointer */
2026     const WCHAR *substitutes[5];
2027 } font_links_defaults_list[] =
2028 {
2029     /* Non East-Asian */
2030     { Tahoma, /* FIXME unverified ordering */
2031       { MS_UI_Gothic, SimSun, Gulim, PMingLiU, NULL }
2032     },
2033     /* Below lists are courtesy of
2034      * http://blogs.msdn.com/michkap/archive/2005/06/18/430507.aspx
2035      */
2036     /* Japanese */
2037     { MS_UI_Gothic,
2038       { MS_UI_Gothic, PMingLiU, SimSun, Gulim, NULL }
2039     },
2040     /* Chinese Simplified */
2041     { SimSun,
2042       { SimSun, PMingLiU, MS_UI_Gothic, Batang, NULL }
2043     },
2044     /* Korean */
2045     { Gulim,
2046       { Gulim, PMingLiU, MS_UI_Gothic, SimSun, NULL }
2047     },
2048     /* Chinese Traditional */
2049     { PMingLiU,
2050       { PMingLiU, SimSun, MS_UI_Gothic, Batang, NULL }
2051     }
2052 };
2053
2054
2055 static SYSTEM_LINKS *find_font_link(const WCHAR *name)
2056 {
2057     SYSTEM_LINKS *font_link;
2058
2059     LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2060     {
2061         if(!strcmpiW(font_link->font_name, name))
2062             return font_link;
2063     }
2064
2065     return NULL;
2066 }
2067
2068 static void populate_system_links(const WCHAR *name, const WCHAR *const *values)
2069 {
2070     const WCHAR *value;
2071     int i;
2072     FontSubst *psub;
2073     Family *family;
2074     Face *face;
2075     const char *file;
2076     WCHAR *fileW;
2077
2078     if (values)
2079     {
2080         SYSTEM_LINKS *font_link;
2081
2082         psub = get_font_subst(&font_subst_list, name, -1);
2083         /* Don't store fonts that are only substitutes for other fonts */
2084         if(psub)
2085         {
2086             TRACE("%s: Internal SystemLink entry for substituted font, ignoring\n", debugstr_w(name));
2087             return;
2088         }
2089
2090         font_link = find_font_link(name);
2091         if (font_link == NULL)
2092         {
2093             font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
2094             font_link->font_name = strdupW(name);
2095             list_init(&font_link->links);
2096             list_add_tail(&system_links, &font_link->entry);
2097         }
2098
2099         memset(&font_link->fs, 0, sizeof font_link->fs);
2100         for (i = 0; values[i] != NULL; i++)
2101         {
2102             const struct list *face_list;
2103             CHILD_FONT *child_font;
2104
2105             value = values[i];
2106             if (!strcmpiW(name,value))
2107                 continue;
2108             psub = get_font_subst(&font_subst_list, value, -1);
2109             if(psub)
2110                 value = psub->to.name;
2111             family = find_family_from_name(value);
2112             if (!family)
2113                 continue;
2114             file = NULL;
2115             /* Use first extant filename for this Family */
2116             face_list = get_face_list_from_family(family);
2117             LIST_FOR_EACH_ENTRY(face, face_list, Face, entry)
2118             {
2119                 if (!face->file)
2120                     continue;
2121                 file = strrchr(face->file, '/');
2122                 if (!file)
2123                     file = face->file;
2124                 else
2125                     file++;
2126                 break;
2127             }
2128             if (!file)
2129                 continue;
2130             fileW = towstr(CP_UNIXCP, file);
2131
2132             face = find_face_from_filename(fileW, value);
2133             if(!face)
2134             {
2135                 TRACE("Unable to find file %s face name %s\n", debugstr_w(fileW), debugstr_w(value));
2136                 continue;
2137             }
2138
2139             child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2140             child_font->face = face;
2141             child_font->font = NULL;
2142             font_link->fs.fsCsb[0] |= face->fs.fsCsb[0];
2143             font_link->fs.fsCsb[1] |= face->fs.fsCsb[1];
2144             TRACE("Adding file %s index %ld\n", child_font->face->file, child_font->face->face_index);
2145             list_add_tail(&font_link->links, &child_font->entry);
2146
2147             TRACE("added internal SystemLink for %s to %s in %s\n", debugstr_w(name), debugstr_w(value),debugstr_w(fileW));
2148             HeapFree(GetProcessHeap(), 0, fileW);
2149         }
2150     }
2151 }
2152
2153
2154 /*************************************************************
2155  * init_system_links
2156  */
2157 static BOOL init_system_links(void)
2158 {
2159     HKEY hkey;
2160     BOOL ret = FALSE;
2161     DWORD type, max_val, max_data, val_len, data_len, index;
2162     WCHAR *value, *data;
2163     WCHAR *entry, *next;
2164     SYSTEM_LINKS *font_link, *system_font_link;
2165     CHILD_FONT *child_font;
2166     static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
2167     static const WCHAR System[] = {'S','y','s','t','e','m',0};
2168     static const WCHAR MS_Shell_Dlg[] = {'M','S',' ','S','h','e','l','l',' ','D','l','g',0};
2169     Face *face;
2170     FontSubst *psub;
2171     UINT i, j;
2172
2173     if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
2174     {
2175         RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
2176         value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
2177         data = HeapAlloc(GetProcessHeap(), 0, max_data);
2178         val_len = max_val + 1;
2179         data_len = max_data;
2180         index = 0;
2181         while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
2182         {
2183             psub = get_font_subst(&font_subst_list, value, -1);
2184             /* Don't store fonts that are only substitutes for other fonts */
2185             if(psub)
2186             {
2187                 TRACE("%s: SystemLink entry for substituted font, ignoring\n", debugstr_w(value));
2188                 goto next;
2189             }
2190             font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
2191             font_link->font_name = strdupW(value);
2192             memset(&font_link->fs, 0, sizeof font_link->fs);
2193             list_init(&font_link->links);
2194             for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
2195             {
2196                 WCHAR *face_name;
2197                 CHILD_FONT *child_font;
2198
2199                 TRACE("%s: %s\n", debugstr_w(value), debugstr_w(entry));
2200
2201                 next = entry + strlenW(entry) + 1;
2202
2203                 face_name = strchrW(entry, ',');
2204                 if(face_name)
2205                 {
2206                     *face_name++ = 0;
2207                     while(isspaceW(*face_name))
2208                         face_name++;
2209
2210                     psub = get_font_subst(&font_subst_list, face_name, -1);
2211                     if(psub)
2212                         face_name = psub->to.name;
2213                 }
2214                 face = find_face_from_filename(entry, face_name);
2215                 if(!face)
2216                 {
2217                     TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
2218                     continue;
2219                 }
2220
2221                 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2222                 child_font->face = face;
2223                 child_font->font = NULL;
2224                 font_link->fs.fsCsb[0] |= face->fs.fsCsb[0];
2225                 font_link->fs.fsCsb[1] |= face->fs.fsCsb[1];
2226                 TRACE("Adding file %s index %ld\n", child_font->face->file, child_font->face->face_index);
2227                 list_add_tail(&font_link->links, &child_font->entry);
2228             }
2229             list_add_tail(&system_links, &font_link->entry);
2230         next:
2231             val_len = max_val + 1;
2232             data_len = max_data;
2233         }
2234
2235         HeapFree(GetProcessHeap(), 0, value);
2236         HeapFree(GetProcessHeap(), 0, data);
2237         RegCloseKey(hkey);
2238     }
2239
2240
2241     psub = get_font_subst(&font_subst_list, MS_Shell_Dlg, -1);
2242     if (!psub) {
2243         WARN("could not find FontSubstitute for MS Shell Dlg\n");
2244         goto skip_internal;
2245     }
2246
2247     for (i = 0; i < sizeof(font_links_defaults_list)/sizeof(font_links_defaults_list[0]); i++)
2248     {
2249         const FontSubst *psub2;
2250         psub2 = get_font_subst(&font_subst_list, font_links_defaults_list[i].shelldlg, -1);
2251
2252         if ((!strcmpiW(font_links_defaults_list[i].shelldlg, psub->to.name) || (psub2 && !strcmpiW(psub2->to.name,psub->to.name))))
2253         {
2254             for (j = 0; j < sizeof(font_links_list)/sizeof(font_links_list[0]); j++)
2255                 populate_system_links(font_links_list[j], font_links_defaults_list[i].substitutes);
2256
2257             if (!strcmpiW(psub->to.name, font_links_defaults_list[i].substitutes[0]))
2258                 populate_system_links(psub->to.name, font_links_defaults_list[i].substitutes);
2259         }
2260         else if (strcmpiW(psub->to.name, font_links_defaults_list[i].substitutes[0]))
2261         {
2262             populate_system_links(font_links_defaults_list[i].substitutes[0], NULL);
2263         }
2264     }
2265
2266 skip_internal:
2267
2268     /* Explicitly add an entry for the system font, this links to Tahoma and any links
2269        that Tahoma has */
2270
2271     system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
2272     system_font_link->font_name = strdupW(System);
2273     memset(&system_font_link->fs, 0, sizeof system_font_link->fs);
2274     list_init(&system_font_link->links);
2275
2276     face = find_face_from_filename(tahoma_ttf, Tahoma);
2277     if(face)
2278     {
2279         child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
2280         child_font->face = face;
2281         child_font->font = NULL;
2282         system_font_link->fs.fsCsb[0] |= face->fs.fsCsb[0];
2283         system_font_link->fs.fsCsb[1] |= face->fs.fsCsb[1];
2284         TRACE("Found Tahoma in %s index %ld\n", child_font->face->file, child_font->face->face_index);
2285         list_add_tail(&system_font_link->links, &child_font->entry);
2286     }
2287     font_link = find_font_link(Tahoma);
2288     if (font_link != NULL)
2289     {
2290         CHILD_FONT *font_link_entry;
2291         LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2292         {
2293             CHILD_FONT *new_child;
2294             new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
2295             new_child->face = font_link_entry->face;
2296             new_child->font = NULL;
2297             system_font_link->fs.fsCsb[0] |= font_link_entry->face->fs.fsCsb[0];
2298             system_font_link->fs.fsCsb[1] |= font_link_entry->face->fs.fsCsb[1];
2299             list_add_tail(&system_font_link->links, &new_child->entry);
2300         }
2301     }
2302     list_add_tail(&system_links, &system_font_link->entry);
2303     return ret;
2304 }
2305
2306 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
2307 {
2308     DIR *dir;
2309     struct dirent *dent;
2310     char path[MAX_PATH];
2311
2312     TRACE("Loading fonts from %s\n", debugstr_a(dirname));
2313
2314     dir = opendir(dirname);
2315     if(!dir) {
2316         WARN("Can't open directory %s\n", debugstr_a(dirname));
2317         return FALSE;
2318     }
2319     while((dent = readdir(dir)) != NULL) {
2320         struct stat statbuf;
2321
2322         if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
2323             continue;
2324
2325         TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
2326
2327         sprintf(path, "%s/%s", dirname, dent->d_name);
2328
2329         if(stat(path, &statbuf) == -1)
2330         {
2331             WARN("Can't stat %s\n", debugstr_a(path));
2332             continue;
2333         }
2334         if(S_ISDIR(statbuf.st_mode))
2335             ReadFontDir(path, external_fonts);
2336         else
2337         {
2338             DWORD addfont_flags = ADDFONT_ADD_TO_CACHE;
2339             if(external_fonts) addfont_flags |= ADDFONT_EXTERNAL_FONT;
2340             AddFontToList(path, NULL, 0, addfont_flags);
2341         }
2342     }
2343     closedir(dir);
2344     return TRUE;
2345 }
2346
2347 #ifdef SONAME_LIBFONTCONFIG
2348 static void load_fontconfig_fonts(void)
2349 {
2350     void *fc_handle = NULL;
2351     FcConfig *config;
2352     FcPattern *pat;
2353     FcObjectSet *os;
2354     FcFontSet *fontset;
2355     int i, len;
2356     char *file;
2357     const char *ext;
2358
2359     fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
2360     if(!fc_handle) {
2361         TRACE("Wine cannot find the fontconfig library (%s).\n",
2362               SONAME_LIBFONTCONFIG);
2363         return;
2364     }
2365 #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;}
2366 LOAD_FUNCPTR(FcConfigGetCurrent);
2367 LOAD_FUNCPTR(FcFontList);
2368 LOAD_FUNCPTR(FcFontSetDestroy);
2369 LOAD_FUNCPTR(FcInit);
2370 LOAD_FUNCPTR(FcObjectSetAdd);
2371 LOAD_FUNCPTR(FcObjectSetCreate);
2372 LOAD_FUNCPTR(FcObjectSetDestroy);
2373 LOAD_FUNCPTR(FcPatternCreate);
2374 LOAD_FUNCPTR(FcPatternDestroy);
2375 LOAD_FUNCPTR(FcPatternGetBool);
2376 LOAD_FUNCPTR(FcPatternGetString);
2377 #undef LOAD_FUNCPTR
2378
2379     if(!pFcInit()) return;
2380
2381     config = pFcConfigGetCurrent();
2382     pat = pFcPatternCreate();
2383     os = pFcObjectSetCreate();
2384     pFcObjectSetAdd(os, FC_FILE);
2385     pFcObjectSetAdd(os, FC_SCALABLE);
2386     fontset = pFcFontList(config, pat, os);
2387     if(!fontset) return;
2388     for(i = 0; i < fontset->nfont; i++) {
2389         FcBool scalable;
2390
2391         if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
2392             continue;
2393         TRACE("fontconfig: %s\n", file);
2394
2395         /* We're just interested in OT/TT fonts for now, so this hack just
2396            picks up the scalable fonts without extensions .pf[ab] to save time
2397            loading every other font */
2398
2399         if(pFcPatternGetBool(fontset->fonts[i], FC_SCALABLE, 0, &scalable) == FcResultMatch && !scalable)
2400         {
2401             TRACE("not scalable\n");
2402             continue;
2403         }
2404
2405         len = strlen( file );
2406         if(len < 4) continue;
2407         ext = &file[ len - 3 ];
2408         if(strcasecmp(ext, "pfa") && strcasecmp(ext, "pfb"))
2409             AddFontToList(file, NULL, 0, ADDFONT_EXTERNAL_FONT | ADDFONT_ADD_TO_CACHE);
2410     }
2411     pFcFontSetDestroy(fontset);
2412     pFcObjectSetDestroy(os);
2413     pFcPatternDestroy(pat);
2414  sym_not_found:
2415     return;
2416 }
2417
2418 #elif defined(HAVE_CARBON_CARBON_H)
2419
2420 static void load_mac_font_callback(const void *value, void *context)
2421 {
2422     CFStringRef pathStr = value;
2423     CFIndex len;
2424     char* path;
2425
2426     len = CFStringGetMaximumSizeOfFileSystemRepresentation(pathStr);
2427     path = HeapAlloc(GetProcessHeap(), 0, len);
2428     if (path && CFStringGetFileSystemRepresentation(pathStr, path, len))
2429     {
2430         TRACE("font file %s\n", path);
2431         AddFontToList(path, NULL, 0, ADDFONT_EXTERNAL_FONT | ADDFONT_ADD_TO_CACHE);
2432     }
2433     HeapFree(GetProcessHeap(), 0, path);
2434 }
2435
2436 static void load_mac_fonts(void)
2437 {
2438     CFStringRef removeDupesKey;
2439     CFBooleanRef removeDupesValue;
2440     CFDictionaryRef options;
2441     CTFontCollectionRef col;
2442     CFArrayRef descs;
2443     CFMutableSetRef paths;
2444     CFIndex i;
2445
2446     removeDupesKey = kCTFontCollectionRemoveDuplicatesOption;
2447     removeDupesValue = kCFBooleanTrue;
2448     options = CFDictionaryCreate(NULL, (const void**)&removeDupesKey, (const void**)&removeDupesValue, 1,
2449                                  &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
2450     col = CTFontCollectionCreateFromAvailableFonts(options);
2451     if (options) CFRelease(options);
2452     if (!col)
2453     {
2454         WARN("CTFontCollectionCreateFromAvailableFonts failed\n");
2455         return;
2456     }
2457
2458     descs = CTFontCollectionCreateMatchingFontDescriptors(col);
2459     CFRelease(col);
2460     if (!descs)
2461     {
2462         WARN("CTFontCollectionCreateMatchingFontDescriptors failed\n");
2463         return;
2464     }
2465
2466     paths = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
2467     if (!paths)
2468     {
2469         WARN("CFSetCreateMutable failed\n");
2470         CFRelease(descs);
2471         return;
2472     }
2473
2474     for (i = 0; i < CFArrayGetCount(descs); i++)
2475     {
2476         CTFontDescriptorRef desc;
2477         CTFontRef font;
2478         ATSFontRef atsFont;
2479         OSStatus status;
2480         FSRef fsref;
2481         CFURLRef url;
2482         CFStringRef ext;
2483         CFStringRef path;
2484
2485         desc = CFArrayGetValueAtIndex(descs, i);
2486
2487         /* CTFontDescriptor doesn't support kCTFontURLAttribute until 10.6, so
2488            we have to go CFFontDescriptor -> CTFont -> ATSFont -> FSRef -> CFURL. */
2489         font = CTFontCreateWithFontDescriptor(desc, 0, NULL);
2490         if (!font) continue;
2491
2492         atsFont = CTFontGetPlatformFont(font, NULL);
2493         if (!atsFont)
2494         {
2495             CFRelease(font);
2496             continue;
2497         }
2498
2499         status = ATSFontGetFileReference(atsFont, &fsref);
2500         CFRelease(font);
2501         if (status != noErr) continue;
2502
2503         url = CFURLCreateFromFSRef(NULL, &fsref);
2504         if (!url) continue;
2505
2506         ext = CFURLCopyPathExtension(url);
2507         if (ext)
2508         {
2509             BOOL skip = (CFStringCompare(ext, CFSTR("pfa"), kCFCompareCaseInsensitive) == kCFCompareEqualTo ||
2510                          CFStringCompare(ext, CFSTR("pfb"), kCFCompareCaseInsensitive) == kCFCompareEqualTo);
2511             CFRelease(ext);
2512             if (skip)
2513             {
2514                 CFRelease(url);
2515                 continue;
2516             }
2517         }
2518
2519         path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
2520         CFRelease(url);
2521         if (!path) continue;
2522
2523         CFSetAddValue(paths, path);
2524         CFRelease(path);
2525     }
2526
2527     CFRelease(descs);
2528
2529     CFSetApplyFunction(paths, load_mac_font_callback, NULL);
2530     CFRelease(paths);
2531 }
2532
2533 #endif
2534
2535 static BOOL load_font_from_data_dir(LPCWSTR file)
2536 {
2537     BOOL ret = FALSE;
2538     const char *data_dir = wine_get_data_dir();
2539
2540     if (!data_dir) data_dir = wine_get_build_dir();
2541
2542     if (data_dir)
2543     {
2544         INT len;
2545         char *unix_name;
2546
2547         len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
2548
2549         unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
2550
2551         strcpy(unix_name, data_dir);
2552         strcat(unix_name, "/fonts/");
2553
2554         WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
2555
2556         EnterCriticalSection( &freetype_cs );
2557         ret = AddFontToList(unix_name, NULL, 0, ADDFONT_FORCE_BITMAP | ADDFONT_ADD_TO_CACHE);
2558         LeaveCriticalSection( &freetype_cs );
2559         HeapFree(GetProcessHeap(), 0, unix_name);
2560     }
2561     return ret;
2562 }
2563
2564 static BOOL load_font_from_winfonts_dir(LPCWSTR file)
2565 {
2566     static const WCHAR slashW[] = {'\\','\0'};
2567     BOOL ret = FALSE;
2568     WCHAR windowsdir[MAX_PATH];
2569     char *unixname;
2570
2571     GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2572     strcatW(windowsdir, fontsW);
2573     strcatW(windowsdir, slashW);
2574     strcatW(windowsdir, file);
2575     if ((unixname = wine_get_unix_file_name(windowsdir))) {
2576         EnterCriticalSection( &freetype_cs );
2577         ret = AddFontToList(unixname, NULL, 0, ADDFONT_FORCE_BITMAP);
2578         LeaveCriticalSection( &freetype_cs );
2579         HeapFree(GetProcessHeap(), 0, unixname);
2580     }
2581     return ret;
2582 }
2583
2584 static void load_system_fonts(void)
2585 {
2586     HKEY hkey;
2587     WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
2588     const WCHAR * const *value;
2589     DWORD dlen, type;
2590     static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
2591     char *unixname;
2592
2593     if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
2594         GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2595         strcatW(windowsdir, fontsW);
2596         for(value = SystemFontValues; *value; value++) {
2597             dlen = sizeof(data);
2598             if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
2599                type == REG_SZ) {
2600                 BOOL added = FALSE;
2601
2602                 sprintfW(pathW, fmtW, windowsdir, data);
2603                 if((unixname = wine_get_unix_file_name(pathW))) {
2604                     added = AddFontToList(unixname, NULL, 0, ADDFONT_FORCE_BITMAP | ADDFONT_ADD_TO_CACHE);
2605                     HeapFree(GetProcessHeap(), 0, unixname);
2606                 }
2607                 if (!added)
2608                     load_font_from_data_dir(data);
2609             }
2610         }
2611         RegCloseKey(hkey);
2612     }
2613 }
2614
2615 /*************************************************************
2616  *
2617  * This adds registry entries for any externally loaded fonts
2618  * (fonts from fontconfig or FontDirs).  It also deletes entries
2619  * of no longer existing fonts.
2620  *
2621  */
2622 static void update_reg_entries(void)
2623 {
2624     HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
2625     LPWSTR valueW;
2626     DWORD len, len_fam;
2627     Family *family;
2628     Face *face;
2629     struct list *family_elem_ptr, *face_elem_ptr;
2630     WCHAR *file;
2631     static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
2632     static const WCHAR spaceW[] = {' ', '\0'};
2633     char *path;
2634
2635     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
2636                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
2637         ERR("Can't create Windows font reg key\n");
2638         goto end;
2639     }
2640
2641     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
2642                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
2643         ERR("Can't create Windows font reg key\n");
2644         goto end;
2645     }
2646
2647     if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
2648                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &external_key, NULL) != ERROR_SUCCESS) {
2649         ERR("Can't create external font reg key\n");
2650         goto end;
2651     }
2652
2653     /* enumerate the fonts and add external ones to the two keys */
2654
2655     LIST_FOR_EACH(family_elem_ptr, &font_list) {
2656         family = LIST_ENTRY(family_elem_ptr, Family, entry);
2657         len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
2658         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2659             face = LIST_ENTRY(face_elem_ptr, Face, entry);
2660             if(!face->external) continue;
2661             len = len_fam;
2662             if (!(face->ntmFlags & NTM_REGULAR))
2663                 len = len_fam + strlenW(face->StyleName) + 1;
2664             valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2665             strcpyW(valueW, family->FamilyName);
2666             if(len != len_fam) {
2667                 strcatW(valueW, spaceW);
2668                 strcatW(valueW, face->StyleName);
2669             }
2670             strcatW(valueW, TrueType);
2671
2672             file = wine_get_dos_file_name(face->file);
2673             if(file)
2674                 len = strlenW(file) + 1;
2675             else
2676             {
2677                 if((path = strrchr(face->file, '/')) == NULL)
2678                     path = face->file;
2679                 else
2680                     path++;
2681                 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
2682
2683                 file = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2684                 MultiByteToWideChar(CP_ACP, 0, path, -1, file, len);
2685             }
2686             RegSetValueExW(winnt_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2687             RegSetValueExW(win9x_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2688             RegSetValueExW(external_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2689
2690             HeapFree(GetProcessHeap(), 0, file);
2691             HeapFree(GetProcessHeap(), 0, valueW);
2692         }
2693     }
2694  end:
2695     if(external_key) RegCloseKey(external_key);
2696     if(win9x_key) RegCloseKey(win9x_key);
2697     if(winnt_key) RegCloseKey(winnt_key);
2698     return;
2699 }
2700
2701 static void delete_external_font_keys(void)
2702 {
2703     HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
2704     DWORD dlen, vlen, datalen, valuelen, i, type;
2705     LPWSTR valueW;
2706     LPVOID data;
2707
2708     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
2709                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
2710         ERR("Can't create Windows font reg key\n");
2711         goto end;
2712     }
2713
2714     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
2715                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
2716         ERR("Can't create Windows font reg key\n");
2717         goto end;
2718     }
2719
2720     if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &external_key) != ERROR_SUCCESS) {
2721         ERR("Can't create external font reg key\n");
2722         goto end;
2723     }
2724
2725     /* Delete all external fonts added last time */
2726
2727     RegQueryInfoKeyW(external_key, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2728                      &valuelen, &datalen, NULL, NULL);
2729     valuelen++; /* returned value doesn't include room for '\0' */
2730     valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2731     data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
2732
2733     dlen = datalen * sizeof(WCHAR);
2734     vlen = valuelen;
2735     i = 0;
2736     while(RegEnumValueW(external_key, i++, valueW, &vlen, NULL, &type, data,
2737                         &dlen) == ERROR_SUCCESS) {
2738
2739         RegDeleteValueW(winnt_key, valueW);
2740         RegDeleteValueW(win9x_key, valueW);
2741         /* reset dlen and vlen */
2742         dlen = datalen;
2743         vlen = valuelen;
2744     }
2745     HeapFree(GetProcessHeap(), 0, data);
2746     HeapFree(GetProcessHeap(), 0, valueW);
2747
2748     /* Delete the old external fonts key */
2749     RegCloseKey(external_key);
2750     RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
2751
2752  end:
2753     if(win9x_key) RegCloseKey(win9x_key);
2754     if(winnt_key) RegCloseKey(winnt_key);
2755 }
2756
2757 /*************************************************************
2758  *    WineEngAddFontResourceEx
2759  *
2760  */
2761 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2762 {
2763     INT ret = 0;
2764
2765     GDI_CheckNotLock();
2766
2767     if (ft_handle)  /* do it only if we have freetype up and running */
2768     {
2769         char *unixname;
2770
2771         if(flags)
2772             FIXME("Ignoring flags %x\n", flags);
2773
2774         if((unixname = wine_get_unix_file_name(file)))
2775         {
2776             DWORD addfont_flags = ADDFONT_FORCE_BITMAP;
2777
2778             if(!(flags & FR_PRIVATE)) addfont_flags |= ADDFONT_ADD_TO_CACHE;
2779             EnterCriticalSection( &freetype_cs );
2780             ret = AddFontToList(unixname, NULL, 0, addfont_flags);
2781             LeaveCriticalSection( &freetype_cs );
2782             HeapFree(GetProcessHeap(), 0, unixname);
2783         }
2784         if (!ret && !strchrW(file, '\\')) {
2785             /* Try in %WINDIR%/fonts, needed for Fotobuch Designer */
2786             ret = load_font_from_winfonts_dir(file);
2787             if (!ret) {
2788                 /* Try in datadir/fonts (or builddir/fonts),
2789                  * needed for Magic the Gathering Online
2790                  */
2791                 ret = load_font_from_data_dir(file);
2792             }
2793         }
2794     }
2795    return ret;
2796 }
2797
2798 /*************************************************************
2799  *    WineEngAddFontMemResourceEx
2800  *
2801  */
2802 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
2803 {
2804     GDI_CheckNotLock();
2805
2806     if (ft_handle)  /* do it only if we have freetype up and running */
2807     {
2808         PVOID pFontCopy = HeapAlloc(GetProcessHeap(), 0, cbFont);
2809
2810         TRACE("Copying %d bytes of data from %p to %p\n", cbFont, pbFont, pFontCopy);
2811         memcpy(pFontCopy, pbFont, cbFont);
2812
2813         EnterCriticalSection( &freetype_cs );
2814         *pcFonts = AddFontToList(NULL, pFontCopy, cbFont, ADDFONT_FORCE_BITMAP);
2815         LeaveCriticalSection( &freetype_cs );
2816
2817         if (*pcFonts == 0)
2818         {
2819             TRACE("AddFontToList failed\n");
2820             HeapFree(GetProcessHeap(), 0, pFontCopy);
2821             return 0;
2822         }
2823         /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
2824          * For now return something unique but quite random
2825          */
2826         TRACE("Returning handle %lx\n", ((INT_PTR)pFontCopy)^0x87654321);
2827         return (HANDLE)(((INT_PTR)pFontCopy)^0x87654321);
2828     }
2829
2830     *pcFonts = 0;
2831     return 0;
2832 }
2833
2834 /*************************************************************
2835  *    WineEngRemoveFontResourceEx
2836  *
2837  */
2838 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2839 {
2840     GDI_CheckNotLock();
2841     FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
2842     return TRUE;
2843 }
2844
2845 static char *get_ttf_file_name( LPCWSTR font_file, LPCWSTR font_path )
2846 {
2847     WCHAR *fullname;
2848     char *unix_name;
2849     int file_len;
2850
2851     if (!font_file) return NULL;
2852
2853     file_len = strlenW( font_file );
2854
2855     if (font_path && font_path[0])
2856     {
2857         int path_len = strlenW( font_path );
2858         fullname = HeapAlloc( GetProcessHeap(), 0, (file_len + path_len + 2) * sizeof(WCHAR) );
2859         if (!fullname) return NULL;
2860         memcpy( fullname, font_path, path_len * sizeof(WCHAR) );
2861         fullname[path_len] = '\\';
2862         memcpy( fullname + path_len + 1, font_file, (file_len + 1) * sizeof(WCHAR) );
2863     }
2864     else
2865     {
2866         int len = GetFullPathNameW( font_file, 0, NULL, NULL );
2867         if (!len) return NULL;
2868         fullname = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
2869         if (!fullname) return NULL;
2870         GetFullPathNameW( font_file, len, fullname, NULL );
2871     }
2872
2873     unix_name = wine_get_unix_file_name( fullname );
2874     HeapFree( GetProcessHeap(), 0, fullname );
2875     return unix_name;
2876 }
2877
2878 #include <pshpack1.h>
2879 struct fontdir
2880 {
2881     WORD   num_of_resources;
2882     WORD   res_id;
2883     WORD   dfVersion;
2884     DWORD  dfSize;
2885     CHAR   dfCopyright[60];
2886     WORD   dfType;
2887     WORD   dfPoints;
2888     WORD   dfVertRes;
2889     WORD   dfHorizRes;
2890     WORD   dfAscent;
2891     WORD   dfInternalLeading;
2892     WORD   dfExternalLeading;
2893     BYTE   dfItalic;
2894     BYTE   dfUnderline;
2895     BYTE   dfStrikeOut;
2896     WORD   dfWeight;
2897     BYTE   dfCharSet;
2898     WORD   dfPixWidth;
2899     WORD   dfPixHeight;
2900     BYTE   dfPitchAndFamily;
2901     WORD   dfAvgWidth;
2902     WORD   dfMaxWidth;
2903     BYTE   dfFirstChar;
2904     BYTE   dfLastChar;
2905     BYTE   dfDefaultChar;
2906     BYTE   dfBreakChar;
2907     WORD   dfWidthBytes;
2908     DWORD  dfDevice;
2909     DWORD  dfFace;
2910     DWORD  dfReserved;
2911     CHAR   szFaceName[LF_FACESIZE];
2912 };
2913
2914 #include <poppack.h>
2915
2916 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
2917                            NEWTEXTMETRICEXW *pntm, LPDWORD ptype);
2918
2919 static BOOL get_fontdir( const char *unix_name, struct fontdir *fd )
2920 {
2921     FT_Face ft_face = new_ft_face( unix_name, NULL, 0, 0, FALSE );
2922     Face *face;
2923     Family *family;
2924     WCHAR *name, *english_name;
2925     ENUMLOGFONTEXW elf;
2926     NEWTEXTMETRICEXW ntm;
2927     DWORD type;
2928
2929     if (!ft_face) return FALSE;
2930     face = create_face( ft_face, 0, unix_name, NULL, 0, 0, FALSE );
2931     get_family_names( ft_face, &name, &english_name, FALSE );
2932     family = create_family( name, english_name );
2933     insert_face_in_family_list( face, family );
2934     pFT_Done_Face( ft_face );
2935
2936     GetEnumStructs( face, &elf, &ntm, &type );
2937     free_family( family );
2938
2939     if ((type & TRUETYPE_FONTTYPE) == 0) return FALSE;
2940
2941     memset( fd, 0, sizeof(*fd) );
2942
2943     fd->num_of_resources  = 1;
2944     fd->res_id            = 0;
2945     fd->dfVersion         = 0x200;
2946     fd->dfSize            = sizeof(*fd);
2947     strcpy( fd->dfCopyright, "Wine fontdir" );
2948     fd->dfType            = 0x4003;  /* 0x0080 set if private */
2949     fd->dfPoints          = ntm.ntmTm.ntmSizeEM;
2950     fd->dfVertRes         = 72;
2951     fd->dfHorizRes        = 72;
2952     fd->dfAscent          = ntm.ntmTm.tmAscent;
2953     fd->dfInternalLeading = ntm.ntmTm.tmInternalLeading;
2954     fd->dfExternalLeading = ntm.ntmTm.tmExternalLeading;
2955     fd->dfItalic          = ntm.ntmTm.tmItalic;
2956     fd->dfUnderline       = ntm.ntmTm.tmUnderlined;
2957     fd->dfStrikeOut       = ntm.ntmTm.tmStruckOut;
2958     fd->dfWeight          = ntm.ntmTm.tmWeight;
2959     fd->dfCharSet         = ntm.ntmTm.tmCharSet;
2960     fd->dfPixWidth        = 0;
2961     fd->dfPixHeight       = ntm.ntmTm.tmHeight;
2962     fd->dfPitchAndFamily  = ntm.ntmTm.tmPitchAndFamily;
2963     fd->dfAvgWidth        = ntm.ntmTm.tmAveCharWidth;
2964     fd->dfMaxWidth        = ntm.ntmTm.tmMaxCharWidth;
2965     fd->dfFirstChar       = ntm.ntmTm.tmFirstChar;
2966     fd->dfLastChar        = ntm.ntmTm.tmLastChar;
2967     fd->dfDefaultChar     = ntm.ntmTm.tmDefaultChar;
2968     fd->dfBreakChar       = ntm.ntmTm.tmBreakChar;
2969     fd->dfWidthBytes      = 0;
2970     fd->dfDevice          = 0;
2971     fd->dfFace            = FIELD_OFFSET( struct fontdir, szFaceName );
2972     fd->dfReserved        = 0;
2973     WideCharToMultiByte( CP_ACP, 0, elf.elfLogFont.lfFaceName, -1, fd->szFaceName, LF_FACESIZE, NULL, NULL );
2974
2975     return TRUE;
2976 }
2977
2978 #define NE_FFLAGS_LIBMODULE     0x8000
2979 #define NE_OSFLAGS_WINDOWS      0x02
2980
2981 static const char dos_string[0x40] = "This is a TrueType resource file";
2982 static const char FONTRES[] = {'F','O','N','T','R','E','S',':'};
2983
2984 #include <pshpack2.h>
2985
2986 struct ne_typeinfo
2987 {
2988     WORD type_id;
2989     WORD count;
2990     DWORD res;
2991 };
2992
2993 struct ne_nameinfo
2994 {
2995     WORD off;
2996     WORD len;
2997     WORD flags;
2998     WORD id;
2999     DWORD res;
3000 };
3001
3002 struct rsrc_tab
3003 {
3004     WORD align;
3005     struct ne_typeinfo fontdir_type;
3006     struct ne_nameinfo fontdir_name;
3007     struct ne_typeinfo scalable_type;
3008     struct ne_nameinfo scalable_name;
3009     WORD end_of_rsrc;
3010     BYTE fontdir_res_name[8];
3011 };
3012
3013 #include <poppack.h>
3014
3015 static BOOL create_fot( const WCHAR *resource, const WCHAR *font_file, const struct fontdir *fontdir )
3016 {
3017     BOOL ret = FALSE;
3018     HANDLE file;
3019     DWORD size, written;
3020     BYTE *ptr, *start;
3021     BYTE import_name_len, res_name_len, non_res_name_len, font_file_len;
3022     char *font_fileA, *last_part, *ext;
3023     IMAGE_DOS_HEADER dos;
3024     IMAGE_OS2_HEADER ne =
3025     {
3026         IMAGE_OS2_SIGNATURE, 5, 1, 0, 0, 0, NE_FFLAGS_LIBMODULE, 0,
3027         0, 0, 0, 0, 0, 0,
3028         0, sizeof(ne), sizeof(ne), 0, 0, 0, 0,
3029         0, 4, 2, NE_OSFLAGS_WINDOWS, 0, 0, 0, 0, 0x300
3030     };
3031     struct rsrc_tab rsrc_tab =
3032     {
3033         4,
3034         { 0x8007, 1, 0 },
3035         { 0, 0, 0x0c50, 0x2c, 0 },
3036         { 0x80cc, 1, 0 },
3037         { 0, 0, 0x0c50, 0x8001, 0 },
3038         0,
3039         { 7,'F','O','N','T','D','I','R'}
3040     };
3041
3042     memset( &dos, 0, sizeof(dos) );
3043     dos.e_magic = IMAGE_DOS_SIGNATURE;
3044     dos.e_lfanew = sizeof(dos) + sizeof(dos_string);
3045
3046     /* import name is last part\0, resident name is last part without extension
3047        non-resident name is "FONTRES:" + lfFaceName */
3048
3049     font_file_len = WideCharToMultiByte( CP_ACP, 0, font_file, -1, NULL, 0, NULL, NULL );
3050     font_fileA = HeapAlloc( GetProcessHeap(), 0, font_file_len );
3051     WideCharToMultiByte( CP_ACP, 0, font_file, -1, font_fileA, font_file_len, NULL, NULL );
3052
3053     last_part = strrchr( font_fileA, '\\' );
3054     if (last_part) last_part++;
3055     else last_part = font_fileA;
3056     import_name_len = strlen( last_part ) + 1;
3057
3058     ext = strchr( last_part, '.' );
3059     if (ext) res_name_len = ext - last_part;
3060     else res_name_len = import_name_len - 1;
3061
3062     non_res_name_len = sizeof( FONTRES ) + strlen( fontdir->szFaceName );
3063
3064     ne.ne_cbnrestab = 1 + non_res_name_len + 2 + 1; /* len + string + (WORD) ord_num + 1 byte eod */
3065     ne.ne_restab = ne.ne_rsrctab + sizeof(rsrc_tab);
3066     ne.ne_modtab = ne.ne_imptab = ne.ne_restab + 1 + res_name_len + 2 + 3; /* len + string + (WORD) ord_num + 3 bytes eod */
3067     ne.ne_enttab = ne.ne_imptab + 1 + import_name_len; /* len + string */
3068     ne.ne_cbenttab = 2;
3069     ne.ne_nrestab = ne.ne_enttab + ne.ne_cbenttab + 2 + dos.e_lfanew; /* there are 2 bytes of 0 after entry tab */
3070
3071     rsrc_tab.scalable_name.off = (ne.ne_nrestab + ne.ne_cbnrestab + 0xf) >> 4;
3072     rsrc_tab.scalable_name.len = (font_file_len + 0xf) >> 4;
3073     rsrc_tab.fontdir_name.off  = rsrc_tab.scalable_name.off + rsrc_tab.scalable_name.len;
3074     rsrc_tab.fontdir_name.len  = (fontdir->dfSize + 0xf) >> 4;
3075
3076     size = (rsrc_tab.fontdir_name.off + rsrc_tab.fontdir_name.len) << 4;
3077     start = ptr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
3078
3079     if (!ptr)
3080     {
3081         HeapFree( GetProcessHeap(), 0, font_fileA );
3082         return FALSE;
3083     }
3084
3085     memcpy( ptr, &dos, sizeof(dos) );
3086     memcpy( ptr + sizeof(dos), dos_string, sizeof(dos_string) );
3087     memcpy( ptr + dos.e_lfanew, &ne, sizeof(ne) );
3088
3089     ptr = start + dos.e_lfanew + ne.ne_rsrctab;
3090     memcpy( ptr, &rsrc_tab, sizeof(rsrc_tab) );
3091
3092     ptr = start + dos.e_lfanew + ne.ne_restab;
3093     *ptr++ = res_name_len;
3094     memcpy( ptr, last_part, res_name_len );
3095
3096     ptr = start + dos.e_lfanew + ne.ne_imptab;
3097     *ptr++ = import_name_len;
3098     memcpy( ptr, last_part, import_name_len );
3099
3100     ptr = start + ne.ne_nrestab;
3101     *ptr++ = non_res_name_len;
3102     memcpy( ptr, FONTRES, sizeof(FONTRES) );
3103     memcpy( ptr + sizeof(FONTRES), fontdir->szFaceName, strlen( fontdir->szFaceName ) );
3104
3105     ptr = start + (rsrc_tab.scalable_name.off << 4);
3106     memcpy( ptr, font_fileA, font_file_len );
3107
3108     ptr = start + (rsrc_tab.fontdir_name.off << 4);
3109     memcpy( ptr, fontdir, fontdir->dfSize );
3110
3111     file = CreateFileW( resource, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL );
3112     if (file != INVALID_HANDLE_VALUE)
3113     {
3114         if (WriteFile( file, start, size, &written, NULL ) && written == size)
3115             ret = TRUE;
3116         CloseHandle( file );
3117     }
3118
3119     HeapFree( GetProcessHeap(), 0, start );
3120     HeapFree( GetProcessHeap(), 0, font_fileA );
3121
3122     return ret;
3123 }
3124
3125 /*************************************************************
3126  *    WineEngCreateScalableFontResource
3127  *
3128  */
3129 BOOL WineEngCreateScalableFontResource( DWORD hidden, LPCWSTR resource,
3130                                         LPCWSTR font_file, LPCWSTR font_path )
3131 {
3132     char *unix_name = get_ttf_file_name( font_file, font_path );
3133     struct fontdir fontdir;
3134     BOOL ret = FALSE;
3135
3136     if (!unix_name || !get_fontdir( unix_name, &fontdir ))
3137         SetLastError( ERROR_INVALID_PARAMETER );
3138     else
3139     {
3140         if (hidden) fontdir.dfType |= 0x80;
3141         ret = create_fot( resource, font_file, &fontdir );
3142     }
3143
3144     HeapFree( GetProcessHeap(), 0, unix_name );
3145     return ret;
3146 }
3147
3148 static const struct nls_update_font_list
3149 {
3150     UINT ansi_cp, oem_cp;
3151     const char *oem, *fixed, *system;
3152     const char *courier, *serif, *small, *sserif;
3153     /* these are for font substitutes */
3154     const char *shelldlg, *tmsrmn;
3155     const char *fixed_0, *system_0, *courier_0, *serif_0, *small_0, *sserif_0,
3156                *helv_0, *tmsrmn_0;
3157     const struct subst
3158     {
3159         const char *from, *to;
3160     } arial_0, courier_new_0, times_new_roman_0;
3161 } nls_update_font_list[] =
3162 {
3163     /* Latin 1 (United States) */
3164     { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
3165       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
3166       "Tahoma","Times New Roman",
3167       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3168       { 0 }, { 0 }, { 0 }
3169     },
3170     /* Latin 1 (Multilingual) */
3171     { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
3172       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
3173       "Tahoma","Times New Roman",  /* FIXME unverified */
3174       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3175       { 0 }, { 0 }, { 0 }
3176     },
3177     /* Eastern Europe */
3178     { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
3179       "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
3180       "Tahoma","Times New Roman", /* FIXME unverified */
3181       "Fixedsys,238", "System,238",
3182       "Courier New,238", "MS Serif,238", "Small Fonts,238",
3183       "MS Sans Serif,238", "MS Sans Serif,238", "MS Serif,238",
3184       { "Arial CE,0", "Arial,238" },
3185       { "Courier New CE,0", "Courier New,238" },
3186       { "Times New Roman CE,0", "Times New Roman,238" }
3187     },
3188     /* Cyrillic */
3189     { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
3190       "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
3191       "Tahoma","Times New Roman", /* FIXME unverified */
3192       "Fixedsys,204", "System,204",
3193       "Courier New,204", "MS Serif,204", "Small Fonts,204",
3194       "MS Sans Serif,204", "MS Sans Serif,204", "MS Serif,204",
3195       { "Arial Cyr,0", "Arial,204" },
3196       { "Courier New Cyr,0", "Courier New,204" },
3197       { "Times New Roman Cyr,0", "Times New Roman,204" }
3198     },
3199     /* Greek */
3200     { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
3201       "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
3202       "Tahoma","Times New Roman", /* FIXME unverified */
3203       "Fixedsys,161", "System,161",
3204       "Courier New,161", "MS Serif,161", "Small Fonts,161",
3205       "MS Sans Serif,161", "MS Sans Serif,161", "MS Serif,161",
3206       { "Arial Greek,0", "Arial,161" },
3207       { "Courier New Greek,0", "Courier New,161" },
3208       { "Times New Roman Greek,0", "Times New Roman,161" }
3209     },
3210     /* Turkish */
3211     { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
3212       "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
3213       "Tahoma","Times New Roman", /* FIXME unverified */
3214       "Fixedsys,162", "System,162",
3215       "Courier New,162", "MS Serif,162", "Small Fonts,162",
3216       "MS Sans Serif,162", "MS Sans Serif,162", "MS Serif,162",
3217       { "Arial Tur,0", "Arial,162" },
3218       { "Courier New Tur,0", "Courier New,162" },
3219       { "Times New Roman Tur,0", "Times New Roman,162" }
3220     },
3221     /* Hebrew */
3222     { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
3223       "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
3224       "Tahoma","Times New Roman", /* FIXME unverified */
3225       "Fixedsys,177", "System,177",
3226       "Courier New,177", "MS Serif,177", "Small Fonts,177",
3227       "MS Sans Serif,177", "MS Sans Serif,177", "MS Serif,177",
3228       { 0 }, { 0 }, { 0 }
3229     },
3230     /* Arabic */
3231     { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
3232       "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
3233       "Tahoma","Times New Roman", /* FIXME unverified */
3234       "Fixedsys,178", "System,178",
3235       "Courier New,178", "MS Serif,178", "Small Fonts,178",
3236       "MS Sans Serif,178", "MS Sans Serif,178", "MS Serif,178",
3237       { 0 }, { 0 }, { 0 }
3238     },
3239     /* Baltic */
3240     { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
3241       "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
3242       "Tahoma","Times New Roman", /* FIXME unverified */
3243       "Fixedsys,186", "System,186",
3244       "Courier New,186", "MS Serif,186", "Small Fonts,186",
3245       "MS Sans Serif,186", "MS Sans Serif,186", "MS Serif,186",
3246       { "Arial Baltic,0", "Arial,186" },
3247       { "Courier New Baltic,0", "Courier New,186" },
3248       { "Times New Roman Baltic,0", "Times New Roman,186" }
3249     },
3250     /* Vietnamese */
3251     { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
3252       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
3253       "Tahoma","Times New Roman", /* FIXME unverified */
3254       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3255       { 0 }, { 0 }, { 0 }
3256     },
3257     /* Thai */
3258     { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
3259       "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
3260       "Tahoma","Times New Roman", /* FIXME unverified */
3261       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3262       { 0 }, { 0 }, { 0 }
3263     },
3264     /* Japanese */
3265     { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
3266       "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
3267       "MS UI Gothic","MS Serif",
3268       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3269       { 0 }, { 0 }, { 0 }
3270     },
3271     /* Chinese Simplified */
3272     { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
3273       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
3274       "SimSun", "NSimSun",
3275       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3276       { 0 }, { 0 }, { 0 }
3277     },
3278     /* Korean */
3279     { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
3280       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
3281       "Gulim",  "Batang",
3282       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3283       { 0 }, { 0 }, { 0 }
3284     },
3285     /* Chinese Traditional */
3286     { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
3287       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
3288       "PMingLiU",  "MingLiU",
3289       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3290       { 0 }, { 0 }, { 0 }
3291     }
3292 };
3293
3294 static inline BOOL is_dbcs_ansi_cp(UINT ansi_cp)
3295 {
3296     return ( ansi_cp == 932       /* CP932 for Japanese */
3297             || ansi_cp == 936     /* CP936 for Chinese Simplified */
3298             || ansi_cp == 949     /* CP949 for Korean */
3299             || ansi_cp == 950 );  /* CP950 for Chinese Traditional */
3300 }
3301
3302 static inline HKEY create_fonts_NT_registry_key(void)
3303 {
3304     HKEY hkey = 0;
3305
3306     RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
3307                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
3308     return hkey;
3309 }
3310
3311 static inline HKEY create_fonts_9x_registry_key(void)
3312 {
3313     HKEY hkey = 0;
3314
3315     RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
3316                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
3317     return hkey;
3318 }
3319
3320 static inline HKEY create_config_fonts_registry_key(void)
3321 {
3322     HKEY hkey = 0;
3323
3324     RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
3325                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
3326     return hkey;
3327 }
3328
3329 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl)
3330 {
3331     RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
3332     RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
3333     RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)fl->sserif, strlen(fl->sserif)+1);
3334     RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
3335 }
3336
3337 static void set_value_key(HKEY hkey, const char *name, const char *value)
3338 {
3339     if (value)
3340         RegSetValueExA(hkey, name, 0, REG_SZ, (const BYTE *)value, strlen(value) + 1);
3341     else if (name)
3342         RegDeleteValueA(hkey, name);
3343 }
3344
3345 static void update_font_info(void)
3346 {
3347     char buf[40], cpbuf[40];
3348     DWORD len, type;
3349     HKEY hkey = 0;
3350     UINT i, ansi_cp = 0, oem_cp = 0;
3351     BOOL done = FALSE;
3352
3353     if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL) != ERROR_SUCCESS)
3354         return;
3355
3356     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
3357                    (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
3358     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
3359                    (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
3360     sprintf( cpbuf, "%u,%u", ansi_cp, oem_cp );
3361
3362     /* Setup Default_Fallback usage for DBCS ANSI codepages */
3363     if (is_dbcs_ansi_cp(ansi_cp))
3364         use_default_fallback = TRUE;
3365
3366     len = sizeof(buf);
3367     if (RegQueryValueExA(hkey, "Codepages", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
3368     {
3369         if (!strcmp( buf, cpbuf ))  /* already set correctly */
3370         {
3371             RegCloseKey(hkey);
3372             return;
3373         }
3374         TRACE("updating registry, codepages changed %s -> %u,%u\n", buf, ansi_cp, oem_cp);
3375     }
3376     else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp, oem_cp);
3377
3378     RegSetValueExA(hkey, "Codepages", 0, REG_SZ, (const BYTE *)cpbuf, strlen(cpbuf)+1);
3379     RegCloseKey(hkey);
3380
3381     for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
3382     {
3383         HKEY hkey;
3384
3385         if (nls_update_font_list[i].ansi_cp == ansi_cp &&
3386             nls_update_font_list[i].oem_cp == oem_cp)
3387         {
3388             hkey = create_config_fonts_registry_key();
3389             RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
3390             RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
3391             RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
3392             RegCloseKey(hkey);
3393
3394             hkey = create_fonts_NT_registry_key();
3395             add_font_list(hkey, &nls_update_font_list[i]);
3396             RegCloseKey(hkey);
3397
3398             hkey = create_fonts_9x_registry_key();
3399             add_font_list(hkey, &nls_update_font_list[i]);
3400             RegCloseKey(hkey);
3401
3402             if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
3403             {
3404                 RegSetValueExA(hkey, "MS Shell Dlg", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].shelldlg,
3405                                strlen(nls_update_font_list[i].shelldlg)+1);
3406                 RegSetValueExA(hkey, "Tms Rmn", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].tmsrmn,
3407                                strlen(nls_update_font_list[i].tmsrmn)+1);
3408
3409                 set_value_key(hkey, "Fixedsys,0", nls_update_font_list[i].fixed_0);
3410                 set_value_key(hkey, "System,0", nls_update_font_list[i].system_0);
3411                 set_value_key(hkey, "Courier,0", nls_update_font_list[i].courier_0);
3412                 set_value_key(hkey, "MS Serif,0", nls_update_font_list[i].serif_0);
3413                 set_value_key(hkey, "Small Fonts,0", nls_update_font_list[i].small_0);
3414                 set_value_key(hkey, "MS Sans Serif,0", nls_update_font_list[i].sserif_0);
3415                 set_value_key(hkey, "Helv,0", nls_update_font_list[i].helv_0);
3416                 set_value_key(hkey, "Tms Rmn,0", nls_update_font_list[i].tmsrmn_0);
3417
3418                 set_value_key(hkey, nls_update_font_list[i].arial_0.from, nls_update_font_list[i].arial_0.to);
3419                 set_value_key(hkey, nls_update_font_list[i].courier_new_0.from, nls_update_font_list[i].courier_new_0.to);
3420                 set_value_key(hkey, nls_update_font_list[i].times_new_roman_0.from, nls_update_font_list[i].times_new_roman_0.to);
3421
3422                 RegCloseKey(hkey);
3423             }
3424             done = TRUE;
3425         }
3426         else
3427         {
3428             /* Delete the FontSubstitutes from other locales */
3429             if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
3430             {
3431                 set_value_key(hkey, nls_update_font_list[i].arial_0.from, NULL);
3432                 set_value_key(hkey, nls_update_font_list[i].courier_new_0.from, NULL);
3433                 set_value_key(hkey, nls_update_font_list[i].times_new_roman_0.from, NULL);
3434                 RegCloseKey(hkey);
3435             }
3436         }
3437     }
3438     if (!done)
3439         FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp, oem_cp);
3440 }
3441
3442 static BOOL init_freetype(void)
3443 {
3444     ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
3445     if(!ft_handle) {
3446         WINE_MESSAGE(
3447       "Wine cannot find the FreeType font library.  To enable Wine to\n"
3448       "use TrueType fonts please install a version of FreeType greater than\n"
3449       "or equal to 2.0.5.\n"
3450       "http://www.freetype.org\n");
3451         return FALSE;
3452     }
3453
3454 #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;}
3455
3456     LOAD_FUNCPTR(FT_Done_Face)
3457     LOAD_FUNCPTR(FT_Get_Char_Index)
3458     LOAD_FUNCPTR(FT_Get_First_Char)
3459     LOAD_FUNCPTR(FT_Get_Module)
3460     LOAD_FUNCPTR(FT_Get_Next_Char)
3461     LOAD_FUNCPTR(FT_Get_Sfnt_Name)
3462     LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
3463     LOAD_FUNCPTR(FT_Get_Sfnt_Table)
3464     LOAD_FUNCPTR(FT_Get_WinFNT_Header)
3465     LOAD_FUNCPTR(FT_Init_FreeType)
3466     LOAD_FUNCPTR(FT_Library_Version)
3467     LOAD_FUNCPTR(FT_Load_Glyph)
3468     LOAD_FUNCPTR(FT_Load_Sfnt_Table)
3469     LOAD_FUNCPTR(FT_Matrix_Multiply)
3470 #ifndef FT_MULFIX_INLINED
3471     LOAD_FUNCPTR(FT_MulFix)
3472 #endif
3473     LOAD_FUNCPTR(FT_New_Face)
3474     LOAD_FUNCPTR(FT_New_Memory_Face)
3475     LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
3476     LOAD_FUNCPTR(FT_Outline_Transform)
3477     LOAD_FUNCPTR(FT_Outline_Translate)
3478     LOAD_FUNCPTR(FT_Render_Glyph)
3479     LOAD_FUNCPTR(FT_Select_Charmap)
3480     LOAD_FUNCPTR(FT_Set_Charmap)
3481     LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
3482     LOAD_FUNCPTR(FT_Vector_Transform)
3483     LOAD_FUNCPTR(FT_Vector_Unit)
3484 #undef LOAD_FUNCPTR
3485     /* Don't warn if these ones are missing */
3486     pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
3487 #ifdef HAVE_FREETYPE_FTLCDFIL_H
3488     pFT_Library_SetLcdFilter = wine_dlsym(ft_handle, "FT_Library_SetLcdFilter", NULL, 0);
3489 #endif
3490
3491     if(pFT_Init_FreeType(&library) != 0) {
3492         ERR("Can't init FreeType library\n");
3493         wine_dlclose(ft_handle, NULL, 0);
3494         ft_handle = NULL;
3495         return FALSE;
3496     }
3497     pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
3498
3499     TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
3500     FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
3501                        ((FT_Version.minor <<  8) & 0x00ff00) |
3502                        ((FT_Version.patch      ) & 0x0000ff);
3503
3504     font_driver = &freetype_funcs;
3505     return TRUE;
3506
3507 sym_not_found:
3508     WINE_MESSAGE(
3509       "Wine cannot find certain functions that it needs inside the FreeType\n"
3510       "font library.  To enable Wine to use TrueType fonts please upgrade\n"
3511       "FreeType to at least version 2.1.4.\n"
3512       "http://www.freetype.org\n");
3513     wine_dlclose(ft_handle, NULL, 0);
3514     ft_handle = NULL;
3515     return FALSE;
3516 }
3517
3518 static void init_font_list(void)
3519 {
3520     static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
3521     static const WCHAR pathW[] = {'P','a','t','h',0};
3522     HKEY hkey;
3523     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
3524     WCHAR windowsdir[MAX_PATH];
3525     char *unixname;
3526     const char *data_dir;
3527
3528     delete_external_font_keys();
3529
3530     /* load the system bitmap fonts */
3531     load_system_fonts();
3532
3533     /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
3534     GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
3535     strcatW(windowsdir, fontsW);
3536     if((unixname = wine_get_unix_file_name(windowsdir)))
3537     {
3538         ReadFontDir(unixname, FALSE);
3539         HeapFree(GetProcessHeap(), 0, unixname);
3540     }
3541
3542     /* load the system truetype fonts */
3543     data_dir = wine_get_data_dir();
3544     if (!data_dir) data_dir = wine_get_build_dir();
3545     if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/"))))
3546     {
3547         strcpy(unixname, data_dir);
3548         strcat(unixname, "/fonts/");
3549         ReadFontDir(unixname, TRUE);
3550         HeapFree(GetProcessHeap(), 0, unixname);
3551     }
3552
3553     /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
3554        for any fonts not installed in %WINDOWSDIR%\Fonts.  They will have their
3555        full path as the entry.  Also look for any .fon fonts, since ReadFontDir
3556        will skip these. */
3557     if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
3558                    is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
3559                    &hkey) == ERROR_SUCCESS)
3560     {
3561         LPWSTR data, valueW;
3562         RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3563                          &valuelen, &datalen, NULL, NULL);
3564
3565         valuelen++; /* returned value doesn't include room for '\0' */
3566         valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
3567         data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
3568         if (valueW && data)
3569         {
3570             dlen = datalen * sizeof(WCHAR);
3571             vlen = valuelen;
3572             while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, (LPBYTE)data,
3573                                 &dlen) == ERROR_SUCCESS)
3574             {
3575                 if(data[0] && (data[1] == ':'))
3576                 {
3577                     if((unixname = wine_get_unix_file_name(data)))
3578                     {
3579                         AddFontToList(unixname, NULL, 0, ADDFONT_FORCE_BITMAP | ADDFONT_ADD_TO_CACHE);
3580                         HeapFree(GetProcessHeap(), 0, unixname);
3581                     }
3582                 }
3583                 else if(dlen / 2 >= 6 && !strcmpiW(data + dlen / 2 - 5, dot_fonW))
3584                 {
3585                     WCHAR pathW[MAX_PATH];
3586                     static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
3587                     BOOL added = FALSE;
3588
3589                     sprintfW(pathW, fmtW, windowsdir, data);
3590                     if((unixname = wine_get_unix_file_name(pathW)))
3591                     {
3592                         added = AddFontToList(unixname, NULL, 0, ADDFONT_FORCE_BITMAP | ADDFONT_ADD_TO_CACHE);
3593                         HeapFree(GetProcessHeap(), 0, unixname);
3594                     }
3595                     if (!added)
3596                         load_font_from_data_dir(data);
3597                 }
3598                 /* reset dlen and vlen */
3599                 dlen = datalen;
3600                 vlen = valuelen;
3601             }
3602         }
3603         HeapFree(GetProcessHeap(), 0, data);
3604         HeapFree(GetProcessHeap(), 0, valueW);
3605         RegCloseKey(hkey);
3606     }
3607
3608 #ifdef SONAME_LIBFONTCONFIG
3609     load_fontconfig_fonts();
3610 #elif defined(HAVE_CARBON_CARBON_H)
3611     load_mac_fonts();
3612 #endif
3613
3614     /* then look in any directories that we've specified in the config file */
3615     /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
3616     if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
3617     {
3618         DWORD len;
3619         LPWSTR valueW;
3620         LPSTR valueA, ptr;
3621
3622         if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
3623         {
3624             len += sizeof(WCHAR);
3625             valueW = HeapAlloc( GetProcessHeap(), 0, len );
3626             if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
3627             {
3628                 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
3629                 valueA = HeapAlloc( GetProcessHeap(), 0, len );
3630                 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
3631                 TRACE( "got font path %s\n", debugstr_a(valueA) );
3632                 ptr = valueA;
3633                 while (ptr)
3634                 {
3635                     const char* home;
3636                     LPSTR next = strchr( ptr, ':' );
3637                     if (next) *next++ = 0;
3638                     if (ptr[0] == '~' && ptr[1] == '/' && (home = getenv( "HOME" )) &&
3639                         (unixname = HeapAlloc( GetProcessHeap(), 0, strlen(ptr) + strlen(home) )))
3640                     {
3641                         strcpy( unixname, home );
3642                         strcat( unixname, ptr + 1 );
3643                         ReadFontDir( unixname, TRUE );
3644                         HeapFree( GetProcessHeap(), 0, unixname );
3645                     }
3646                     else
3647                         ReadFontDir( ptr, TRUE );
3648                     ptr = next;
3649                 }
3650                 HeapFree( GetProcessHeap(), 0, valueA );
3651             }
3652             HeapFree( GetProcessHeap(), 0, valueW );
3653         }
3654         RegCloseKey(hkey);
3655     }
3656 }
3657
3658 static BOOL move_to_front(const WCHAR *name)
3659 {
3660     Family *family, *cursor2;
3661     LIST_FOR_EACH_ENTRY_SAFE(family, cursor2, &font_list, Family, entry)
3662     {
3663         if(!strcmpiW(family->FamilyName, name))
3664         {
3665             list_remove(&family->entry);
3666             list_add_head(&font_list, &family->entry);
3667             return TRUE;
3668         }
3669     }
3670     return FALSE;
3671 }
3672
3673 static BOOL set_default(const WCHAR **name_list)
3674 {
3675     while (*name_list)
3676     {
3677         if (move_to_front(*name_list)) return TRUE;
3678         name_list++;
3679     }
3680
3681     return FALSE;
3682 }
3683
3684 static void reorder_font_list(void)
3685 {
3686     set_default( default_serif_list );
3687     set_default( default_fixed_list );
3688     set_default( default_sans_list );
3689 }
3690
3691 /*************************************************************
3692  *    WineEngInit
3693  *
3694  * Initialize FreeType library and create a list of available faces
3695  */
3696 BOOL WineEngInit(void)
3697 {
3698     HKEY hkey_font_cache;
3699     DWORD disposition;
3700     HANDLE font_mutex;
3701
3702     /* update locale dependent font info in registry */
3703     update_font_info();
3704
3705     if(!init_freetype()) return FALSE;
3706
3707     if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL)
3708     {
3709         ERR("Failed to create font mutex\n");
3710         return FALSE;
3711     }
3712     WaitForSingleObject(font_mutex, INFINITE);
3713
3714     create_font_cache_key(&hkey_font_cache, &disposition);
3715
3716     if(disposition == REG_CREATED_NEW_KEY)
3717         init_font_list();
3718     else
3719         load_font_list_from_cache(hkey_font_cache);
3720
3721     RegCloseKey(hkey_font_cache);
3722
3723     reorder_font_list();
3724
3725     DumpFontList();
3726     LoadSubstList();
3727     DumpSubstList();
3728     LoadReplaceList();
3729
3730     if(disposition == REG_CREATED_NEW_KEY)
3731         update_reg_entries();
3732
3733     init_system_links();
3734
3735     ReleaseMutex(font_mutex);
3736     return TRUE;
3737 }
3738
3739
3740 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
3741 {
3742     TT_OS2 *pOS2;
3743     TT_HoriHeader *pHori;
3744
3745     LONG ppem;
3746
3747     pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
3748     pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
3749
3750     if(height == 0) height = 16;
3751
3752     /* Calc. height of EM square:
3753      *
3754      * For +ve lfHeight we have
3755      * lfHeight = (winAscent + winDescent) * ppem / units_per_em
3756      * Re-arranging gives:
3757      * ppem = units_per_em * lfheight / (winAscent + winDescent)
3758      *
3759      * For -ve lfHeight we have
3760      * |lfHeight| = ppem
3761      * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
3762      * with il = winAscent + winDescent - units_per_em]
3763      *
3764      */
3765
3766     if(height > 0) {
3767         if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
3768             ppem = MulDiv(ft_face->units_per_EM, height,
3769                           pHori->Ascender - pHori->Descender);
3770         else
3771             ppem = MulDiv(ft_face->units_per_EM, height,
3772                           pOS2->usWinAscent + pOS2->usWinDescent);
3773     }
3774     else
3775         ppem = -height;
3776
3777     return ppem;
3778 }
3779
3780 static struct font_mapping *map_font_file( const char *name )
3781 {
3782     struct font_mapping *mapping;
3783     struct stat st;
3784     int fd;
3785
3786     if ((fd = open( name, O_RDONLY )) == -1) return NULL;
3787     if (fstat( fd, &st ) == -1) goto error;
3788
3789     LIST_FOR_EACH_ENTRY( mapping, &mappings_list, struct font_mapping, entry )
3790     {
3791         if (mapping->dev == st.st_dev && mapping->ino == st.st_ino)
3792         {
3793             mapping->refcount++;
3794             close( fd );
3795             return mapping;
3796         }
3797     }
3798     if (!(mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping) )))
3799         goto error;
3800
3801     mapping->data = mmap( NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );
3802     close( fd );
3803
3804     if (mapping->data == MAP_FAILED)
3805     {
3806         HeapFree( GetProcessHeap(), 0, mapping );
3807         return NULL;
3808     }
3809     mapping->refcount = 1;
3810     mapping->dev = st.st_dev;
3811     mapping->ino = st.st_ino;
3812     mapping->size = st.st_size;
3813     list_add_tail( &mappings_list, &mapping->entry );
3814     return mapping;
3815
3816 error:
3817     close( fd );
3818     return NULL;
3819 }
3820
3821 static void unmap_font_file( struct font_mapping *mapping )
3822 {
3823     if (!--mapping->refcount)
3824     {
3825         list_remove( &mapping->entry );
3826         munmap( mapping->data, mapping->size );
3827         HeapFree( GetProcessHeap(), 0, mapping );
3828     }
3829 }
3830
3831 static LONG load_VDMX(GdiFont*, LONG);
3832
3833 static FT_Face OpenFontFace(GdiFont *font, Face *face, LONG width, LONG height)
3834 {
3835     FT_Error err;
3836     FT_Face ft_face;
3837     void *data_ptr;
3838     DWORD data_size;
3839
3840     TRACE("%s/%p, %ld, %d x %d\n", debugstr_a(face->file), face->font_data_ptr, face->face_index, width, height);
3841
3842     if (face->file)
3843     {
3844         if (!(font->mapping = map_font_file( face->file )))
3845         {
3846             WARN("failed to map %s\n", debugstr_a(face->file));
3847             return 0;
3848         }
3849         data_ptr = font->mapping->data;
3850         data_size = font->mapping->size;
3851     }
3852     else
3853     {
3854         data_ptr = face->font_data_ptr;
3855         data_size = face->font_data_size;
3856     }
3857
3858     err = pFT_New_Memory_Face(library, data_ptr, data_size, face->face_index, &ft_face);
3859     if(err) {
3860         ERR("FT_New_Face rets %d\n", err);
3861         return 0;
3862     }
3863
3864     /* set it here, as load_VDMX needs it */
3865     font->ft_face = ft_face;
3866
3867     if(FT_IS_SCALABLE(ft_face)) {
3868         /* load the VDMX table if we have one */
3869         font->ppem = load_VDMX(font, height);
3870         if(font->ppem == 0)
3871             font->ppem = calc_ppem_for_height(ft_face, height);
3872         TRACE("height %d => ppem %d\n", height, font->ppem);
3873
3874         if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
3875             WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font->ppem, err);
3876     } else {
3877         font->ppem = height;
3878         if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
3879             WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width, height, err);
3880     }
3881     return ft_face;
3882 }
3883
3884
3885 static int get_nearest_charset(const WCHAR *family_name, Face *face, int *cp)
3886 {
3887   /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
3888      a single face with the requested charset.  The idea is to check if
3889      the selected font supports the current ANSI codepage, if it does
3890      return the corresponding charset, else return the first charset */
3891
3892     CHARSETINFO csi;
3893     int acp = GetACP(), i;
3894     DWORD fs0;
3895
3896     *cp = acp;
3897     if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
3898     {
3899         const SYSTEM_LINKS *font_link;
3900
3901         if (csi.fs.fsCsb[0] & face->fs.fsCsb[0])
3902             return csi.ciCharset;
3903
3904         font_link = find_font_link(family_name);
3905         if (font_link != NULL && csi.fs.fsCsb[0] & font_link->fs.fsCsb[0])
3906             return csi.ciCharset;
3907     }
3908
3909     for(i = 0; i < 32; i++) {
3910         fs0 = 1L << i;
3911         if(face->fs.fsCsb[0] & fs0) {
3912             if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
3913                 *cp = csi.ciACP;
3914                 return csi.ciCharset;
3915             }
3916             else
3917                 FIXME("TCI failing on %x\n", fs0);
3918         }
3919     }
3920
3921     FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
3922           face->fs.fsCsb[0], face->file);
3923     *cp = acp;
3924     return DEFAULT_CHARSET;
3925 }
3926
3927 static GdiFont *alloc_font(void)
3928 {
3929     GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
3930     ret->gmsize = 1;
3931     ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM*));
3932     ret->gm[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
3933     ret->potm = NULL;
3934     ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
3935     ret->total_kern_pairs = (DWORD)-1;
3936     ret->kern_pairs = NULL;
3937     list_init(&ret->hfontlist);
3938     list_init(&ret->child_fonts);
3939     return ret;
3940 }
3941
3942 static void free_font(GdiFont *font)
3943 {
3944     struct list *cursor, *cursor2;
3945     DWORD i;
3946
3947     LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
3948     {
3949         CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
3950         list_remove(cursor);
3951         if(child->font)
3952             free_font(child->font);
3953         HeapFree(GetProcessHeap(), 0, child);
3954     }
3955
3956     LIST_FOR_EACH_SAFE(cursor, cursor2, &font->hfontlist)
3957     {
3958         HFONTLIST *hfontlist = LIST_ENTRY(cursor, HFONTLIST, entry);
3959         DeleteObject(hfontlist->hfont);
3960         list_remove(&hfontlist->entry);
3961         HeapFree(GetProcessHeap(), 0, hfontlist);
3962     }
3963
3964     if (font->ft_face) pFT_Done_Face(font->ft_face);
3965     if (font->mapping) unmap_font_file( font->mapping );
3966     HeapFree(GetProcessHeap(), 0, font->kern_pairs);
3967     HeapFree(GetProcessHeap(), 0, font->potm);
3968     HeapFree(GetProcessHeap(), 0, font->name);
3969     for (i = 0; i < font->gmsize; i++)
3970         HeapFree(GetProcessHeap(),0,font->gm[i]);
3971     HeapFree(GetProcessHeap(), 0, font->gm);
3972     HeapFree(GetProcessHeap(), 0, font->GSUB_Table);
3973     HeapFree(GetProcessHeap(), 0, font);
3974 }
3975
3976
3977 static DWORD get_font_data( GdiFont *font, DWORD table, DWORD offset, LPVOID buf, DWORD cbData)
3978 {
3979     FT_Face ft_face = font->ft_face;
3980     FT_ULong len;
3981     FT_Error err;
3982
3983     if (!FT_IS_SFNT(ft_face)) return GDI_ERROR;
3984
3985     if(!buf)
3986         len = 0;
3987     else
3988         len = cbData;
3989
3990     table = RtlUlongByteSwap( table );  /* MS tags differ in endianness from FT ones */
3991
3992     /* make sure value of len is the value freetype says it needs */
3993     if (buf && len)
3994     {
3995         FT_ULong needed = 0;
3996         err = pFT_Load_Sfnt_Table(ft_face, table, offset, NULL, &needed);
3997         if( !err && needed < len) len = needed;
3998     }
3999     err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, &len);
4000     if (err)
4001     {
4002         TRACE("Can't find table %c%c%c%c\n",
4003               /* bytes were reversed */
4004               HIBYTE(HIWORD(table)), LOBYTE(HIWORD(table)),
4005               HIBYTE(LOWORD(table)), LOBYTE(LOWORD(table)));
4006         return GDI_ERROR;
4007     }
4008     return len;
4009 }
4010
4011 /*************************************************************
4012  * load_VDMX
4013  *
4014  * load the vdmx entry for the specified height
4015  */
4016
4017 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
4018           ( ( (FT_ULong)_x4 << 24 ) |     \
4019             ( (FT_ULong)_x3 << 16 ) |     \
4020             ( (FT_ULong)_x2 <<  8 ) |     \
4021               (FT_ULong)_x1         )
4022
4023 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
4024
4025 typedef struct {
4026     BYTE bCharSet;
4027     BYTE xRatio;
4028     BYTE yStartRatio;
4029     BYTE yEndRatio;
4030 } Ratios;
4031
4032 typedef struct {
4033     WORD recs;
4034     BYTE startsz;
4035     BYTE endsz;
4036 } VDMX_group;
4037
4038 static LONG load_VDMX(GdiFont *font, LONG height)
4039 {
4040     WORD hdr[3], tmp;
4041     VDMX_group group;
4042     BYTE devXRatio, devYRatio;
4043     USHORT numRecs, numRatios;
4044     DWORD result, offset = -1;
4045     LONG ppem = 0;
4046     int i;
4047
4048     result = get_font_data(font, MS_VDMX_TAG, 0, hdr, 6);
4049
4050     if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
4051         return ppem;
4052
4053     /* FIXME: need the real device aspect ratio */
4054     devXRatio = 1;
4055     devYRatio = 1;
4056
4057     numRecs = GET_BE_WORD(hdr[1]);
4058     numRatios = GET_BE_WORD(hdr[2]);
4059
4060     TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
4061     for(i = 0; i < numRatios; i++) {
4062         Ratios ratio;
4063
4064         offset = (3 * 2) + (i * sizeof(Ratios));
4065         get_font_data(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
4066         offset = -1;
4067
4068         TRACE("Ratios[%d] %d  %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
4069
4070         if((ratio.xRatio == 0 &&
4071             ratio.yStartRatio == 0 &&
4072             ratio.yEndRatio == 0) ||
4073            (devXRatio == ratio.xRatio &&
4074             devYRatio >= ratio.yStartRatio &&
4075             devYRatio <= ratio.yEndRatio))
4076             {
4077                 offset = (3 * 2) + (numRatios * 4) + (i * 2);
4078                 get_font_data(font, MS_VDMX_TAG, offset, &tmp, 2);
4079                 offset = GET_BE_WORD(tmp);
4080                 break;
4081             }
4082     }
4083
4084     if(offset == -1) {
4085         FIXME("No suitable ratio found\n");
4086         return ppem;
4087     }
4088
4089     if(get_font_data(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
4090         USHORT recs;
4091         BYTE startsz, endsz;
4092         WORD *vTable;
4093
4094         recs = GET_BE_WORD(group.recs);
4095         startsz = group.startsz;
4096         endsz = group.endsz;
4097
4098         TRACE("recs=%d  startsz=%d  endsz=%d\n", recs, startsz, endsz);
4099
4100         vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
4101         result = get_font_data(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
4102         if(result == GDI_ERROR) {
4103             FIXME("Failed to retrieve vTable\n");
4104             goto end;
4105         }
4106
4107         if(height > 0) {
4108             for(i = 0; i < recs; i++) {
4109                 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
4110                 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
4111                 ppem = GET_BE_WORD(vTable[i * 3]);
4112
4113                 if(yMax + -yMin == height) {
4114                     font->yMax = yMax;
4115                     font->yMin = yMin;
4116                     TRACE("ppem %d found; height=%d  yMax=%d  yMin=%d\n", ppem, height, font->yMax, font->yMin);
4117                     break;
4118                 }
4119                 if(yMax + -yMin > height) {
4120                     if(--i < 0) {
4121                         ppem = 0;
4122                         goto end; /* failed */
4123                     }
4124                     font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
4125                     font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
4126                     ppem = GET_BE_WORD(vTable[i * 3]);
4127                     TRACE("ppem %d found; height=%d  yMax=%d  yMin=%d\n", ppem, height, font->yMax, font->yMin);
4128                     break;
4129                 }
4130             }
4131             if(!font->yMax) {
4132                 ppem = 0;
4133                 TRACE("ppem not found for height %d\n", height);
4134             }
4135         }
4136         end:
4137         HeapFree(GetProcessHeap(), 0, vTable);
4138     }
4139
4140     return ppem;
4141 }
4142
4143 static BOOL fontcmp(const GdiFont *font, FONT_DESC *fd)
4144 {
4145     if(font->font_desc.hash != fd->hash) return TRUE;
4146     if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
4147     if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
4148     if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
4149     return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
4150 }
4151
4152 static void calc_hash(FONT_DESC *pfd)
4153 {
4154     DWORD hash = 0, *ptr, two_chars;
4155     WORD *pwc;
4156     unsigned int i;
4157
4158     for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
4159         hash ^= *ptr;
4160     for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
4161         hash ^= *ptr;
4162     for(i = 0, ptr = (DWORD*)pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
4163         two_chars = *ptr;
4164         pwc = (WCHAR *)&two_chars;
4165         if(!*pwc) break;
4166         *pwc = toupperW(*pwc);
4167         pwc++;
4168         *pwc = toupperW(*pwc);
4169         hash ^= two_chars;
4170         if(!*pwc) break;
4171     }
4172     hash ^= !pfd->can_use_bitmap;
4173     pfd->hash = hash;
4174     return;
4175 }
4176
4177 static GdiFont *find_in_cache(HFONT hfont, const LOGFONTW *plf, const FMAT2 *pmat, BOOL can_use_bitmap)
4178 {
4179     GdiFont *ret;
4180     FONT_DESC fd;
4181     HFONTLIST *hflist;
4182     struct list *font_elem_ptr, *hfontlist_elem_ptr;
4183
4184     fd.lf = *plf;
4185     fd.matrix = *pmat;
4186     fd.can_use_bitmap = can_use_bitmap;
4187     calc_hash(&fd);
4188
4189     /* try the child list */
4190     LIST_FOR_EACH(font_elem_ptr, &child_font_list) {
4191         ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
4192         if(!fontcmp(ret, &fd)) {
4193             if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
4194             LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
4195                 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
4196                 if(hflist->hfont == hfont)
4197                     return ret;
4198             }
4199         }
4200     }
4201
4202     /* try the in-use list */
4203     LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
4204         ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
4205         if(!fontcmp(ret, &fd)) {
4206             if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
4207             LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
4208                 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
4209                 if(hflist->hfont == hfont)
4210                     return ret;
4211             }
4212             hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
4213             hflist->hfont = hfont;
4214             list_add_head(&ret->hfontlist, &hflist->entry);
4215             return ret;
4216         }
4217     }
4218
4219     /* then the unused list */
4220     font_elem_ptr = list_head(&unused_gdi_font_list);
4221     while(font_elem_ptr) {
4222         ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
4223         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
4224         if(!fontcmp(ret, &fd)) {
4225             if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
4226             assert(list_empty(&ret->hfontlist));
4227             TRACE("Found %p in unused list\n", ret);
4228             list_remove(&ret->entry);
4229             list_add_head(&gdi_font_list, &ret->entry);
4230             hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
4231             hflist->hfont = hfont;
4232             list_add_head(&ret->hfontlist, &hflist->entry);
4233             return ret;
4234         }
4235     }
4236     return NULL;
4237 }
4238
4239 static void add_to_cache(GdiFont *font)
4240 {
4241     static DWORD cache_num = 1;
4242
4243     font->cache_num = cache_num++;
4244     list_add_head(&gdi_font_list, &font->entry);
4245 }
4246
4247 /*************************************************************
4248  * create_child_font_list
4249  */
4250 static BOOL create_child_font_list(GdiFont *font)
4251 {
4252     BOOL ret = FALSE;
4253     SYSTEM_LINKS *font_link;
4254     CHILD_FONT *font_link_entry, *new_child;
4255     FontSubst *psub;
4256     WCHAR* font_name;
4257
4258     psub = get_font_subst(&font_subst_list, font->name, -1);
4259     font_name = psub ? psub->to.name : font->name;
4260     font_link = find_font_link(font_name);
4261     if (font_link != NULL)
4262     {
4263         TRACE("found entry in system list\n");
4264         LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
4265         {
4266             new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
4267             new_child->face = font_link_entry->face;
4268             new_child->font = NULL;
4269             list_add_tail(&font->child_fonts, &new_child->entry);
4270             TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
4271         }
4272         ret = TRUE;
4273     }
4274     /*
4275      * if not SYMBOL or OEM then we also get all the fonts for Microsoft
4276      * Sans Serif.  This is how asian windows get default fallbacks for fonts
4277      */
4278     if (use_default_fallback && font->charset != SYMBOL_CHARSET &&
4279         font->charset != OEM_CHARSET &&
4280         strcmpiW(font_name,szDefaultFallbackLink) != 0)
4281     {
4282         font_link = find_font_link(szDefaultFallbackLink);
4283         if (font_link != NULL)
4284         {
4285             TRACE("found entry in default fallback list\n");
4286             LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
4287             {
4288                 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
4289                 new_child->face = font_link_entry->face;
4290                 new_child->font = NULL;
4291                 list_add_tail(&font->child_fonts, &new_child->entry);
4292                 TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
4293             }
4294             ret = TRUE;
4295         }
4296     }
4297
4298     return ret;
4299 }
4300
4301 static BOOL select_charmap(FT_Face ft_face, FT_Encoding encoding)
4302 {
4303     FT_Error ft_err = FT_Err_Invalid_CharMap_Handle;
4304
4305     if (pFT_Set_Charmap)
4306     {
4307         FT_Int i;
4308         FT_CharMap cmap0, cmap1, cmap2, cmap3, cmap_def;
4309
4310         cmap0 = cmap1 = cmap2 = cmap3 = cmap_def = NULL;
4311
4312         for (i = 0; i < ft_face->num_charmaps; i++)
4313         {
4314             if (ft_face->charmaps[i]->encoding == encoding)
4315             {
4316                 TRACE("found cmap with platform_id %u, encoding_id %u\n",
4317                        ft_face->charmaps[i]->platform_id, ft_face->charmaps[i]->encoding_id);
4318
4319                 switch (ft_face->charmaps[i]->platform_id)
4320                 {
4321                     default:
4322                         cmap_def = ft_face->charmaps[i];
4323                         break;
4324                     case 0: /* Apple Unicode */
4325                         cmap0 = ft_face->charmaps[i];
4326                         break;
4327                     case 1: /* Macintosh */
4328                         cmap1 = ft_face->charmaps[i];
4329                         break;
4330                     case 2: /* ISO */
4331                         cmap2 = ft_face->charmaps[i];
4332                         break;
4333                     case 3: /* Microsoft */
4334                         cmap3 = ft_face->charmaps[i];
4335                         break;
4336                 }
4337             }
4338
4339             if (cmap3) /* prefer Microsoft cmap table */
4340                 ft_err = pFT_Set_Charmap(ft_face, cmap3);
4341             else if (cmap1)
4342                 ft_err = pFT_Set_Charmap(ft_face, cmap1);
4343             else if (cmap2)
4344                 ft_err = pFT_Set_Charmap(ft_face, cmap2);
4345             else if (cmap0)
4346                 ft_err = pFT_Set_Charmap(ft_face, cmap0);
4347             else if (cmap_def)
4348                 ft_err = pFT_Set_Charmap(ft_face, cmap_def);
4349         }
4350         return ft_err == FT_Err_Ok;
4351     }
4352
4353     return pFT_Select_Charmap(ft_face, encoding) == FT_Err_Ok;
4354 }
4355
4356
4357 /*************************************************************
4358  * freetype_CreateDC
4359  */
4360 static BOOL freetype_CreateDC( PHYSDEV *dev, LPCWSTR driver, LPCWSTR device,
4361                                LPCWSTR output, const DEVMODEW *devmode )
4362 {
4363     struct freetype_physdev *physdev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physdev) );
4364
4365     if (!physdev) return FALSE;
4366     push_dc_driver( dev, &physdev->dev, &freetype_funcs );
4367     return TRUE;
4368 }
4369
4370
4371 /*************************************************************
4372  * freetype_DeleteDC
4373  */
4374 static BOOL freetype_DeleteDC( PHYSDEV dev )
4375 {
4376     struct freetype_physdev *physdev = get_freetype_dev( dev );
4377     HeapFree( GetProcessHeap(), 0, physdev );
4378     return TRUE;
4379 }
4380
4381
4382 /*************************************************************
4383  * freetype_SelectFont
4384  */
4385 static HFONT freetype_SelectFont( PHYSDEV dev, HFONT hfont )
4386 {
4387     struct freetype_physdev *physdev = get_freetype_dev( dev );
4388     GdiFont *ret;
4389     Face *face, *best, *best_bitmap;
4390     Family *family, *last_resort_family;
4391     const struct list *family_elem_ptr, *face_list, *face_elem_ptr;
4392     INT height, width = 0;
4393     unsigned int score = 0, new_score;
4394     signed int diff = 0, newdiff;
4395     BOOL bd, it, can_use_bitmap, want_vertical;
4396     LOGFONTW lf;
4397     CHARSETINFO csi;
4398     HFONTLIST *hflist;
4399     FMAT2 dcmat;
4400     FontSubst *psub = NULL;
4401     DC *dc = get_dc_ptr( dev->hdc );
4402     const SYSTEM_LINKS *font_link;
4403
4404     if (!hfont)  /* notification that the font has been changed by another driver */
4405     {
4406         dc->gdiFont = NULL;
4407         physdev->font = NULL;
4408         release_dc_ptr( dc );
4409         return 0;
4410     }
4411
4412     GetObjectW( hfont, sizeof(lf), &lf );
4413     lf.lfWidth = abs(lf.lfWidth);
4414
4415     can_use_bitmap = GetDeviceCaps(dev->hdc, TEXTCAPS) & TC_RA_ABLE;
4416
4417     TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
4418           debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
4419           lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
4420           lf.lfEscapement);
4421
4422     if(dc->GraphicsMode == GM_ADVANCED)
4423     {
4424         memcpy(&dcmat, &dc->xformWorld2Vport, sizeof(FMAT2));
4425         /* Try to avoid not necessary glyph transformations */
4426         if (dcmat.eM21 == 0.0 && dcmat.eM12 == 0.0 && dcmat.eM11 == dcmat.eM22)
4427         {
4428             lf.lfHeight *= fabs(dcmat.eM11);
4429             lf.lfWidth *= fabs(dcmat.eM11);
4430             dcmat.eM11 = dcmat.eM22 = 1.0;
4431         }
4432     }
4433     else
4434     {
4435         /* Windows 3.1 compatibility mode GM_COMPATIBLE has only limited
4436            font scaling abilities. */
4437         dcmat.eM11 = dcmat.eM22 = 1.0;
4438         dcmat.eM21 = dcmat.eM12 = 0;
4439         if (dc->vport2WorldValid)
4440         {
4441             if (dc->xformWorld2Vport.eM11 * dc->xformWorld2Vport.eM22 < 0)
4442                 lf.lfOrientation = -lf.lfOrientation;
4443             lf.lfHeight *= fabs(dc->xformWorld2Vport.eM22);
4444             lf.lfWidth *= fabs(dc->xformWorld2Vport.eM22);
4445         }
4446     }
4447
4448     TRACE("DC transform %f %f %f %f\n", dcmat.eM11, dcmat.eM12,
4449                                         dcmat.eM21, dcmat.eM22);
4450
4451     GDI_CheckNotLock();
4452     EnterCriticalSection( &freetype_cs );
4453
4454     /* check the cache first */
4455     if((ret = find_in_cache(hfont, &lf, &dcmat, can_use_bitmap)) != NULL) {
4456         TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
4457         goto done;
4458     }
4459
4460     if(list_empty(&font_list)) /* No fonts installed */
4461     {
4462         TRACE("No fonts installed\n");
4463         goto done;
4464     }
4465
4466     TRACE("not in cache\n");
4467     ret = alloc_font();
4468
4469     ret->font_desc.matrix = dcmat;
4470     ret->font_desc.lf = lf;
4471     ret->font_desc.can_use_bitmap = can_use_bitmap;
4472     calc_hash(&ret->font_desc);
4473     hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
4474     hflist->hfont = hfont;
4475     list_add_head(&ret->hfontlist, &hflist->entry);
4476
4477     /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
4478        SYMBOL_CHARSET so that Symbol gets picked irrespective of the
4479        original value lfCharSet.  Note this is a special case for
4480        Symbol and doesn't happen at least for "Wingdings*" */
4481
4482     if(!strcmpiW(lf.lfFaceName, SymbolW))
4483         lf.lfCharSet = SYMBOL_CHARSET;
4484
4485     if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
4486         switch(lf.lfCharSet) {
4487         case DEFAULT_CHARSET:
4488             csi.fs.fsCsb[0] = 0;
4489             break;
4490         default:
4491             FIXME("Untranslated charset %d\n", lf.lfCharSet);
4492             csi.fs.fsCsb[0] = 0;
4493             break;
4494         }
4495     }
4496
4497     family = NULL;
4498     if(lf.lfFaceName[0] != '\0') {
4499         CHILD_FONT *font_link_entry;
4500         LPWSTR FaceName = lf.lfFaceName;
4501
4502         psub = get_font_subst(&font_subst_list, FaceName, lf.lfCharSet);
4503
4504         if(psub) {
4505             TRACE("substituting %s,%d -> %s,%d\n", debugstr_w(FaceName), lf.lfCharSet,
4506                   debugstr_w(psub->to.name), (psub->to.charset != -1) ? psub->to.charset : lf.lfCharSet);
4507             if (psub->to.charset != -1)
4508                 lf.lfCharSet = psub->to.charset;
4509         }
4510
4511         /* We want a match on name and charset or just name if
4512            charset was DEFAULT_CHARSET.  If the latter then
4513            we fixup the returned charset later in get_nearest_charset
4514            where we'll either use the charset of the current ansi codepage
4515            or if that's unavailable the first charset that the font supports.
4516         */
4517         LIST_FOR_EACH(family_elem_ptr, &font_list) {
4518             family = LIST_ENTRY(family_elem_ptr, Family, entry);
4519             if (!strcmpiW(family->FamilyName, FaceName) ||
4520                 (psub && !strcmpiW(family->FamilyName, psub->to.name)))
4521             {
4522                 font_link = find_font_link(family->FamilyName);
4523                 face_list = get_face_list_from_family(family);
4524                 LIST_FOR_EACH(face_elem_ptr, face_list) {
4525                     face = LIST_ENTRY(face_elem_ptr, Face, entry);
4526                     if (!(face->scalable || can_use_bitmap))
4527                         continue;
4528                     if (csi.fs.fsCsb[0] & face->fs.fsCsb[0])
4529                         goto found;
4530                     if (font_link != NULL &&
4531                         csi.fs.fsCsb[0] & font_link->fs.fsCsb[0])
4532                         goto found;
4533                     if (!csi.fs.fsCsb[0])
4534                         goto found;
4535                 }
4536             }
4537         }
4538
4539         /* Search by full face name. */
4540         LIST_FOR_EACH(family_elem_ptr, &font_list) {
4541             family = LIST_ENTRY(family_elem_ptr, Family, entry);
4542             face_list = get_face_list_from_family(family);
4543             LIST_FOR_EACH(face_elem_ptr, face_list) {
4544                 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4545                 if(face->FullName && !strcmpiW(face->FullName, FaceName) &&
4546                    (face->scalable || can_use_bitmap))
4547                 {
4548                     if (csi.fs.fsCsb[0] & face->fs.fsCsb[0] || !csi.fs.fsCsb[0])
4549                         goto found_face;
4550                     font_link = find_font_link(family->FamilyName);
4551                     if (font_link != NULL &&
4552                         csi.fs.fsCsb[0] & font_link->fs.fsCsb[0])
4553                         goto found_face;
4554                 }
4555             }
4556         }
4557
4558         /*
4559          * Try check the SystemLink list first for a replacement font.
4560          * We may find good replacements there.
4561          */
4562         LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
4563         {
4564             if(!strcmpiW(font_link->font_name, FaceName) ||
4565                (psub && !strcmpiW(font_link->font_name,psub->to.name)))
4566             {
4567                 TRACE("found entry in system list\n");
4568                 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
4569                 {
4570                     const SYSTEM_LINKS *links;
4571
4572                     face = font_link_entry->face;
4573                     if (!(face->scalable || can_use_bitmap))
4574                         continue;
4575                     family = face->family;
4576                     if (csi.fs.fsCsb[0] & face->fs.fsCsb[0] || !csi.fs.fsCsb[0])
4577                         goto found;
4578                     links = find_font_link(family->FamilyName);
4579                     if (links != NULL && csi.fs.fsCsb[0] & links->fs.fsCsb[0])
4580                         goto found;
4581                 }
4582             }
4583         }
4584     }
4585
4586     psub = NULL; /* substitution is no more relevant */
4587
4588     /* If requested charset was DEFAULT_CHARSET then try using charset
4589        corresponding to the current ansi codepage */
4590     if (!csi.fs.fsCsb[0])
4591     {
4592         INT acp = GetACP();
4593         if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
4594             FIXME("TCI failed on codepage %d\n", acp);
4595             csi.fs.fsCsb[0] = 0;
4596         } else
4597             lf.lfCharSet = csi.ciCharset;
4598     }
4599
4600     want_vertical = (lf.lfFaceName[0] == '@');
4601
4602     /* Face families are in the top 4 bits of lfPitchAndFamily,
4603        so mask with 0xF0 before testing */
4604
4605     if((lf.lfPitchAndFamily & FIXED_PITCH) ||
4606        (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
4607         strcpyW(lf.lfFaceName, defFixed);
4608     else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
4609         strcpyW(lf.lfFaceName, defSerif);
4610     else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
4611         strcpyW(lf.lfFaceName, defSans);
4612     else
4613         strcpyW(lf.lfFaceName, defSans);
4614     LIST_FOR_EACH(family_elem_ptr, &font_list) {
4615         family = LIST_ENTRY(family_elem_ptr, Family, entry);
4616         if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
4617             font_link = find_font_link(family->FamilyName);
4618             face_list = get_face_list_from_family(family);
4619             LIST_FOR_EACH(face_elem_ptr, face_list) {
4620                 face = LIST_ENTRY(face_elem_ptr, Face, entry);
4621                 if (!(face->scalable || can_use_bitmap))
4622                     continue;
4623                 if (csi.fs.fsCsb[0] & face->fs.fsCsb[0])
4624                     goto found;
4625                 if (font_link != NULL && csi.fs.fsCsb[0] & font_link->fs.fsCsb[0])
4626                     goto found;
4627             }
4628         }
4629     }
4630
4631     last_resort_family = NULL;
4632     LIST_FOR_EACH(family_elem_ptr, &font_list) {
4633         family = LIST_ENTRY(family_elem_ptr, Family, entry);
4634         font_link = find_font_link(family->FamilyName);
4635         face_list = get_face_list_from_family(family);
4636         LIST_FOR_EACH(face_elem_ptr, face_list) {
4637             face = LIST_ENTRY(face_elem_ptr, Face, entry);
4638             if(face->vertical == want_vertical &&
4639                (csi.fs.fsCsb[0] & face->fs.fsCsb[0] ||
4640                 (font_link != NULL && csi.fs.fsCsb[0] & font_link->fs.fsCsb[0]))) {
4641                 if(face->scalable)
4642                     goto found;
4643                 if(can_use_bitmap && !last_resort_family)
4644                     last_resort_family = family;
4645             }
4646         }
4647     }
4648
4649     if(last_resort_family) {
4650         family = last_resort_family;
4651         csi.fs.fsCsb[0] = 0;
4652         goto found;
4653     }
4654
4655     LIST_FOR_EACH(family_elem_ptr, &font_list) {
4656         family = LIST_ENTRY(family_elem_ptr, Family, entry);
4657         face_list = get_face_list_from_family(family);
4658         LIST_FOR_EACH(face_elem_ptr, face_list) {
4659             face = LIST_ENTRY(face_elem_ptr, Face, entry);
4660             if(face->scalable && face->vertical == want_vertical) {
4661                 csi.fs.fsCsb[0] = 0;
4662                 WARN("just using first face for now\n");
4663                 goto found;
4664             }
4665             if(can_use_bitmap && !last_resort_family)
4666                 last_resort_family = family;
4667         }
4668     }
4669     if(!last_resort_family) {
4670         FIXME("can't find a single appropriate font - bailing\n");
4671         free_font(ret);
4672         ret = NULL;
4673         goto done;
4674     }
4675
4676     WARN("could only find a bitmap font - this will probably look awful!\n");
4677     family = last_resort_family;
4678     csi.fs.fsCsb[0] = 0;
4679
4680 found:
4681     it = lf.lfItalic ? 1 : 0;
4682     bd = lf.lfWeight > 550 ? 1 : 0;
4683
4684     height = lf.lfHeight;
4685
4686     face = best = best_bitmap = NULL;
4687     font_link = find_font_link(family->FamilyName);
4688     face_list = get_face_list_from_family(family);
4689     LIST_FOR_EACH_ENTRY(face, face_list, Face, entry)
4690     {
4691         if (csi.fs.fsCsb[0] & face->fs.fsCsb[0] ||
4692             (font_link != NULL && csi.fs.fsCsb[0] & font_link->fs.fsCsb[0]) ||
4693             !csi.fs.fsCsb[0])
4694         {
4695             BOOL italic, bold;
4696
4697             italic = (face->ntmFlags & NTM_ITALIC) ? 1 : 0;
4698             bold = (face->ntmFlags & NTM_BOLD) ? 1 : 0;
4699             new_score = (italic ^ it) + (bold ^ bd);
4700             if(!best || new_score <= score)
4701             {
4702                 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
4703                       italic, bold, it, bd);
4704                 score = new_score;
4705                 best = face;
4706                 if(best->scalable  && score == 0) break;
4707                 if(!best->scalable)
4708                 {
4709                     if(height > 0)
4710                         newdiff = height - (signed int)(best->size.height);
4711                     else
4712                         newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
4713                     if(!best_bitmap || new_score < score ||
4714                        (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
4715                     {
4716                         TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
4717                         diff = newdiff;
4718                         best_bitmap = best;
4719                         if(score == 0 && diff == 0) break;
4720                     }
4721                 }
4722             }
4723         }
4724     }
4725     if(best)
4726         face = best->scalable ? best : best_bitmap;
4727     ret->fake_italic = (it && !(face->ntmFlags & NTM_ITALIC));
4728     ret->fake_bold = (bd && !(face->ntmFlags & NTM_BOLD));
4729
4730 found_face:
4731     height = lf.lfHeight;
4732
4733     ret->fs = face->fs;
4734
4735     if(csi.fs.fsCsb[0]) {
4736         ret->charset = lf.lfCharSet;
4737         ret->codepage = csi.ciACP;
4738     }
4739     else
4740         ret->charset = get_nearest_charset(family->FamilyName, face, &ret->codepage);
4741
4742     TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family->FamilyName),
4743           debugstr_w(face->StyleName), face->file, face->font_data_ptr, face->face_index);
4744
4745     ret->aveWidth = height ? lf.lfWidth : 0;
4746
4747     if(!face->scalable) {
4748         /* Windows uses integer scaling factors for bitmap fonts */
4749         INT scale, scaled_height;
4750         GdiFont *cachedfont;
4751
4752         /* FIXME: rotation of bitmap fonts is ignored */
4753         height = abs(GDI_ROUND( (double)height * ret->font_desc.matrix.eM22 ));
4754         if (ret->aveWidth)
4755             ret->aveWidth = (double)ret->aveWidth * ret->font_desc.matrix.eM11;
4756         ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
4757         dcmat.eM11 = dcmat.eM22 = 1.0;
4758         /* As we changed the matrix, we need to search the cache for the font again,
4759          * otherwise we might explode the cache. */
4760         if((cachedfont = find_in_cache(hfont, &lf, &dcmat, can_use_bitmap)) != NULL) {
4761             TRACE("Found cached font after non-scalable matrix rescale!\n");
4762             free_font( ret );
4763             ret = cachedfont;
4764             goto done;
4765         }
4766         calc_hash(&ret->font_desc);
4767
4768         if (height != 0) height = diff;
4769         height += face->size.height;
4770
4771         scale = (height + face->size.height - 1) / face->size.height;
4772         scaled_height = scale * face->size.height;
4773         /* Only jump to the next height if the difference <= 25% original height */
4774         if (scale > 2 && scaled_height - height > face->size.height / 4) scale--;
4775         /* The jump between unscaled and doubled is delayed by 1 */
4776         else if (scale == 2 && scaled_height - height > (face->size.height / 4 - 1)) scale--;
4777         ret->scale_y = scale;
4778
4779         width = face->size.x_ppem >> 6;
4780         height = face->size.y_ppem >> 6;
4781     }
4782     else
4783         ret->scale_y = 1.0;
4784     TRACE("font scale y: %f\n", ret->scale_y);
4785
4786     ret->ft_face = OpenFontFace(ret, face, width, height);
4787
4788     if (!ret->ft_face)
4789     {
4790         free_font( ret );
4791         ret = NULL;
4792         goto done;
4793     }
4794
4795     ret->ntmFlags = face->ntmFlags;
4796
4797     if (ret->charset == SYMBOL_CHARSET &&
4798         select_charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
4799         /* No ops */
4800     }
4801     else if (select_charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
4802         /* No ops */
4803     }
4804     else {
4805         select_charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
4806     }
4807
4808     ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
4809     ret->name = psub ? strdupW(psub->from.name) : strdupW(family->FamilyName);
4810     ret->underline = lf.lfUnderline ? 0xff : 0;
4811     ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
4812     create_child_font_list(ret);
4813
4814     if (face->vertical) /* We need to try to load the GSUB table */
4815     {
4816         int length = get_font_data(ret, GSUB_TAG , 0, NULL, 0);
4817         if (length != GDI_ERROR)
4818         {
4819             ret->GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
4820             get_font_data(ret, GSUB_TAG , 0, ret->GSUB_Table, length);
4821             TRACE("Loaded GSUB table of %i bytes\n",length);
4822         }
4823     }
4824
4825     TRACE("caching: gdiFont=%p  hfont=%p\n", ret, hfont);
4826
4827     add_to_cache(ret);
4828 done:
4829     if (ret)
4830     {
4831         dc->gdiFont = ret;
4832         physdev->font = ret;
4833     }
4834     LeaveCriticalSection( &freetype_cs );
4835     release_dc_ptr( dc );
4836     return ret ? hfont : 0;
4837 }
4838
4839 static void dump_gdi_font_list(void)
4840 {
4841     GdiFont *gdiFont;
4842     struct list *elem_ptr;
4843
4844     TRACE("---------- gdiFont Cache ----------\n");
4845     LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
4846         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
4847         TRACE("gdiFont=%p %s %d\n",
4848               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
4849     }
4850
4851     TRACE("---------- Unused gdiFont Cache ----------\n");
4852     LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
4853         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
4854         TRACE("gdiFont=%p %s %d\n",
4855               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
4856     }
4857
4858     TRACE("---------- Child gdiFont Cache ----------\n");
4859     LIST_FOR_EACH(elem_ptr, &child_font_list) {
4860         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
4861         TRACE("gdiFont=%p %s %d\n",
4862               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
4863     }
4864 }
4865
4866 /*************************************************************
4867  * WineEngDestroyFontInstance
4868  *
4869  * free the gdiFont associated with this handle
4870  *
4871  */
4872 BOOL WineEngDestroyFontInstance(HFONT handle)
4873 {
4874     GdiFont *gdiFont;
4875     HFONTLIST *hflist;
4876     BOOL ret = FALSE;
4877     struct list *font_elem_ptr, *hfontlist_elem_ptr;
4878     int i = 0;
4879
4880     GDI_CheckNotLock();
4881     EnterCriticalSection( &freetype_cs );
4882
4883     LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
4884     {
4885         hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
4886         while(hfontlist_elem_ptr) {
4887             hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
4888             hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
4889             if(hflist->hfont == handle) {
4890                 TRACE("removing child font %p from child list\n", gdiFont);
4891                 list_remove(&gdiFont->entry);
4892                 LeaveCriticalSection( &freetype_cs );
4893                 return TRUE;
4894             }
4895         }
4896     }
4897
4898     TRACE("destroying hfont=%p\n", handle);
4899     if(TRACE_ON(font))
4900         dump_gdi_font_list();
4901
4902     font_elem_ptr = list_head(&gdi_font_list);
4903     while(font_elem_ptr) {
4904         gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
4905         font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
4906
4907         hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
4908         while(hfontlist_elem_ptr) {
4909             hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
4910             hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
4911             if(hflist->hfont == handle) {
4912                 list_remove(&hflist->entry);
4913                 HeapFree(GetProcessHeap(), 0, hflist);
4914                 ret = TRUE;
4915             }
4916         }
4917         if(list_empty(&gdiFont->hfontlist)) {
4918             TRACE("Moving to Unused list\n");
4919             list_remove(&gdiFont->entry);
4920             list_add_head(&unused_gdi_font_list, &gdiFont->entry);
4921         }
4922     }
4923
4924
4925     font_elem_ptr = list_head(&unused_gdi_font_list);
4926     while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
4927         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
4928     while(font_elem_ptr) {
4929         gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
4930         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
4931         TRACE("freeing %p\n", gdiFont);
4932         list_remove(&gdiFont->entry);
4933         free_font(gdiFont);
4934     }
4935     LeaveCriticalSection( &freetype_cs );
4936     return ret;
4937 }
4938
4939 static INT load_script_name( UINT id, WCHAR buffer[LF_FACESIZE] )
4940 {
4941     HRSRC rsrc;
4942     HGLOBAL hMem;
4943     WCHAR *p;
4944     int i;
4945
4946     id += IDS_FIRST_SCRIPT;
4947     rsrc = FindResourceW( gdi32_module, (LPCWSTR)(ULONG_PTR)((id >> 4) + 1), (LPCWSTR)6 /*RT_STRING*/ );
4948     if (!rsrc) return 0;
4949     hMem = LoadResource( gdi32_module, rsrc );
4950     if (!hMem) return 0;
4951
4952     p = LockResource( hMem );
4953     id &= 0x000f;
4954     while (id--) p += *p + 1;
4955
4956     i = min(LF_FACESIZE - 1, *p);
4957     memcpy(buffer, p + 1, i * sizeof(WCHAR));
4958     buffer[i] = 0;
4959     return i;
4960 }
4961
4962
4963 /***************************************************
4964  * create_enum_charset_list
4965  *
4966  * This function creates charset enumeration list because in DEFAULT_CHARSET
4967  * case, the ANSI codepage's charset takes precedence over other charsets.
4968  * This function works as a filter other than DEFAULT_CHARSET case.
4969  */
4970 static DWORD create_enum_charset_list(DWORD charset, struct enum_charset_list *list)
4971 {
4972     CHARSETINFO csi;
4973     DWORD n = 0;
4974
4975     if (TranslateCharsetInfo(ULongToPtr(charset), &csi, TCI_SRCCHARSET) &&
4976         csi.fs.fsCsb[0] != 0) {
4977         list->element[n].mask    = csi.fs.fsCsb[0];
4978         list->element[n].charset = csi.ciCharset;
4979         load_script_name( ffs(csi.fs.fsCsb[0]) - 1, list->element[n].name );
4980         n++;
4981     }
4982     else { /* charset is DEFAULT_CHARSET or invalid. */
4983         INT acp, i;
4984
4985         /* Set the current codepage's charset as the first element. */
4986         acp = GetACP();
4987         if (TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE) &&
4988             csi.fs.fsCsb[0] != 0) {
4989             list->element[n].mask    = csi.fs.fsCsb[0];
4990             list->element[n].charset = csi.ciCharset;
4991             load_script_name( ffs(csi.fs.fsCsb[0]) - 1, list->element[n].name );
4992             n++;
4993         }
4994
4995         /* Fill out left elements. */
4996         for (i = 0; i < 32; i++) {
4997             FONTSIGNATURE fs;
4998             fs.fsCsb[0] = 1L << i;
4999             fs.fsCsb[1] = 0;
5000             if (n > 0 && fs.fsCsb[0] == list->element[0].mask)
5001                 continue; /* skip, already added. */
5002             if (!TranslateCharsetInfo(fs.fsCsb, &csi, TCI_SRCFONTSIG))
5003                 continue; /* skip, this is an invalid fsCsb bit. */
5004
5005             list->element[n].mask    = fs.fsCsb[0];
5006             list->element[n].charset = csi.ciCharset;
5007             load_script_name( i, list->element[n].name );
5008             n++;
5009         }
5010     }
5011     list->total = n;
5012
5013     return n;
5014 }
5015
5016 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
5017                            NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
5018 {
5019     GdiFont *font;
5020     LONG width, height;
5021
5022     if (face->cached_enum_data)
5023     {
5024         TRACE("Cached\n");
5025         *pelf = face->cached_enum_data->elf;
5026         *pntm = face->cached_enum_data->ntm;
5027         *ptype = face->cached_enum_data->type;
5028         return;
5029     }
5030
5031     font = alloc_font();
5032
5033     if(face->scalable) {
5034         height = -2048; /* 2048 is the most common em size */
5035         width = 0;
5036     } else {
5037         height = face->size.y_ppem >> 6;
5038         width = face->size.x_ppem >> 6;
5039     }
5040     font->scale_y = 1.0;
5041
5042     if (!(font->ft_face = OpenFontFace(font, face, width, height)))
5043     {
5044         free_font(font);
5045         return;
5046     }
5047
5048     font->name = strdupW(face->family->FamilyName);
5049     font->ntmFlags = face->ntmFlags;
5050
5051     if (get_outline_text_metrics(font))
5052     {
5053         memcpy(&pntm->ntmTm, &font->potm->otmTextMetrics, sizeof(TEXTMETRICW));
5054
5055         pntm->ntmTm.ntmSizeEM = font->potm->otmEMSquare;
5056
5057         lstrcpynW(pelf->elfLogFont.lfFaceName,
5058                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFamilyName),
5059                  LF_FACESIZE);
5060         lstrcpynW(pelf->elfFullName,
5061                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFullName),
5062                  LF_FULLFACESIZE);
5063         lstrcpynW(pelf->elfStyle,
5064                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpStyleName),
5065                  LF_FACESIZE);
5066     }
5067     else
5068     {
5069         get_text_metrics(font, (TEXTMETRICW *)&pntm->ntmTm);
5070
5071         pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
5072
5073         lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
5074         if (face->FullName)
5075             lstrcpynW(pelf->elfFullName, face->FullName, LF_FULLFACESIZE);
5076         else
5077             lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FULLFACESIZE);
5078         lstrcpynW(pelf->elfStyle, face->StyleName, LF_FACESIZE);
5079     }
5080
5081     pntm->ntmTm.ntmFlags = face->ntmFlags;
5082     pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
5083     pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
5084     pntm->ntmFontSig = face->fs;
5085
5086     pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
5087
5088     pelf->elfLogFont.lfEscapement = 0;
5089     pelf->elfLogFont.lfOrientation = 0;
5090     pelf->elfLogFont.lfHeight = pntm->ntmTm.tmHeight;
5091     pelf->elfLogFont.lfWidth = pntm->ntmTm.tmAveCharWidth;
5092     pelf->elfLogFont.lfWeight = pntm->ntmTm.tmWeight;
5093     pelf->elfLogFont.lfItalic = pntm->ntmTm.tmItalic;
5094     pelf->elfLogFont.lfUnderline = pntm->ntmTm.tmUnderlined;
5095     pelf->elfLogFont.lfStrikeOut = pntm->ntmTm.tmStruckOut;
5096     pelf->elfLogFont.lfCharSet = pntm->ntmTm.tmCharSet;
5097     pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
5098     pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
5099     pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
5100     pelf->elfLogFont.lfPitchAndFamily = (pntm->ntmTm.tmPitchAndFamily & 0xf1) + 1;
5101
5102     *ptype = 0;
5103     if (pntm->ntmTm.tmPitchAndFamily & TMPF_TRUETYPE)
5104         *ptype |= TRUETYPE_FONTTYPE;
5105     if (pntm->ntmTm.tmPitchAndFamily & TMPF_DEVICE)
5106         *ptype |= DEVICE_FONTTYPE;
5107     if(!(pntm->ntmTm.tmPitchAndFamily & TMPF_VECTOR))
5108         *ptype |= RASTER_FONTTYPE;
5109
5110     face->cached_enum_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*face->cached_enum_data));
5111     if (face->cached_enum_data)
5112     {
5113         face->cached_enum_data->elf = *pelf;
5114         face->cached_enum_data->ntm = *pntm;
5115         face->cached_enum_data->type = *ptype;
5116     }
5117
5118     free_font(font);
5119 }
5120
5121 static void create_full_name(WCHAR *full_name, const WCHAR *family_name, const WCHAR *style_name)
5122 {
5123     static const WCHAR spaceW[] = { ' ', 0 };
5124
5125     strcpyW(full_name, family_name);
5126     strcatW(full_name, spaceW);
5127     strcatW(full_name, style_name);
5128 }
5129
5130 static BOOL family_matches(Family *family, const LOGFONTW *lf)
5131 {
5132     const struct list *face_list, *face_elem_ptr;
5133
5134     if (!strcmpiW(lf->lfFaceName, family->FamilyName)) return TRUE;
5135
5136     face_list = get_face_list_from_family(family);
5137     LIST_FOR_EACH(face_elem_ptr, face_list)
5138     {
5139         WCHAR full_family_name[LF_FULLFACESIZE];
5140         Face *face = LIST_ENTRY(face_elem_ptr, Face, entry);
5141
5142         if (strlenW(family->FamilyName) + strlenW(face->StyleName) + 2 > LF_FULLFACESIZE)
5143         {
5144             FIXME("Length of %s + %s + 2 is longer than LF_FULLFACESIZE\n",
5145                   debugstr_w(family->FamilyName), debugstr_w(face->StyleName));
5146             continue;
5147         }
5148
5149         create_full_name(full_family_name, family->FamilyName, face->StyleName);
5150         if (!strcmpiW(lf->lfFaceName, full_family_name)) return TRUE;
5151     }
5152
5153     return FALSE;
5154 }
5155
5156 static BOOL face_matches(const WCHAR *family_name, Face *face, const LOGFONTW *lf)
5157 {
5158     WCHAR full_family_name[LF_FULLFACESIZE];
5159
5160     if (!strcmpiW(lf->lfFaceName, family_name)) return TRUE;
5161
5162     if (strlenW(family_name) + strlenW(face->StyleName) + 2 > LF_FULLFACESIZE)
5163     {
5164         FIXME("Length of %s + %s + 2 is longer than LF_FULLFACESIZE\n",
5165               debugstr_w(family_name), debugstr_w(face->StyleName));
5166         return FALSE;
5167     }
5168
5169     create_full_name(full_family_name, family_name, face->StyleName);
5170     return !strcmpiW(lf->lfFaceName, full_family_name);
5171 }
5172
5173 static BOOL enum_face_charsets(const Family *family, Face *face, struct enum_charset_list *list,
5174                                FONTENUMPROCW proc, LPARAM lparam)
5175 {
5176     ENUMLOGFONTEXW elf;
5177     NEWTEXTMETRICEXW ntm;
5178     DWORD type = 0;
5179     int i;
5180
5181     GetEnumStructs(face, &elf, &ntm, &type);
5182     for(i = 0; i < list->total; i++) {
5183         if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
5184             elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
5185             load_script_name( IDS_OEM_DOS, elf.elfScript );
5186             i = list->total; /* break out of loop after enumeration */
5187         } else if(!(face->fs.fsCsb[0] & list->element[i].mask))
5188             continue;
5189         else {
5190             elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = list->element[i].charset;
5191             strcpyW(elf.elfScript, list->element[i].name);
5192             if (!elf.elfScript[0])
5193                 FIXME("Unknown elfscript for bit %d\n", ffs(list->element[i].mask) - 1);
5194         }
5195         /* Font Replacement */
5196         if (family != face->family)
5197         {
5198             strcpyW(elf.elfLogFont.lfFaceName, family->FamilyName);
5199             create_full_name(elf.elfFullName, family->FamilyName, face->StyleName);
5200         }
5201         TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
5202               debugstr_w(elf.elfLogFont.lfFaceName),
5203               debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
5204               elf.elfLogFont.lfCharSet, type, debugstr_w(elf.elfScript),
5205               elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
5206               ntm.ntmTm.ntmFlags);
5207         /* release section before callback (FIXME) */
5208         LeaveCriticalSection( &freetype_cs );
5209         if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return FALSE;
5210         EnterCriticalSection( &freetype_cs );
5211     }
5212     return TRUE;
5213 }
5214
5215 /*************************************************************
5216  * freetype_EnumFonts
5217  */
5218 static BOOL freetype_EnumFonts( PHYSDEV dev, LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam )
5219 {
5220     Family *family;
5221     Face *face;
5222     const struct list *family_elem_ptr, *face_list, *face_elem_ptr;
5223     LOGFONTW lf;
5224     struct enum_charset_list enum_charsets;
5225
5226     if (!plf)
5227     {
5228         lf.lfCharSet = DEFAULT_CHARSET;
5229         lf.lfPitchAndFamily = 0;
5230         lf.lfFaceName[0] = 0;
5231         plf = &lf;
5232     }
5233
5234     TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
5235
5236     create_enum_charset_list(plf->lfCharSet, &enum_charsets);
5237
5238     GDI_CheckNotLock();
5239     EnterCriticalSection( &freetype_cs );
5240     if(plf->lfFaceName[0]) {
5241         FontSubst *psub;
5242         psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
5243
5244         if(psub) {
5245             TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
5246                   debugstr_w(psub->to.name));
5247             lf = *plf;
5248             strcpyW(lf.lfFaceName, psub->to.name);
5249             plf = &lf;
5250         }
5251
5252         LIST_FOR_EACH(family_elem_ptr, &font_list) {
5253             family = LIST_ENTRY(family_elem_ptr, Family, entry);
5254             if(family_matches(family, plf)) {
5255                 face_list = get_face_list_from_family(family);
5256                 LIST_FOR_EACH(face_elem_ptr, face_list) {
5257                     face = LIST_ENTRY(face_elem_ptr, Face, entry);
5258                     if (!face_matches(family->FamilyName, face, plf)) continue;
5259                     if (!enum_face_charsets(family, face, &enum_charsets, proc, lparam)) return FALSE;
5260                 }
5261             }
5262         }
5263     } else {
5264         LIST_FOR_EACH(family_elem_ptr, &font_list) {
5265             family = LIST_ENTRY(family_elem_ptr, Family, entry);
5266             face_list = get_face_list_from_family(family);
5267             face_elem_ptr = list_head(face_list);
5268             face = LIST_ENTRY(face_elem_ptr, Face, entry);
5269             if (!enum_face_charsets(family, face, &enum_charsets, proc, lparam)) return FALSE;
5270         }
5271     }
5272     LeaveCriticalSection( &freetype_cs );
5273     return TRUE;
5274 }
5275
5276 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
5277 {
5278     pt->x.value = vec->x >> 6;
5279     pt->x.fract = (vec->x & 0x3f) << 10;
5280     pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
5281     pt->y.value = vec->y >> 6;
5282     pt->y.fract = (vec->y & 0x3f) << 10;
5283     pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
5284     return;
5285 }
5286
5287 /***************************************************
5288  * According to the MSDN documentation on WideCharToMultiByte,
5289  * certain codepages cannot set the default_used parameter.
5290  * This returns TRUE if the codepage can set that parameter, false else
5291  * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
5292  */
5293 static BOOL codepage_sets_default_used(UINT codepage)
5294 {
5295    switch (codepage)
5296    {
5297        case CP_UTF7:
5298        case CP_UTF8:
5299        case CP_SYMBOL:
5300            return FALSE;
5301        default:
5302            return TRUE;
5303    }
5304 }
5305
5306 /*
5307  * GSUB Table handling functions
5308  */
5309
5310 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
5311 {
5312     const GSUB_CoverageFormat1* cf1;
5313
5314     cf1 = table;
5315
5316     if (GET_BE_WORD(cf1->CoverageFormat) == 1)
5317     {
5318         int count = GET_BE_WORD(cf1->GlyphCount);
5319         int i;
5320         TRACE("Coverage Format 1, %i glyphs\n",count);
5321         for (i = 0; i < count; i++)
5322             if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
5323                 return i;
5324         return -1;
5325     }
5326     else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
5327     {
5328         const GSUB_CoverageFormat2* cf2;
5329         int i;
5330         int count;
5331         cf2 = (const GSUB_CoverageFormat2*)cf1;
5332
5333         count = GET_BE_WORD(cf2->RangeCount);
5334         TRACE("Coverage Format 2, %i ranges\n",count);
5335         for (i = 0; i < count; i++)
5336         {
5337             if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
5338                 return -1;
5339             if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
5340                 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
5341             {
5342                 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
5343                     glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
5344             }
5345         }
5346         return -1;
5347     }
5348     else
5349         ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
5350
5351     return -1;
5352 }
5353
5354 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
5355 {
5356     const GSUB_ScriptList *script;
5357     const GSUB_Script *deflt = NULL;
5358     int i;
5359     script = (const GSUB_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
5360
5361     TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
5362     for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
5363     {
5364         const GSUB_Script *scr;
5365         int offset;
5366
5367         offset = GET_BE_WORD(script->ScriptRecord[i].Script);
5368         scr = (const GSUB_Script*)((const BYTE*)script + offset);
5369
5370         if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
5371             return scr;
5372         if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
5373             deflt = scr;
5374     }
5375     return deflt;
5376 }
5377
5378 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
5379 {
5380     int i;
5381     int offset;
5382     const GSUB_LangSys *Lang;
5383
5384     TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
5385
5386     for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
5387     {
5388         offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
5389         Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
5390
5391         if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
5392             return Lang;
5393     }
5394     offset = GET_BE_WORD(script->DefaultLangSys);
5395     if (offset)
5396     {
5397         Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
5398         return Lang;
5399     }
5400     return NULL;
5401 }
5402
5403 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
5404 {
5405     int i;
5406     const GSUB_FeatureList *feature;
5407     feature = (const GSUB_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
5408
5409     TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
5410     for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
5411     {
5412         int index = GET_BE_WORD(lang->FeatureIndex[i]);
5413         if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
5414         {
5415             const GSUB_Feature *feat;
5416             feat = (const GSUB_Feature*)((const BYTE*)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
5417             return feat;
5418         }
5419     }
5420     return NULL;
5421 }
5422
5423 static FT_UInt GSUB_apply_feature(const GSUB_Header * header, const GSUB_Feature* feature, UINT glyph)
5424 {
5425     int i;
5426     int offset;
5427     const GSUB_LookupList *lookup;
5428     lookup = (const GSUB_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
5429
5430     TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
5431     for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
5432     {
5433         const GSUB_LookupTable *look;
5434         offset = GET_BE_WORD(lookup->Lookup[GET_BE_WORD(feature->LookupListIndex[i])]);
5435         look = (const GSUB_LookupTable*)((const BYTE*)lookup + offset);
5436         TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
5437         if (GET_BE_WORD(look->LookupType) != 1)
5438             FIXME("We only handle SubType 1\n");
5439         else
5440         {
5441             int j;
5442
5443             for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
5444             {
5445                 const GSUB_SingleSubstFormat1 *ssf1;
5446                 offset = GET_BE_WORD(look->SubTable[j]);
5447                 ssf1 = (const GSUB_SingleSubstFormat1*)((const BYTE*)look+offset);
5448                 if (GET_BE_WORD(ssf1->SubstFormat) == 1)
5449                 {
5450                     int offset = GET_BE_WORD(ssf1->Coverage);
5451                     TRACE("  subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
5452                     if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyph) != -1)
5453                     {
5454                         TRACE("  Glyph 0x%x ->",glyph);
5455                         glyph += GET_BE_WORD(ssf1->DeltaGlyphID);
5456                         TRACE(" 0x%x\n",glyph);
5457                     }
5458                 }
5459                 else
5460                 {
5461                     const GSUB_SingleSubstFormat2 *ssf2;
5462                     INT index;
5463                     INT offset;
5464
5465                     ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
5466                     offset = GET_BE_WORD(ssf1->Coverage);
5467                     TRACE("  subtype 2,  glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
5468                     index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyph);
5469                     TRACE("  Coverage index %i\n",index);
5470                     if (index != -1)
5471                     {
5472                         TRACE("    Glyph is 0x%x ->",glyph);
5473                         glyph = GET_BE_WORD(ssf2->Substitute[index]);
5474                         TRACE("0x%x\n",glyph);
5475                     }
5476                 }
5477             }
5478         }
5479     }
5480     return glyph;
5481 }
5482
5483 static const char* get_opentype_script(const GdiFont *font)
5484 {
5485     /*
5486      * I am not sure if this is the correct way to generate our script tag
5487      */
5488
5489     switch (font->charset)
5490     {
5491         case ANSI_CHARSET: return "latn";
5492         case BALTIC_CHARSET: return "latn"; /* ?? */
5493         case CHINESEBIG5_CHARSET: return "hani";
5494         case EASTEUROPE_CHARSET: return "latn"; /* ?? */
5495         case GB2312_CHARSET: return "hani";
5496         case GREEK_CHARSET: return "grek";
5497         case HANGUL_CHARSET: return "hang";
5498         case RUSSIAN_CHARSET: return "cyrl";
5499         case SHIFTJIS_CHARSET: return "kana";
5500         case TURKISH_CHARSET: return "latn"; /* ?? */
5501         case VIETNAMESE_CHARSET: return "latn";
5502         case JOHAB_CHARSET: return "latn"; /* ?? */
5503         case ARABIC_CHARSET: return "arab";
5504         case HEBREW_CHARSET: return "hebr";
5505         case THAI_CHARSET: return "thai";
5506         default: return "latn";
5507     }
5508 }
5509
5510 static FT_UInt get_GSUB_vert_glyph(const GdiFont *font, UINT glyph)
5511 {
5512     const GSUB_Header *header;
5513     const GSUB_Script *script;
5514     const GSUB_LangSys *language;
5515     const GSUB_Feature *feature;
5516
5517     if (!font->GSUB_Table)
5518         return glyph;
5519
5520     header = font->GSUB_Table;
5521
5522     script = GSUB_get_script_table(header, get_opentype_script(font));
5523     if (!script)
5524     {
5525         TRACE("Script not found\n");
5526         return glyph;
5527     }
5528     language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
5529     if (!language)
5530     {
5531         TRACE("Language not found\n");
5532         return glyph;
5533     }
5534     feature  =  GSUB_get_feature(header, language, "vrt2");
5535     if (!feature)
5536         feature  =  GSUB_get_feature(header, language, "vert");
5537     if (!feature)
5538     {
5539         TRACE("vrt2/vert feature not found\n");
5540         return glyph;
5541     }
5542     return GSUB_apply_feature(header, feature, glyph);
5543 }
5544
5545 static FT_UInt get_glyph_index(const GdiFont *font, UINT glyph)
5546 {
5547     FT_UInt glyphId;
5548
5549     if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
5550         WCHAR wc = (WCHAR)glyph;
5551         BOOL default_used;
5552         BOOL *default_used_pointer;
5553         FT_UInt ret;
5554         char buf;
5555         default_used_pointer = NULL;
5556         default_used = FALSE;
5557         if (codepage_sets_default_used(font->codepage))
5558             default_used_pointer = &default_used;
5559         if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
5560             ret = 0;
5561         else
5562             ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
5563         TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
5564         return ret;
5565     }
5566
5567     if(font->ft_face->charmap->encoding == FT_ENCODING_MS_SYMBOL)
5568     {
5569         if (glyph < 0x100) glyph += 0xf000;
5570         /* there is a number of old pre-Unicode "broken" TTFs, which
5571            do have symbols at U+00XX instead of U+f0XX */
5572         if (!(glyphId = pFT_Get_Char_Index(font->ft_face, glyph)))
5573             glyphId = pFT_Get_Char_Index(font->ft_face, glyph-0xf000);
5574     }
5575     else glyphId = pFT_Get_Char_Index(font->ft_face, glyph);
5576
5577     return glyphId;
5578 }
5579
5580 /*************************************************************
5581  * freetype_GetGlyphIndices
5582  */
5583 static DWORD freetype_GetGlyphIndices( PHYSDEV dev, LPCWSTR lpstr, INT count, LPWORD pgi, DWORD flags )
5584 {
5585     struct freetype_physdev *physdev = get_freetype_dev( dev );
5586     int i;
5587     WORD default_char;
5588     BOOL got_default = FALSE;
5589
5590     if (!physdev->font)
5591     {
5592         dev = GET_NEXT_PHYSDEV( dev, pGetGlyphIndices );
5593         return dev->funcs->pGetGlyphIndices( dev, lpstr, count, pgi, flags );
5594     }
5595
5596     if (flags & GGI_MARK_NONEXISTING_GLYPHS)
5597     {
5598         default_char = 0xffff;  /* XP would use 0x1f for bitmap fonts */
5599         got_default = TRUE;
5600     }
5601
5602     GDI_CheckNotLock();
5603     EnterCriticalSection( &freetype_cs );
5604
5605     for(i = 0; i < count; i++)
5606     {
5607         pgi[i] = get_glyph_index(physdev->font, lpstr[i]);
5608         if  (pgi[i] == 0)
5609         {
5610             if (!got_default)
5611             {
5612                 if (FT_IS_SFNT(physdev->font->ft_face))
5613                 {
5614                     TT_OS2 *pOS2 = pFT_Get_Sfnt_Table(physdev->font->ft_face, ft_sfnt_os2);
5615                     default_char = (pOS2->usDefaultChar ? get_glyph_index(physdev->font, pOS2->usDefaultChar) : 0);
5616                 }
5617                 else
5618                 {
5619                     TEXTMETRICW textm;
5620                     get_text_metrics(physdev->font, &textm);
5621                     default_char = textm.tmDefaultChar;
5622                 }
5623                 got_default = TRUE;
5624             }
5625             pgi[i] = default_char;
5626         }
5627     }
5628     LeaveCriticalSection( &freetype_cs );
5629     return count;
5630 }
5631
5632 static inline BOOL is_identity_FMAT2(const FMAT2 *matrix)
5633 {
5634     static const FMAT2 identity = { 1.0, 0.0, 0.0, 1.0 };
5635     return !memcmp(matrix, &identity, sizeof(FMAT2));
5636 }
5637
5638 static inline BOOL is_identity_MAT2(const MAT2 *matrix)
5639 {
5640     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
5641     return !memcmp(matrix, &identity, sizeof(MAT2));
5642 }
5643
5644 static inline BYTE get_max_level( UINT format )
5645 {
5646     switch( format )
5647     {
5648     case GGO_GRAY2_BITMAP: return 4;
5649     case GGO_GRAY4_BITMAP: return 16;
5650     case GGO_GRAY8_BITMAP: return 64;
5651     }
5652     return 255;
5653 }
5654
5655 static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
5656
5657 static DWORD get_glyph_outline(GdiFont *incoming_font, UINT glyph, UINT format,
5658                                LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
5659                                const MAT2* lpmat)
5660 {
5661     static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
5662     FT_Face ft_face = incoming_font->ft_face;
5663     GdiFont *font = incoming_font;
5664     FT_UInt glyph_index;
5665     DWORD width, height, pitch, needed = 0;
5666     FT_Bitmap ft_bitmap;
5667     FT_Error err;
5668     INT left, right, top = 0, bottom = 0, adv, lsb, bbx;
5669     FT_Angle angle = 0;
5670     FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
5671     double widthRatio = 1.0;
5672     FT_Matrix transMat = identityMat;
5673     FT_Matrix transMatUnrotated;
5674     BOOL needsTransform = FALSE;
5675     BOOL tategaki = (font->GSUB_Table != NULL);
5676     UINT original_index;
5677
5678     TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
5679           buflen, buf, lpmat);
5680
5681     TRACE("font transform %f %f %f %f\n",
5682           font->font_desc.matrix.eM11, font->font_desc.matrix.eM12,
5683           font->font_desc.matrix.eM21, font->font_desc.matrix.eM22);
5684
5685     if(format & GGO_GLYPH_INDEX) {
5686         glyph_index = get_GSUB_vert_glyph(incoming_font,glyph);
5687         original_index = glyph;
5688         format &= ~GGO_GLYPH_INDEX;
5689     } else {
5690         get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
5691         ft_face = font->ft_face;
5692         original_index = glyph_index;
5693     }
5694
5695     if(format & GGO_UNHINTED) {
5696         load_flags |= FT_LOAD_NO_HINTING;
5697         format &= ~GGO_UNHINTED;
5698     }
5699
5700     /* tategaki never appears to happen to lower glyph index */
5701     if (glyph_index < TATEGAKI_LOWER_BOUND )
5702         tategaki = FALSE;
5703
5704     if(original_index >= font->gmsize * GM_BLOCK_SIZE) {
5705         font->gmsize = (original_index / GM_BLOCK_SIZE + 1);
5706         font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
5707                                font->gmsize * sizeof(GM*));
5708     } else {
5709         if (format == GGO_METRICS && font->gm[original_index / GM_BLOCK_SIZE] != NULL &&
5710             FONT_GM(font,original_index)->init && is_identity_MAT2(lpmat))
5711         {
5712             *lpgm = FONT_GM(font,original_index)->gm;
5713             TRACE("cached: %u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
5714                   wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
5715                   lpgm->gmCellIncX, lpgm->gmCellIncY);
5716             return 1; /* FIXME */
5717         }
5718     }
5719
5720     if (!font->gm[original_index / GM_BLOCK_SIZE])
5721         font->gm[original_index / GM_BLOCK_SIZE] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
5722
5723     /* Scaling factor */
5724     if (font->aveWidth)
5725     {
5726         TEXTMETRICW tm;
5727
5728         get_text_metrics(font, &tm);
5729
5730         widthRatio = (double)font->aveWidth;
5731         widthRatio /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
5732     }
5733     else
5734         widthRatio = font->scale_y;
5735
5736     /* Scaling transform */
5737     if (widthRatio != 1.0 || font->scale_y != 1.0)
5738     {
5739         FT_Matrix scaleMat;
5740         scaleMat.xx = FT_FixedFromFloat(widthRatio);
5741         scaleMat.xy = 0;
5742         scaleMat.yx = 0;
5743         scaleMat.yy = FT_FixedFromFloat(font->scale_y);
5744
5745         pFT_Matrix_Multiply(&scaleMat, &transMat);
5746         needsTransform = TRUE;
5747     }
5748
5749     /* Slant transform */
5750     if (font->fake_italic) {
5751         FT_Matrix slantMat;
5752
5753         slantMat.xx = (1 << 16);
5754         slantMat.xy = ((1 << 16) >> 2);
5755         slantMat.yx = 0;
5756         slantMat.yy = (1 << 16);
5757         pFT_Matrix_Multiply(&slantMat, &transMat);
5758         needsTransform = TRUE;
5759     }
5760
5761     /* Rotation transform */
5762     transMatUnrotated = transMat;
5763     if(font->orientation && !tategaki) {
5764         FT_Matrix rotationMat;
5765         FT_Vector vecAngle;
5766         angle = FT_FixedFromFloat((double)font->orientation / 10.0);
5767         pFT_Vector_Unit(&vecAngle, angle);
5768         rotationMat.xx = vecAngle.x;
5769         rotationMat.xy = -vecAngle.y;
5770         rotationMat.yx = -rotationMat.xy;
5771         rotationMat.yy = rotationMat.xx;
5772
5773         pFT_Matrix_Multiply(&rotationMat, &transMat);
5774         needsTransform = TRUE;
5775     }
5776
5777     /* World transform */
5778     if (!is_identity_FMAT2(&font->font_desc.matrix))
5779     {
5780         FT_Matrix worldMat;
5781         worldMat.xx = FT_FixedFromFloat(font->font_desc.matrix.eM11);
5782         worldMat.xy = FT_FixedFromFloat(font->font_desc.matrix.eM12);
5783         worldMat.yx = FT_FixedFromFloat(font->font_desc.matrix.eM21);
5784         worldMat.yy = FT_FixedFromFloat(font->font_desc.matrix.eM22);
5785         pFT_Matrix_Multiply(&worldMat, &transMat);
5786         pFT_Matrix_Multiply(&worldMat, &transMatUnrotated);
5787         needsTransform = TRUE;
5788     }
5789
5790     /* Extra transformation specified by caller */
5791     if (!is_identity_MAT2(lpmat))
5792     {
5793         FT_Matrix extraMat;
5794         extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
5795         extraMat.xy = FT_FixedFromFIXED(lpmat->eM12);
5796         extraMat.yx = FT_FixedFromFIXED(lpmat->eM21);
5797         extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
5798         pFT_Matrix_Multiply(&extraMat, &transMat);
5799         pFT_Matrix_Multiply(&extraMat, &transMatUnrotated);
5800         needsTransform = TRUE;
5801     }
5802
5803     if (needsTransform || (format == GGO_NATIVE || format == GGO_BEZIER ||
5804                            format == GGO_GRAY2_BITMAP || format == GGO_GRAY4_BITMAP ||
5805                            format == GGO_GRAY8_BITMAP))
5806     {
5807         load_flags |= FT_LOAD_NO_BITMAP;
5808     }
5809
5810     err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
5811
5812     if(err) {
5813         WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
5814         return GDI_ERROR;
5815     }
5816
5817     if(!needsTransform) {
5818         left = (INT)(ft_face->glyph->metrics.horiBearingX) & -64;
5819         right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) + 63) & -64;
5820         adv = (INT)(ft_face->glyph->metrics.horiAdvance + 63) >> 6;
5821
5822         top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
5823         bottom = (ft_face->glyph->metrics.horiBearingY -
5824                   ft_face->glyph->metrics.height) & -64;
5825         lpgm->gmCellIncX = adv;
5826         lpgm->gmCellIncY = 0;
5827     } else {
5828         INT xc, yc;
5829         FT_Vector vec;
5830
5831         left = right = 0;
5832
5833         for(xc = 0; xc < 2; xc++) {
5834             for(yc = 0; yc < 2; yc++) {
5835                 vec.x = (ft_face->glyph->metrics.horiBearingX +
5836                   xc * ft_face->glyph->metrics.width);
5837                 vec.y = ft_face->glyph->metrics.horiBearingY -
5838                   yc * ft_face->glyph->metrics.height;
5839                 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
5840                 pFT_Vector_Transform(&vec, &transMat);
5841                 if(xc == 0 && yc == 0) {
5842                     left = right = vec.x;
5843                     top = bottom = vec.y;
5844                 } else {
5845                     if(vec.x < left) left = vec.x;
5846                     else if(vec.x > right) right = vec.x;
5847                     if(vec.y < bottom) bottom = vec.y;
5848                     else if(vec.y > top) top = vec.y;
5849                 }
5850             }
5851         }
5852         left = left & -64;
5853         right = (right + 63) & -64;
5854         bottom = bottom & -64;
5855         top = (top + 63) & -64;
5856
5857         TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
5858         vec.x = ft_face->glyph->metrics.horiAdvance;
5859         vec.y = 0;
5860         pFT_Vector_Transform(&vec, &transMat);
5861         lpgm->gmCellIncX = (vec.x+63) >> 6;
5862         lpgm->gmCellIncY = -((vec.y+63) >> 6);
5863
5864         vec.x = ft_face->glyph->metrics.horiAdvance;
5865         vec.y = 0;
5866         pFT_Vector_Transform(&vec, &transMatUnrotated);
5867         adv = (vec.x+63) >> 6;
5868     }
5869
5870     lsb = left >> 6;
5871     bbx = (right - left) >> 6;
5872     lpgm->gmBlackBoxX = (right - left) >> 6;
5873     lpgm->gmBlackBoxY = (top - bottom) >> 6;
5874     lpgm->gmptGlyphOrigin.x = left >> 6;
5875     lpgm->gmptGlyphOrigin.y = top >> 6;
5876
5877     TRACE("%u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
5878           wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
5879           lpgm->gmCellIncX, lpgm->gmCellIncY);
5880
5881     if ((format == GGO_METRICS || format == GGO_BITMAP || format ==  WINE_GGO_GRAY16_BITMAP) &&
5882         is_identity_MAT2(lpmat)) /* don't cache custom transforms */
5883     {
5884         FONT_GM(font,original_index)->gm = *lpgm;
5885         FONT_GM(font,original_index)->adv = adv;
5886         FONT_GM(font,original_index)->lsb = lsb;
5887         FONT_GM(font,original_index)->bbx = bbx;
5888         FONT_GM(font,original_index)->init = TRUE;
5889     }
5890
5891     if(format == GGO_METRICS)
5892     {
5893         return 1; /* FIXME */
5894     }
5895
5896     if(ft_face->glyph->format != ft_glyph_format_outline &&
5897        (format == GGO_NATIVE || format == GGO_BEZIER))
5898     {
5899         TRACE("loaded a bitmap\n");
5900         return GDI_ERROR;
5901     }
5902
5903     switch(format) {
5904     case GGO_BITMAP:
5905         width = lpgm->gmBlackBoxX;
5906         height = lpgm->gmBlackBoxY;
5907         pitch = ((width + 31) >> 5) << 2;
5908         needed = pitch * height;
5909
5910         if(!buf || !buflen) break;
5911
5912         switch(ft_face->glyph->format) {
5913         case ft_glyph_format_bitmap:
5914           {
5915             BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
5916             INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
5917             INT h = ft_face->glyph->bitmap.rows;
5918             while(h--) {
5919                 memcpy(dst, src, w);
5920                 src += ft_face->glyph->bitmap.pitch;
5921                 dst += pitch;
5922             }
5923             break;
5924           }
5925
5926         case ft_glyph_format_outline:
5927             ft_bitmap.width = width;
5928             ft_bitmap.rows = height;
5929             ft_bitmap.pitch = pitch;
5930             ft_bitmap.pixel_mode = ft_pixel_mode_mono;
5931             ft_bitmap.buffer = buf;
5932
5933             if(needsTransform)
5934                 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
5935
5936             pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
5937
5938             /* Note: FreeType will only set 'black' bits for us. */
5939             memset(buf, 0, needed);
5940             pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
5941             break;
5942
5943         default:
5944             FIXME("loaded glyph format %x\n", ft_face->glyph->format);
5945             return GDI_ERROR;
5946         }
5947         break;
5948
5949     case GGO_GRAY2_BITMAP:
5950     case GGO_GRAY4_BITMAP:
5951     case GGO_GRAY8_BITMAP:
5952     case WINE_GGO_GRAY16_BITMAP:
5953       {
5954         unsigned int max_level, row, col;
5955         BYTE *start, *ptr;
5956
5957         width = lpgm->gmBlackBoxX;
5958         height = lpgm->gmBlackBoxY;
5959         pitch = (width + 3) / 4 * 4;
5960         needed = pitch * height;
5961
5962         if(!buf || !buflen) break;
5963
5964         max_level = get_max_level( format );
5965
5966         switch(ft_face->glyph->format) {
5967         case ft_glyph_format_bitmap:
5968           {
5969             BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
5970             INT h = ft_face->glyph->bitmap.rows;
5971             INT x;
5972             memset( buf, 0, needed );
5973             while(h--) {
5974                 for(x = 0; x < pitch && x < ft_face->glyph->bitmap.width; x++)
5975                     if (src[x / 8] & masks[x % 8]) dst[x] = max_level;
5976                 src += ft_face->glyph->bitmap.pitch;
5977                 dst += pitch;
5978             }
5979             return needed;
5980           }
5981         case ft_glyph_format_outline:
5982           {
5983             ft_bitmap.width = width;
5984             ft_bitmap.rows = height;
5985             ft_bitmap.pitch = pitch;
5986             ft_bitmap.pixel_mode = ft_pixel_mode_grays;
5987             ft_bitmap.buffer = buf;
5988
5989             if(needsTransform)
5990                 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
5991
5992             pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
5993
5994             memset(ft_bitmap.buffer, 0, buflen);
5995
5996             pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
5997
5998             if (max_level != 255)
5999             {
6000                 for (row = 0, start = buf; row < height; row++)
6001                 {
6002                     for (col = 0, ptr = start; col < width; col++, ptr++)
6003                         *ptr = (((int)*ptr) * max_level + 128) / 256;
6004                     start += pitch;
6005                 }
6006             }
6007             return needed;
6008           }
6009
6010         default:
6011             FIXME("loaded glyph format %x\n", ft_face->glyph->format);
6012             return GDI_ERROR;
6013         }
6014         break;
6015       }
6016
6017     case WINE_GGO_HRGB_BITMAP:
6018     case WINE_GGO_HBGR_BITMAP:
6019     case WINE_GGO_VRGB_BITMAP:
6020     case WINE_GGO_VBGR_BITMAP:
6021 #ifdef HAVE_FREETYPE_FTLCDFIL_H
6022       {
6023         switch (ft_face->glyph->format)
6024         {
6025         case FT_GLYPH_FORMAT_BITMAP:
6026           {
6027             BYTE *src, *dst;
6028             INT src_pitch, x;
6029
6030             width  = lpgm->gmBlackBoxX;
6031             height = lpgm->gmBlackBoxY;
6032             pitch  = width * 4;
6033             needed = pitch * height;
6034
6035             if (!buf || !buflen) break;
6036
6037             memset(buf, 0, buflen);
6038             dst = buf;
6039             src = ft_face->glyph->bitmap.buffer;
6040             src_pitch = ft_face->glyph->bitmap.pitch;
6041
6042             height = min( height, ft_face->glyph->bitmap.rows );
6043             while ( height-- )
6044             {
6045                 for (x = 0; x < width && x < ft_face->glyph->bitmap.width; x++)
6046                 {
6047                     if ( src[x / 8] & masks[x % 8] )
6048                         ((unsigned int *)dst)[x] = ~0u;
6049                 }
6050                 src += src_pitch;
6051                 dst += pitch;
6052             }
6053
6054             break;
6055           }
6056
6057         case FT_GLYPH_FORMAT_OUTLINE:
6058           {
6059             unsigned int *dst;
6060             BYTE *src;
6061             INT x, src_pitch, src_width, src_height, rgb_interval, hmul, vmul;
6062             INT x_shift, y_shift;
6063             BOOL rgb;
6064             FT_LcdFilter lcdfilter = FT_LCD_FILTER_DEFAULT;
6065             FT_Render_Mode render_mode =
6066                 (format == WINE_GGO_HRGB_BITMAP || format == WINE_GGO_HBGR_BITMAP)?
6067                     FT_RENDER_MODE_LCD: FT_RENDER_MODE_LCD_V;
6068
6069             if ( lcdfilter == FT_LCD_FILTER_DEFAULT || lcdfilter == FT_LCD_FILTER_LIGHT )
6070             {
6071                 if ( render_mode == FT_RENDER_MODE_LCD)
6072                 {
6073                     lpgm->gmBlackBoxX += 2;
6074                     lpgm->gmptGlyphOrigin.x -= 1;
6075                 }
6076                 else
6077                 {
6078                     lpgm->gmBlackBoxY += 2;
6079                     lpgm->gmptGlyphOrigin.y += 1;
6080                 }
6081             }
6082
6083             width  = lpgm->gmBlackBoxX;
6084             height = lpgm->gmBlackBoxY;
6085             pitch  = width * 4;
6086             needed = pitch * height;
6087
6088             if (!buf || !buflen) break;
6089
6090             memset(buf, 0, buflen);
6091             dst = buf;
6092             rgb = (format == WINE_GGO_HRGB_BITMAP || format == WINE_GGO_VRGB_BITMAP);
6093
6094             if ( needsTransform )
6095                 pFT_Outline_Transform (&ft_face->glyph->outline, &transMat);
6096
6097             if ( pFT_Library_SetLcdFilter )
6098                 pFT_Library_SetLcdFilter( library, lcdfilter );
6099             pFT_Render_Glyph (ft_face->glyph, render_mode);
6100
6101             src = ft_face->glyph->bitmap.buffer;
6102             src_pitch = ft_face->glyph->bitmap.pitch;
6103             src_width = ft_face->glyph->bitmap.width;
6104             src_height = ft_face->glyph->bitmap.rows;
6105
6106             if ( render_mode == FT_RENDER_MODE_LCD)
6107             {
6108                 rgb_interval = 1;
6109                 hmul = 3;
6110                 vmul = 1;
6111             }
6112             else
6113             {
6114                 rgb_interval = src_pitch;
6115                 hmul = 1;
6116                 vmul = 3;
6117             }
6118
6119             x_shift = ft_face->glyph->bitmap_left - lpgm->gmptGlyphOrigin.x;
6120             if ( x_shift < 0 ) x_shift = 0;
6121             if ( x_shift + (src_width / hmul) > width )
6122                 x_shift = width - (src_width / hmul);
6123
6124             y_shift = lpgm->gmptGlyphOrigin.y - ft_face->glyph->bitmap_top;
6125             if ( y_shift < 0 ) y_shift = 0;
6126             if ( y_shift + (src_height / vmul) > height )
6127                 y_shift = height - (src_height / vmul);
6128
6129             dst += x_shift + y_shift * ( pitch / 4 );
6130             while ( src_height )
6131             {
6132                 for ( x = 0; x < src_width / hmul; x++ )
6133                 {
6134                     if ( rgb )
6135                     {
6136                         dst[x] = ((unsigned int)src[hmul * x + rgb_interval * 0] << 16) |
6137                                  ((unsigned int)src[hmul * x + rgb_interval * 1] <<  8) |
6138                                  ((unsigned int)src[hmul * x + rgb_interval * 2] <<  0) |
6139                                  ((unsigned int)src[hmul * x + rgb_interval * 1] << 24) ;
6140                     }
6141                     else
6142                     {
6143                         dst[x] = ((unsigned int)src[hmul * x + rgb_interval * 2] << 16) |
6144                                  ((unsigned int)src[hmul * x + rgb_interval * 1] <<  8) |
6145                                  ((unsigned int)src[hmul * x + rgb_interval * 0] <<  0) |
6146                                  ((unsigned int)src[hmul * x + rgb_interval * 1] << 24) ;
6147                     }
6148                 }
6149                 src += src_pitch * vmul;
6150                 dst += pitch / 4;
6151                 src_height -= vmul;
6152             }
6153
6154             break;
6155           }
6156
6157         default:
6158             FIXME ("loaded glyph format %x\n", ft_face->glyph->format);
6159             return GDI_ERROR;
6160         }
6161
6162         break;
6163       }
6164 #else
6165       return GDI_ERROR;
6166 #endif
6167
6168     case GGO_NATIVE:
6169       {
6170         int contour, point = 0, first_pt;
6171         FT_Outline *outline = &ft_face->glyph->outline;
6172         TTPOLYGONHEADER *pph;
6173         TTPOLYCURVE *ppc;
6174         DWORD pph_start, cpfx, type;
6175
6176         if(buflen == 0) buf = NULL;
6177
6178         if (needsTransform && buf) {
6179                 pFT_Outline_Transform(outline, &transMat);
6180         }
6181
6182         for(contour = 0; contour < outline->n_contours; contour++) {
6183             pph_start = needed;
6184             pph = (TTPOLYGONHEADER *)((char *)buf + needed);
6185             first_pt = point;
6186             if(buf) {
6187                 pph->dwType = TT_POLYGON_TYPE;
6188                 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
6189             }
6190             needed += sizeof(*pph);
6191             point++;
6192             while(point <= outline->contours[contour]) {
6193                 ppc = (TTPOLYCURVE *)((char *)buf + needed);
6194                 type = (outline->tags[point] & FT_Curve_Tag_On) ?
6195                   TT_PRIM_LINE : TT_PRIM_QSPLINE;
6196                 cpfx = 0;
6197                 do {
6198                     if(buf)
6199                         FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
6200                     cpfx++;
6201                     point++;
6202                 } while(point <= outline->contours[contour] &&
6203                         (outline->tags[point] & FT_Curve_Tag_On) ==
6204                         (outline->tags[point-1] & FT_Curve_Tag_On));
6205                 /* At the end of a contour Windows adds the start point, but
6206                    only for Beziers */
6207                 if(point > outline->contours[contour] &&
6208                    !(outline->tags[point-1] & FT_Curve_Tag_On)) {
6209                     if(buf)
6210                         FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
6211                     cpfx++;
6212                 } else if(point <= outline->contours[contour] &&
6213                           outline->tags[point] & FT_Curve_Tag_On) {
6214                   /* add closing pt for bezier */
6215                     if(buf)
6216                         FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
6217                     cpfx++;
6218                     point++;
6219                 }
6220                 if(buf) {
6221                     ppc->wType = type;
6222                     ppc->cpfx = cpfx;
6223                 }
6224                 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
6225             }
6226             if(buf)
6227                 pph->cb = needed - pph_start;
6228         }
6229         break;
6230       }
6231     case GGO_BEZIER:
6232       {
6233         /* Convert the quadratic Beziers to cubic Beziers.
6234            The parametric eqn for a cubic Bezier is, from PLRM:
6235            r(t) = at^3 + bt^2 + ct + r0
6236            with the control points:
6237            r1 = r0 + c/3
6238            r2 = r1 + (c + b)/3
6239            r3 = r0 + c + b + a
6240
6241            A quadratic Bezier has the form:
6242            p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
6243
6244            So equating powers of t leads to:
6245            r1 = 2/3 p1 + 1/3 p0
6246            r2 = 2/3 p1 + 1/3 p2
6247            and of course r0 = p0, r3 = p2
6248         */
6249
6250         int contour, point = 0, first_pt;
6251         FT_Outline *outline = &ft_face->glyph->outline;
6252         TTPOLYGONHEADER *pph;
6253         TTPOLYCURVE *ppc;
6254         DWORD pph_start, cpfx, type;
6255         FT_Vector cubic_control[4];
6256         if(buflen == 0) buf = NULL;
6257
6258         if (needsTransform && buf) {
6259                 pFT_Outline_Transform(outline, &transMat);
6260         }
6261
6262         for(contour = 0; contour < outline->n_contours; contour++) {
6263             pph_start = needed;
6264             pph = (TTPOLYGONHEADER *)((char *)buf + needed);
6265             first_pt = point;
6266             if(buf) {
6267                 pph->dwType = TT_POLYGON_TYPE;
6268                 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
6269             }
6270             needed += sizeof(*pph);
6271             point++;
6272             while(point <= outline->contours[contour]) {
6273                 ppc = (TTPOLYCURVE *)((char *)buf + needed);
6274                 type = (outline->tags[point] & FT_Curve_Tag_On) ?
6275                   TT_PRIM_LINE : TT_PRIM_CSPLINE;
6276                 cpfx = 0;
6277                 do {
6278                     if(type == TT_PRIM_LINE) {
6279                         if(buf)
6280                             FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
6281                         cpfx++;
6282                         point++;
6283                     } else {
6284                       /* Unlike QSPLINEs, CSPLINEs always have their endpoint
6285                          so cpfx = 3n */
6286
6287                       /* FIXME: Possible optimization in endpoint calculation
6288                          if there are two consecutive curves */
6289                         cubic_control[0] = outline->points[point-1];
6290                         if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
6291                             cubic_control[0].x += outline->points[point].x + 1;
6292                             cubic_control[0].y += outline->points[point].y + 1;
6293                             cubic_control[0].x >>= 1;
6294                             cubic_control[0].y >>= 1;
6295                         }
6296                         if(point+1 > outline->contours[contour])
6297                             cubic_control[3] = outline->points[first_pt];
6298                         else {
6299                             cubic_control[3] = outline->points[point+1];
6300                             if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
6301                                 cubic_control[3].x += outline->points[point].x + 1;
6302                                 cubic_control[3].y += outline->points[point].y + 1;
6303                                 cubic_control[3].x >>= 1;
6304                                 cubic_control[3].y >>= 1;
6305                             }
6306                         }
6307                         /* r1 = 1/3 p0 + 2/3 p1
6308                            r2 = 1/3 p2 + 2/3 p1 */
6309                         cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
6310                         cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
6311                         cubic_control[2] = cubic_control[1];
6312                         cubic_control[1].x += (cubic_control[0].x + 1) / 3;
6313                         cubic_control[1].y += (cubic_control[0].y + 1) / 3;
6314                         cubic_control[2].x += (cubic_control[3].x + 1) / 3;
6315                         cubic_control[2].y += (cubic_control[3].y + 1) / 3;
6316                         if(buf) {
6317                             FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
6318                             FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
6319                             FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
6320                         }
6321                         cpfx += 3;
6322                         point++;
6323                     }
6324                 } while(point <= outline->contours[contour] &&
6325                         (outline->tags[point] & FT_Curve_Tag_On) ==
6326                         (outline->tags[point-1] & FT_Curve_Tag_On));
6327                 /* At the end of a contour Windows adds the start point,
6328                    but only for Beziers and we've already done that.
6329                 */
6330                 if(point <= outline->contours[contour] &&
6331                    outline->tags[point] & FT_Curve_Tag_On) {
6332                   /* This is the closing pt of a bezier, but we've already
6333                      added it, so just inc point and carry on */
6334                     point++;
6335                 }
6336                 if(buf) {
6337                     ppc->wType = type;
6338                     ppc->cpfx = cpfx;
6339                 }
6340                 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
6341             }
6342             if(buf)
6343                 pph->cb = needed - pph_start;
6344         }
6345         break;
6346       }
6347
6348     default:
6349         FIXME("Unsupported format %d\n", format);
6350         return GDI_ERROR;
6351     }
6352     return needed;
6353 }
6354
6355 static BOOL get_bitmap_text_metrics(GdiFont *font)
6356 {
6357     FT_Face ft_face = font->ft_face;
6358     FT_WinFNT_HeaderRec winfnt_header;
6359     const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
6360     font->potm = HeapAlloc(GetProcessHeap(), 0, size);
6361     font->potm->otmSize = size;
6362
6363 #define TM font->potm->otmTextMetrics
6364     if(!pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
6365     {
6366         TM.tmHeight = winfnt_header.pixel_height;
6367         TM.tmAscent = winfnt_header.ascent;
6368         TM.tmDescent = TM.tmHeight - TM.tmAscent;
6369         TM.tmInternalLeading = winfnt_header.internal_leading;
6370         TM.tmExternalLeading = winfnt_header.external_leading;
6371         TM.tmAveCharWidth = winfnt_header.avg_width;
6372         TM.tmMaxCharWidth = winfnt_header.max_width;
6373         TM.tmWeight = winfnt_header.weight;
6374         TM.tmOverhang = 0;
6375         TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
6376         TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
6377         TM.tmFirstChar = winfnt_header.first_char;
6378         TM.tmLastChar = winfnt_header.last_char;
6379         TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
6380         TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
6381         TM.tmItalic = winfnt_header.italic;
6382         TM.tmUnderlined = font->underline;
6383         TM.tmStruckOut = font->strikeout;
6384         TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
6385         TM.tmCharSet = winfnt_header.charset;
6386     }
6387     else
6388     {
6389         TM.tmAscent = ft_face->size->metrics.ascender >> 6;
6390         TM.tmDescent = -ft_face->size->metrics.descender >> 6;
6391         TM.tmHeight = TM.tmAscent + TM.tmDescent;
6392         TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
6393         TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
6394         TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
6395         TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
6396         TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
6397         TM.tmOverhang = 0;
6398         TM.tmDigitizedAspectX = 96; /* FIXME */
6399         TM.tmDigitizedAspectY = 96; /* FIXME */
6400         TM.tmFirstChar = 1;
6401         TM.tmLastChar = 255;
6402         TM.tmDefaultChar = 32;
6403         TM.tmBreakChar = 32;
6404         TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
6405         TM.tmUnderlined = font->underline;
6406         TM.tmStruckOut = font->strikeout;
6407         /* NB inverted meaning of TMPF_FIXED_PITCH */
6408         TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
6409         TM.tmCharSet = font->charset;
6410     }
6411 #undef TM
6412
6413     return TRUE;
6414 }
6415
6416
6417 static void scale_font_metrics(const GdiFont *font, LPTEXTMETRICW ptm)
6418 {
6419     double scale_x, scale_y;
6420
6421     if (font->aveWidth)
6422     {
6423         scale_x = (double)font->aveWidth;
6424         scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
6425     }
6426     else
6427         scale_x = font->scale_y;
6428
6429     scale_x *= fabs(font->font_desc.matrix.eM11);
6430     scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
6431
6432 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
6433 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
6434
6435     SCALE_Y(ptm->tmHeight);
6436     SCALE_Y(ptm->tmAscent);
6437     SCALE_Y(ptm->tmDescent);
6438     SCALE_Y(ptm->tmInternalLeading);
6439     SCALE_Y(ptm->tmExternalLeading);
6440     SCALE_Y(ptm->tmOverhang);
6441
6442     SCALE_X(ptm->tmAveCharWidth);
6443     SCALE_X(ptm->tmMaxCharWidth);
6444
6445 #undef SCALE_X
6446 #undef SCALE_Y
6447 }
6448
6449 static void scale_outline_font_metrics(const GdiFont *font, OUTLINETEXTMETRICW *potm)
6450 {
6451     double scale_x, scale_y;
6452
6453     if (font->aveWidth)
6454     {
6455         scale_x = (double)font->aveWidth;
6456         scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
6457     }
6458     else
6459         scale_x = font->scale_y;
6460
6461     scale_x *= fabs(font->font_desc.matrix.eM11);
6462     scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
6463
6464     scale_font_metrics(font, &potm->otmTextMetrics);
6465
6466 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
6467 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
6468
6469     SCALE_Y(potm->otmAscent);
6470     SCALE_Y(potm->otmDescent);
6471     SCALE_Y(potm->otmLineGap);
6472     SCALE_Y(potm->otmsCapEmHeight);
6473     SCALE_Y(potm->otmsXHeight);
6474     SCALE_Y(potm->otmrcFontBox.top);
6475     SCALE_Y(potm->otmrcFontBox.bottom);
6476     SCALE_X(potm->otmrcFontBox.left);
6477     SCALE_X(potm->otmrcFontBox.right);
6478     SCALE_Y(potm->otmMacAscent);
6479     SCALE_Y(potm->otmMacDescent);
6480     SCALE_Y(potm->otmMacLineGap);
6481     SCALE_X(potm->otmptSubscriptSize.x);
6482     SCALE_Y(potm->otmptSubscriptSize.y);
6483     SCALE_X(potm->otmptSubscriptOffset.x);
6484     SCALE_Y(potm->otmptSubscriptOffset.y);
6485     SCALE_X(potm->otmptSuperscriptSize.x);
6486     SCALE_Y(potm->otmptSuperscriptSize.y);
6487     SCALE_X(potm->otmptSuperscriptOffset.x);
6488     SCALE_Y(potm->otmptSuperscriptOffset.y);
6489     SCALE_Y(potm->otmsStrikeoutSize);
6490     SCALE_Y(potm->otmsStrikeoutPosition);
6491     SCALE_Y(potm->otmsUnderscoreSize);
6492     SCALE_Y(potm->otmsUnderscorePosition);
6493
6494 #undef SCALE_X
6495 #undef SCALE_Y
6496 }
6497
6498 static BOOL get_text_metrics(GdiFont *font, LPTEXTMETRICW ptm)
6499 {
6500     if(!font->potm)
6501     {
6502         if (!get_outline_text_metrics(font) && !get_bitmap_text_metrics(font)) return FALSE;
6503
6504         /* Make sure that the font has sane width/height ratio */
6505         if (font->aveWidth)
6506         {
6507             if ((font->aveWidth + font->potm->otmTextMetrics.tmHeight - 1) / font->potm->otmTextMetrics.tmHeight > 100)
6508             {
6509                 WARN("Ignoring too large font->aveWidth %d\n", font->aveWidth);
6510                 font->aveWidth = 0;
6511             }
6512         }
6513     }
6514     *ptm = font->potm->otmTextMetrics;
6515     scale_font_metrics(font, ptm);
6516     return TRUE;
6517 }
6518
6519 static BOOL face_has_symbol_charmap(FT_Face ft_face)
6520 {
6521     int i;
6522
6523     for(i = 0; i < ft_face->num_charmaps; i++)
6524     {
6525         if(ft_face->charmaps[i]->encoding == FT_ENCODING_MS_SYMBOL)
6526             return TRUE;
6527     }
6528     return FALSE;
6529 }
6530
6531 static BOOL get_outline_text_metrics(GdiFont *font)
6532 {
6533     BOOL ret = FALSE;
6534     FT_Face ft_face = font->ft_face;
6535     UINT needed, lenfam, lensty;
6536     TT_OS2 *pOS2;
6537     TT_HoriHeader *pHori;
6538     TT_Postscript *pPost;
6539     FT_Fixed x_scale, y_scale;
6540     WCHAR *family_nameW, *style_nameW;
6541     static const WCHAR spaceW[] = {' ', '\0'};
6542     char *cp;
6543     INT ascent, descent;
6544
6545     TRACE("font=%p\n", font);
6546
6547     if(!FT_IS_SCALABLE(ft_face))
6548         return FALSE;
6549
6550     needed = sizeof(*font->potm);
6551
6552     lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
6553     family_nameW = strdupW(font->name);
6554
6555     lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
6556       * sizeof(WCHAR);
6557     style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
6558     MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
6559                         style_nameW, lensty/sizeof(WCHAR));
6560
6561     /* These names should be read from the TT name table */
6562
6563     /* length of otmpFamilyName */
6564     needed += lenfam;
6565
6566     /* length of otmpFaceName */
6567     if ((ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) == 0) {
6568       needed += lenfam; /* just the family name */
6569     } else {
6570       needed += lenfam + lensty; /* family + " " + style */
6571     }
6572
6573     /* length of otmpStyleName */
6574     needed += lensty;
6575
6576     /* length of otmpFullName */
6577     needed += lenfam + lensty;
6578
6579
6580     x_scale = ft_face->size->metrics.x_scale;
6581     y_scale = ft_face->size->metrics.y_scale;
6582
6583     pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
6584     if(!pOS2) {
6585         FIXME("Can't find OS/2 table - not TT font?\n");
6586         goto end;
6587     }
6588
6589     pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
6590     if(!pHori) {
6591         FIXME("Can't find HHEA table - not TT font?\n");
6592         goto end;
6593     }
6594
6595     pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
6596
6597     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",
6598           pOS2->usWinAscent, pOS2->usWinDescent,
6599           pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
6600           ft_face->ascender, ft_face->descender, ft_face->height,
6601           pHori->Ascender, pHori->Descender, pHori->Line_Gap,
6602           ft_face->bbox.yMax, ft_face->bbox.yMin);
6603
6604     font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
6605     font->potm->otmSize = needed;
6606
6607 #define TM font->potm->otmTextMetrics
6608
6609     if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
6610         ascent = pHori->Ascender;
6611         descent = -pHori->Descender;
6612     } else {
6613         ascent = pOS2->usWinAscent;
6614         descent = pOS2->usWinDescent;
6615     }
6616
6617     if(font->yMax) {
6618         TM.tmAscent = font->yMax;
6619         TM.tmDescent = -font->yMin;
6620         TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
6621     } else {
6622         TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
6623         TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
6624         TM.tmInternalLeading = (pFT_MulFix(ascent + descent
6625                                             - ft_face->units_per_EM, y_scale) + 32) >> 6;
6626     }
6627
6628     TM.tmHeight = TM.tmAscent + TM.tmDescent;
6629
6630     /* MSDN says:
6631      el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
6632     */
6633     TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
6634                  ((ascent + descent) -
6635                   (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
6636
6637     TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
6638     if (TM.tmAveCharWidth == 0) {
6639         TM.tmAveCharWidth = 1;
6640     }
6641     TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
6642     TM.tmWeight = FW_REGULAR;
6643     if (font->fake_bold)
6644         TM.tmWeight = FW_BOLD;
6645     else
6646     {
6647         if (ft_face->style_flags & FT_STYLE_FLAG_BOLD)
6648         {
6649             if (pOS2->usWeightClass > FW_MEDIUM)
6650                 TM.tmWeight = pOS2->usWeightClass;
6651         }
6652         else if (pOS2->usWeightClass <= FW_MEDIUM)
6653             TM.tmWeight = pOS2->usWeightClass;
6654     }
6655     TM.tmOverhang = 0;
6656     TM.tmDigitizedAspectX = 300;
6657     TM.tmDigitizedAspectY = 300;
6658     /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
6659      * symbol range to 0 - f0ff
6660      */
6661
6662     if (face_has_symbol_charmap(ft_face) || (pOS2->usFirstCharIndex >= 0xf000 && pOS2->usFirstCharIndex < 0xf100))
6663     {
6664         TM.tmFirstChar = 0;
6665         switch(GetACP())
6666         {
6667         case 1257: /* Baltic */
6668             TM.tmLastChar = 0xf8fd;
6669             break;
6670         default:
6671             TM.tmLastChar = 0xf0ff;
6672         }
6673         TM.tmBreakChar = 0x20;
6674         TM.tmDefaultChar = 0x1f;
6675     }
6676     else
6677     {
6678         TM.tmFirstChar = pOS2->usFirstCharIndex; /* Should be the first char in the cmap */
6679         TM.tmLastChar = pOS2->usLastCharIndex;   /* Should be min(cmap_last, os2_last) */
6680
6681         if(pOS2->usFirstCharIndex <= 1)
6682             TM.tmBreakChar = pOS2->usFirstCharIndex + 2;
6683         else if (pOS2->usFirstCharIndex > 0xff)
6684             TM.tmBreakChar = 0x20;
6685         else
6686             TM.tmBreakChar = pOS2->usFirstCharIndex;
6687         TM.tmDefaultChar = TM.tmBreakChar - 1;
6688     }
6689     TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
6690     TM.tmUnderlined = font->underline;
6691     TM.tmStruckOut = font->strikeout;
6692
6693     /* Yes TPMF_FIXED_PITCH is correct; braindead api */
6694     if(!FT_IS_FIXED_WIDTH(ft_face) &&
6695        (pOS2->version == 0xFFFFU ||
6696         pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
6697         TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
6698     else
6699         TM.tmPitchAndFamily = 0;
6700
6701     switch(pOS2->panose[PAN_FAMILYTYPE_INDEX])
6702     {
6703     case PAN_FAMILY_SCRIPT:
6704         TM.tmPitchAndFamily |= FF_SCRIPT;
6705         break;
6706
6707     case PAN_FAMILY_DECORATIVE:
6708         TM.tmPitchAndFamily |= FF_DECORATIVE;
6709         break;
6710
6711     case PAN_ANY:
6712     case PAN_NO_FIT:
6713     case PAN_FAMILY_TEXT_DISPLAY:
6714     case PAN_FAMILY_PICTORIAL: /* symbol fonts get treated as if they were text */
6715                                /* which is clearly not what the panose spec says. */
6716     default:
6717         if(TM.tmPitchAndFamily == 0 || /* fixed */
6718            pOS2->panose[PAN_PROPORTION_INDEX] == PAN_PROP_MONOSPACED)
6719             TM.tmPitchAndFamily = FF_MODERN;
6720         else
6721         {
6722             switch(pOS2->panose[PAN_SERIFSTYLE_INDEX])
6723             {
6724             case PAN_ANY:
6725             case PAN_NO_FIT:
6726             default:
6727                 TM.tmPitchAndFamily |= FF_DONTCARE;
6728                 break;
6729
6730             case PAN_SERIF_COVE:
6731             case PAN_SERIF_OBTUSE_COVE:
6732             case PAN_SERIF_SQUARE_COVE:
6733             case PAN_SERIF_OBTUSE_SQUARE_COVE:
6734             case PAN_SERIF_SQUARE:
6735             case PAN_SERIF_THIN:
6736             case PAN_SERIF_BONE:
6737             case PAN_SERIF_EXAGGERATED:
6738             case PAN_SERIF_TRIANGLE:
6739                 TM.tmPitchAndFamily |= FF_ROMAN;
6740                 break;
6741
6742             case PAN_SERIF_NORMAL_SANS:
6743             case PAN_SERIF_OBTUSE_SANS:
6744             case PAN_SERIF_PERP_SANS:
6745             case PAN_SERIF_FLARED:
6746             case PAN_SERIF_ROUNDED:
6747                 TM.tmPitchAndFamily |= FF_SWISS;
6748                 break;
6749             }
6750         }
6751         break;
6752     }
6753
6754     if(FT_IS_SCALABLE(ft_face))
6755         TM.tmPitchAndFamily |= TMPF_VECTOR;
6756
6757     if(FT_IS_SFNT(ft_face))
6758     {
6759         if (font->ntmFlags & NTM_PS_OPENTYPE)
6760             TM.tmPitchAndFamily |= TMPF_DEVICE;
6761         else
6762             TM.tmPitchAndFamily |= TMPF_TRUETYPE;
6763     }
6764
6765     TM.tmCharSet = font->charset;
6766
6767     font->potm->otmFiller = 0;
6768     memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
6769     font->potm->otmfsSelection = pOS2->fsSelection;
6770     font->potm->otmfsType = pOS2->fsType;
6771     font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
6772     font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
6773     font->potm->otmItalicAngle = 0; /* POST table */
6774     font->potm->otmEMSquare = ft_face->units_per_EM;
6775     font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
6776     font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
6777     font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
6778     font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
6779     font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
6780     font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
6781     font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
6782     font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
6783     font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
6784     font->potm->otmMacAscent = TM.tmAscent;
6785     font->potm->otmMacDescent = -TM.tmDescent;
6786     font->potm->otmMacLineGap = font->potm->otmLineGap;
6787     font->potm->otmusMinimumPPEM = 0; /* TT Header */
6788     font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
6789     font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
6790     font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
6791     font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
6792     font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
6793     font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
6794     font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
6795     font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
6796     font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
6797     font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
6798     if(!pPost) {
6799         font->potm->otmsUnderscoreSize = 0;
6800         font->potm->otmsUnderscorePosition = 0;
6801     } else {
6802         font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
6803         font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
6804     }
6805 #undef TM
6806
6807     /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
6808     cp = (char*)font->potm + sizeof(*font->potm);
6809     font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
6810     strcpyW((WCHAR*)cp, family_nameW);
6811     cp += lenfam;
6812     font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
6813     strcpyW((WCHAR*)cp, style_nameW);
6814     cp += lensty;
6815     font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
6816     strcpyW((WCHAR*)cp, family_nameW);
6817     if (ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) {
6818         strcatW((WCHAR*)cp, spaceW);
6819         strcatW((WCHAR*)cp, style_nameW);
6820         cp += lenfam + lensty;
6821     } else
6822         cp += lenfam;
6823     font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
6824     strcpyW((WCHAR*)cp, family_nameW);
6825     strcatW((WCHAR*)cp, spaceW);
6826     strcatW((WCHAR*)cp, style_nameW);
6827     ret = TRUE;
6828
6829 end:
6830     HeapFree(GetProcessHeap(), 0, style_nameW);
6831     HeapFree(GetProcessHeap(), 0, family_nameW);
6832     return ret;
6833 }
6834
6835 /*************************************************************
6836  * freetype_GetGlyphOutline
6837  */
6838 static DWORD freetype_GetGlyphOutline( PHYSDEV dev, UINT glyph, UINT format,
6839                                        LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf, const MAT2 *lpmat )
6840 {
6841     struct freetype_physdev *physdev = get_freetype_dev( dev );
6842     DWORD ret;
6843
6844     if (!physdev->font)
6845     {
6846         dev = GET_NEXT_PHYSDEV( dev, pGetGlyphOutline );
6847         return dev->funcs->pGetGlyphOutline( dev, glyph, format, lpgm, buflen, buf, lpmat );
6848     }
6849
6850     GDI_CheckNotLock();
6851     EnterCriticalSection( &freetype_cs );
6852     ret = get_glyph_outline( physdev->font, glyph, format, lpgm, buflen, buf, lpmat );
6853     LeaveCriticalSection( &freetype_cs );
6854     return ret;
6855 }
6856
6857 /*************************************************************
6858  * freetype_GetTextMetrics
6859  */
6860 static BOOL freetype_GetTextMetrics( PHYSDEV dev, TEXTMETRICW *metrics )
6861 {
6862     struct freetype_physdev *physdev = get_freetype_dev( dev );
6863     BOOL ret;
6864
6865     if (!physdev->font)
6866     {
6867         dev = GET_NEXT_PHYSDEV( dev, pGetTextMetrics );
6868         return dev->funcs->pGetTextMetrics( dev, metrics );
6869     }
6870
6871     GDI_CheckNotLock();
6872     EnterCriticalSection( &freetype_cs );
6873     ret = get_text_metrics( physdev->font, metrics );
6874     LeaveCriticalSection( &freetype_cs );
6875     return ret;
6876 }
6877
6878 /*************************************************************
6879  * freetype_GetOutlineTextMetrics
6880  */
6881 static UINT freetype_GetOutlineTextMetrics( PHYSDEV dev, UINT cbSize, OUTLINETEXTMETRICW *potm )
6882 {
6883     struct freetype_physdev *physdev = get_freetype_dev( dev );
6884     UINT ret = 0;
6885
6886     if (!physdev->font)
6887     {
6888         dev = GET_NEXT_PHYSDEV( dev, pGetOutlineTextMetrics );
6889         return dev->funcs->pGetOutlineTextMetrics( dev, cbSize, potm );
6890     }
6891
6892     TRACE("font=%p\n", physdev->font);
6893
6894     if (!FT_IS_SCALABLE( physdev->font->ft_face )) return 0;
6895
6896     GDI_CheckNotLock();
6897     EnterCriticalSection( &freetype_cs );
6898
6899     if (physdev->font->potm || get_outline_text_metrics( physdev->font ))
6900     {
6901         if(cbSize >= physdev->font->potm->otmSize)
6902         {
6903             memcpy(potm, physdev->font->potm, physdev->font->potm->otmSize);
6904             scale_outline_font_metrics(physdev->font, potm);
6905         }
6906         ret = physdev->font->potm->otmSize;
6907     }
6908     LeaveCriticalSection( &freetype_cs );
6909     return ret;
6910 }
6911
6912 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
6913 {
6914     HFONTLIST *hfontlist;
6915     child->font = alloc_font();
6916     child->font->ft_face = OpenFontFace(child->font, child->face, 0, -font->ppem);
6917     if(!child->font->ft_face)
6918     {
6919         free_font(child->font);
6920         child->font = NULL;
6921         return FALSE;
6922     }
6923
6924     child->font->font_desc = font->font_desc;
6925     child->font->ntmFlags = child->face->ntmFlags;
6926     child->font->orientation = font->orientation;
6927     child->font->scale_y = font->scale_y;
6928     hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
6929     hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
6930     child->font->name = strdupW(child->face->family->FamilyName);
6931     list_add_head(&child->font->hfontlist, &hfontlist->entry);
6932     child->font->base_font = font;
6933     list_add_head(&child_font_list, &child->font->entry);
6934     TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
6935     return TRUE;
6936 }
6937
6938 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
6939 {
6940     FT_UInt g;
6941     CHILD_FONT *child_font;
6942
6943     if(font->base_font)
6944         font = font->base_font;
6945
6946     *linked_font = font;
6947
6948     if((*glyph = get_glyph_index(font, c)))
6949     {
6950         *glyph = get_GSUB_vert_glyph(font, *glyph);
6951         return TRUE;
6952     }
6953
6954     LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
6955     {
6956         if(!child_font->font)
6957             if(!load_child_font(font, child_font))
6958                 continue;
6959
6960         if(!child_font->font->ft_face)
6961             continue;
6962         g = get_glyph_index(child_font->font, c);
6963         g = get_GSUB_vert_glyph(child_font->font, g);
6964         if(g)
6965         {
6966             *glyph = g;
6967             *linked_font = child_font->font;
6968             return TRUE;
6969         }
6970     }
6971     return FALSE;
6972 }
6973
6974 /*************************************************************
6975  * freetype_GetCharWidth
6976  */
6977 static BOOL freetype_GetCharWidth( PHYSDEV dev, UINT firstChar, UINT lastChar, LPINT buffer )
6978 {
6979     static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
6980     UINT c;
6981     GLYPHMETRICS gm;
6982     FT_UInt glyph_index;
6983     GdiFont *linked_font;
6984     struct freetype_physdev *physdev = get_freetype_dev( dev );
6985
6986     if (!physdev->font)
6987     {
6988         dev = GET_NEXT_PHYSDEV( dev, pGetCharWidth );
6989         return dev->funcs->pGetCharWidth( dev, firstChar, lastChar, buffer );
6990     }
6991
6992     TRACE("%p, %d, %d, %p\n", physdev->font, firstChar, lastChar, buffer);
6993
6994     GDI_CheckNotLock();
6995     EnterCriticalSection( &freetype_cs );
6996     for(c = firstChar; c <= lastChar; c++) {
6997         get_glyph_index_linked(physdev->font, c, &linked_font, &glyph_index);
6998         get_glyph_outline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
6999                           &gm, 0, NULL, &identity);
7000         buffer[c - firstChar] = FONT_GM(linked_font,glyph_index)->adv;
7001     }
7002     LeaveCriticalSection( &freetype_cs );
7003     return TRUE;
7004 }
7005
7006 /*************************************************************
7007  * freetype_GetCharABCWidths
7008  */
7009 static BOOL freetype_GetCharABCWidths( PHYSDEV dev, UINT firstChar, UINT lastChar, LPABC buffer )
7010 {
7011     static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7012     UINT c;
7013     GLYPHMETRICS gm;
7014     FT_UInt glyph_index;
7015     GdiFont *linked_font;
7016     struct freetype_physdev *physdev = get_freetype_dev( dev );
7017
7018     if (!physdev->font)
7019     {
7020         dev = GET_NEXT_PHYSDEV( dev, pGetCharABCWidths );
7021         return dev->funcs->pGetCharABCWidths( dev, firstChar, lastChar, buffer );
7022     }
7023
7024     TRACE("%p, %d, %d, %p\n", physdev->font, firstChar, lastChar, buffer);
7025
7026     GDI_CheckNotLock();
7027     EnterCriticalSection( &freetype_cs );
7028
7029     for(c = firstChar; c <= lastChar; c++) {
7030         get_glyph_index_linked(physdev->font, c, &linked_font, &glyph_index);
7031         get_glyph_outline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
7032                           &gm, 0, NULL, &identity);
7033         buffer[c - firstChar].abcA = FONT_GM(linked_font,glyph_index)->lsb;
7034         buffer[c - firstChar].abcB = FONT_GM(linked_font,glyph_index)->bbx;
7035         buffer[c - firstChar].abcC = FONT_GM(linked_font,glyph_index)->adv - FONT_GM(linked_font,glyph_index)->lsb -
7036             FONT_GM(linked_font,glyph_index)->bbx;
7037     }
7038     LeaveCriticalSection( &freetype_cs );
7039     return TRUE;
7040 }
7041
7042 /*************************************************************
7043  * freetype_GetCharABCWidthsI
7044  */
7045 static BOOL freetype_GetCharABCWidthsI( PHYSDEV dev, UINT firstChar, UINT count, LPWORD pgi, LPABC buffer )
7046 {
7047     static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7048     UINT c;
7049     GLYPHMETRICS gm;
7050     FT_UInt glyph_index;
7051     GdiFont *linked_font;
7052     struct freetype_physdev *physdev = get_freetype_dev( dev );
7053
7054     if (!physdev->font)
7055     {
7056         dev = GET_NEXT_PHYSDEV( dev, pGetCharABCWidthsI );
7057         return dev->funcs->pGetCharABCWidthsI( dev, firstChar, count, pgi, buffer );
7058     }
7059
7060     if(!FT_HAS_HORIZONTAL(physdev->font->ft_face))
7061         return FALSE;
7062
7063     GDI_CheckNotLock();
7064     EnterCriticalSection( &freetype_cs );
7065
7066     get_glyph_index_linked(physdev->font, 'a', &linked_font, &glyph_index);
7067     if (!pgi)
7068         for(c = firstChar; c < firstChar+count; c++) {
7069             get_glyph_outline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
7070                               &gm, 0, NULL, &identity);
7071             buffer[c - firstChar].abcA = FONT_GM(linked_font,c)->lsb;
7072             buffer[c - firstChar].abcB = FONT_GM(linked_font,c)->bbx;
7073             buffer[c - firstChar].abcC = FONT_GM(linked_font,c)->adv - FONT_GM(linked_font,c)->lsb
7074                 - FONT_GM(linked_font,c)->bbx;
7075         }
7076     else
7077         for(c = 0; c < count; c++) {
7078             get_glyph_outline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
7079                               &gm, 0, NULL, &identity);
7080             buffer[c].abcA = FONT_GM(linked_font,pgi[c])->lsb;
7081             buffer[c].abcB = FONT_GM(linked_font,pgi[c])->bbx;
7082             buffer[c].abcC = FONT_GM(linked_font,pgi[c])->adv
7083                 - FONT_GM(linked_font,pgi[c])->lsb - FONT_GM(linked_font,pgi[c])->bbx;
7084         }
7085
7086     LeaveCriticalSection( &freetype_cs );
7087     return TRUE;
7088 }
7089
7090 /*************************************************************
7091  * freetype_GetTextExtentExPoint
7092  */
7093 static BOOL freetype_GetTextExtentExPoint( PHYSDEV dev, LPCWSTR wstr, INT count,
7094                                            INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
7095 {
7096     static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7097     INT idx;
7098     INT nfit = 0, ext;
7099     GLYPHMETRICS gm;
7100     TEXTMETRICW tm;
7101     FT_UInt glyph_index;
7102     GdiFont *linked_font;
7103     struct freetype_physdev *physdev = get_freetype_dev( dev );
7104
7105     if (!physdev->font)
7106     {
7107         dev = GET_NEXT_PHYSDEV( dev, pGetTextExtentExPoint );
7108         return dev->funcs->pGetTextExtentExPoint( dev, wstr, count, max_ext, pnfit, dxs, size );
7109     }
7110
7111     TRACE("%p, %s, %d, %d, %p\n", physdev->font, debugstr_wn(wstr, count), count, max_ext, size);
7112
7113     GDI_CheckNotLock();
7114     EnterCriticalSection( &freetype_cs );
7115
7116     size->cx = 0;
7117     get_text_metrics( physdev->font, &tm );
7118     size->cy = tm.tmHeight;
7119
7120     for(idx = 0; idx < count; idx++) {
7121         get_glyph_index_linked( physdev->font, wstr[idx], &linked_font, &glyph_index );
7122         get_glyph_outline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
7123                           &gm, 0, NULL, &identity);
7124         size->cx += FONT_GM(linked_font,glyph_index)->adv;
7125         ext = size->cx;
7126         if (! pnfit || ext <= max_ext) {
7127             ++nfit;
7128             if (dxs)
7129                 dxs[idx] = ext;
7130         }
7131     }
7132
7133     if (pnfit)
7134         *pnfit = nfit;
7135
7136     LeaveCriticalSection( &freetype_cs );
7137     TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
7138     return TRUE;
7139 }
7140
7141 /*************************************************************
7142  * freetype_GetTextExtentExPointI
7143  */
7144 static BOOL freetype_GetTextExtentExPointI( PHYSDEV dev, const WORD *indices, INT count,
7145                                             INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size )
7146 {
7147     static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
7148     INT idx;
7149     INT nfit = 0, ext;
7150     GLYPHMETRICS gm;
7151     TEXTMETRICW tm;
7152     struct freetype_physdev *physdev = get_freetype_dev( dev );
7153
7154     if (!physdev->font)
7155     {
7156         dev = GET_NEXT_PHYSDEV( dev, pGetTextExtentExPointI );
7157         return dev->funcs->pGetTextExtentExPointI( dev, indices, count, max_ext, pnfit, dxs, size );
7158     }
7159
7160     TRACE("%p, %p, %d, %d, %p\n", physdev->font, indices, count, max_ext, size);
7161
7162     GDI_CheckNotLock();
7163     EnterCriticalSection( &freetype_cs );
7164
7165     size->cx = 0;
7166     get_text_metrics(physdev->font, &tm);
7167     size->cy = tm.tmHeight;
7168
7169     for(idx = 0; idx < count; idx++) {
7170         get_glyph_outline(physdev->font, indices[idx], GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &identity);
7171         size->cx += FONT_GM(physdev->font,indices[idx])->adv;
7172         ext = size->cx;
7173         if (! pnfit || ext <= max_ext) {
7174             ++nfit;
7175             if (dxs)
7176                 dxs[idx] = ext;
7177         }
7178     }
7179
7180     if (pnfit)
7181         *pnfit = nfit;
7182
7183     LeaveCriticalSection( &freetype_cs );
7184     TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
7185     return TRUE;
7186 }
7187
7188 /*************************************************************
7189  * freetype_GetFontData
7190  */
7191 static DWORD freetype_GetFontData( PHYSDEV dev, DWORD table, DWORD offset, LPVOID buf, DWORD cbData )
7192 {
7193     struct freetype_physdev *physdev = get_freetype_dev( dev );
7194
7195     if (!physdev->font)
7196     {
7197         dev = GET_NEXT_PHYSDEV( dev, pGetFontData );
7198         return dev->funcs->pGetFontData( dev, table, offset, buf, cbData );
7199     }
7200
7201     TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
7202           physdev->font, LOBYTE(LOWORD(table)), HIBYTE(LOWORD(table)),
7203           LOBYTE(HIWORD(table)), HIBYTE(HIWORD(table)), offset, buf, cbData);
7204
7205     return get_font_data( physdev->font, table, offset, buf, cbData );
7206 }
7207
7208 /*************************************************************
7209  * freetype_GetTextFace
7210  */
7211 static INT freetype_GetTextFace( PHYSDEV dev, INT count, LPWSTR str )
7212 {
7213     INT n;
7214     struct freetype_physdev *physdev = get_freetype_dev( dev );
7215
7216     if (!physdev->font)
7217     {
7218         dev = GET_NEXT_PHYSDEV( dev, pGetTextFace );
7219         return dev->funcs->pGetTextFace( dev, count, str );
7220     }
7221
7222     n = strlenW(physdev->font->name) + 1;
7223     if (str)
7224     {
7225         lstrcpynW(str, physdev->font->name, count);
7226         n = min(count, n);
7227     }
7228     return n;
7229 }
7230
7231 /*************************************************************
7232  * freetype_GetTextCharsetInfo
7233  */
7234 static UINT freetype_GetTextCharsetInfo( PHYSDEV dev, LPFONTSIGNATURE fs, DWORD flags )
7235 {
7236     struct freetype_physdev *physdev = get_freetype_dev( dev );
7237
7238     if (!physdev->font)
7239     {
7240         dev = GET_NEXT_PHYSDEV( dev, pGetTextCharsetInfo );
7241         return dev->funcs->pGetTextCharsetInfo( dev, fs, flags );
7242     }
7243     if (fs) *fs = physdev->font->fs;
7244     return physdev->font->charset;
7245 }
7246
7247 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
7248 {
7249     GdiFont *font = dc->gdiFont, *linked_font;
7250     struct list *first_hfont;
7251     BOOL ret;
7252
7253     GDI_CheckNotLock();
7254     EnterCriticalSection( &freetype_cs );
7255     ret = get_glyph_index_linked(font, c, &linked_font, glyph);
7256     TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
7257     if(font == linked_font)
7258         *new_hfont = dc->hFont;
7259     else
7260     {
7261         first_hfont = list_head(&linked_font->hfontlist);
7262         *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
7263     }
7264     LeaveCriticalSection( &freetype_cs );
7265     return ret;
7266 }
7267
7268 /* Retrieve a list of supported Unicode ranges for a given font.
7269  * Can be called with NULL gs to calculate the buffer size. Returns
7270  * the number of ranges found.
7271  */
7272 static DWORD get_font_unicode_ranges(FT_Face face, GLYPHSET *gs)
7273 {
7274     DWORD num_ranges = 0;
7275
7276     if (face->charmap->encoding == FT_ENCODING_UNICODE)
7277     {
7278         FT_UInt glyph_code;
7279         FT_ULong char_code, char_code_prev;
7280
7281         glyph_code = 0;
7282         char_code_prev = char_code = pFT_Get_First_Char(face, &glyph_code);
7283
7284         TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
7285                face->num_glyphs, glyph_code, char_code);
7286
7287         if (!glyph_code) return 0;
7288
7289         if (gs)
7290         {
7291             gs->ranges[0].wcLow = (USHORT)char_code;
7292             gs->ranges[0].cGlyphs = 0;
7293             gs->cGlyphsSupported = 0;
7294         }
7295
7296         num_ranges = 1;
7297         while (glyph_code)
7298         {
7299             if (char_code < char_code_prev)
7300             {
7301                 ERR("expected increasing char code from FT_Get_Next_Char\n");
7302                 return 0;
7303             }
7304             if (char_code - char_code_prev > 1)
7305             {
7306                 num_ranges++;
7307                 if (gs)
7308                 {
7309                     gs->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
7310                     gs->ranges[num_ranges - 1].cGlyphs = 1;
7311                     gs->cGlyphsSupported++;
7312                 }
7313             }
7314             else if (gs)
7315             {
7316                 gs->ranges[num_ranges - 1].cGlyphs++;
7317                 gs->cGlyphsSupported++;
7318             }
7319             char_code_prev = char_code;
7320             char_code = pFT_Get_Next_Char(face, char_code, &glyph_code);
7321         }
7322     }
7323     else
7324         FIXME("encoding %u not supported\n", face->charmap->encoding);
7325
7326     return num_ranges;
7327 }
7328
7329 /*************************************************************
7330  * freetype_GetFontUnicodeRanges
7331  */
7332 static DWORD freetype_GetFontUnicodeRanges( PHYSDEV dev, LPGLYPHSET glyphset )
7333 {
7334     struct freetype_physdev *physdev = get_freetype_dev( dev );
7335     DWORD size, num_ranges;
7336
7337     if (!physdev->font)
7338     {
7339         dev = GET_NEXT_PHYSDEV( dev, pGetFontUnicodeRanges );
7340         return dev->funcs->pGetFontUnicodeRanges( dev, glyphset );
7341     }
7342
7343     num_ranges = get_font_unicode_ranges(physdev->font->ft_face, glyphset);
7344     size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
7345     if (glyphset)
7346     {
7347         glyphset->cbThis = size;
7348         glyphset->cRanges = num_ranges;
7349         glyphset->flAccel = 0;
7350     }
7351     return size;
7352 }
7353
7354 /*************************************************************
7355  * freetype_FontIsLinked
7356  */
7357 static BOOL freetype_FontIsLinked( PHYSDEV dev )
7358 {
7359     struct freetype_physdev *physdev = get_freetype_dev( dev );
7360     BOOL ret;
7361
7362     if (!physdev->font)
7363     {
7364         dev = GET_NEXT_PHYSDEV( dev, pFontIsLinked );
7365         return dev->funcs->pFontIsLinked( dev );
7366     }
7367
7368     GDI_CheckNotLock();
7369     EnterCriticalSection( &freetype_cs );
7370     ret = !list_empty(&physdev->font->child_fonts);
7371     LeaveCriticalSection( &freetype_cs );
7372     return ret;
7373 }
7374
7375 static BOOL is_hinting_enabled(void)
7376 {
7377     /* Use the >= 2.2.0 function if available */
7378     if(pFT_Get_TrueType_Engine_Type)
7379     {
7380         FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
7381         return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
7382     }
7383 #ifdef FT_DRIVER_HAS_HINTER
7384     else
7385     {
7386         FT_Module mod;
7387
7388         /* otherwise if we've been compiled with < 2.2.0 headers
7389            use the internal macro */
7390         mod = pFT_Get_Module(library, "truetype");
7391         if(mod && FT_DRIVER_HAS_HINTER(mod))
7392             return TRUE;
7393     }
7394 #endif
7395
7396     return FALSE;
7397 }
7398
7399 static BOOL is_subpixel_rendering_enabled( void )
7400 {
7401 #ifdef HAVE_FREETYPE_FTLCDFIL_H
7402     return pFT_Library_SetLcdFilter &&
7403            pFT_Library_SetLcdFilter( NULL, 0 ) != FT_Err_Unimplemented_Feature;
7404 #else
7405     return FALSE;
7406 #endif
7407 }
7408
7409 /*************************************************************************
7410  *             GetRasterizerCaps   (GDI32.@)
7411  */
7412 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
7413 {
7414     static int hinting = -1;
7415     static int subpixel = -1;
7416
7417     if(hinting == -1)
7418     {
7419         hinting = is_hinting_enabled();
7420         TRACE("hinting is %senabled\n", hinting ? "" : "NOT ");
7421     }
7422
7423     if ( subpixel == -1 )
7424     {
7425         subpixel = is_subpixel_rendering_enabled();
7426         TRACE("subpixel rendering is %senabled\n", subpixel ? "" : "NOT ");
7427     }
7428
7429     lprs->nSize = sizeof(RASTERIZER_STATUS);
7430     lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
7431     if ( subpixel )
7432         lprs->wFlags |= WINE_TT_SUBPIXEL_RENDERING_ENABLED;
7433     lprs->nLanguageID = 0;
7434     return TRUE;
7435 }
7436
7437 /*************************************************************
7438  * freetype_GdiRealizationInfo
7439  */
7440 static BOOL freetype_GdiRealizationInfo( PHYSDEV dev, void *ptr )
7441 {
7442     struct freetype_physdev *physdev = get_freetype_dev( dev );
7443     realization_info_t *info = ptr;
7444
7445     if (!physdev->font)
7446     {
7447         dev = GET_NEXT_PHYSDEV( dev, pGdiRealizationInfo );
7448         return dev->funcs->pGdiRealizationInfo( dev, ptr );
7449     }
7450
7451     FIXME("(%p, %p): stub!\n", physdev->font, info);
7452
7453     info->flags = 1;
7454     if(FT_IS_SCALABLE(physdev->font->ft_face))
7455         info->flags |= 2;
7456
7457     info->cache_num = physdev->font->cache_num;
7458     info->unknown2 = -1;
7459     return TRUE;
7460 }
7461
7462 /*************************************************************************
7463  * Kerning support for TrueType fonts
7464  */
7465 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
7466
7467 struct TT_kern_table
7468 {
7469     USHORT version;
7470     USHORT nTables;
7471 };
7472
7473 struct TT_kern_subtable
7474 {
7475     USHORT version;
7476     USHORT length;
7477     union
7478     {
7479         USHORT word;
7480         struct
7481         {
7482             USHORT horizontal : 1;
7483             USHORT minimum : 1;
7484             USHORT cross_stream: 1;
7485             USHORT override : 1;
7486             USHORT reserved1 : 4;
7487             USHORT format : 8;
7488         } bits;
7489     } coverage;
7490 };
7491
7492 struct TT_format0_kern_subtable
7493 {
7494     USHORT nPairs;
7495     USHORT searchRange;
7496     USHORT entrySelector;
7497     USHORT rangeShift;
7498 };
7499
7500 struct TT_kern_pair
7501 {
7502     USHORT left;
7503     USHORT right;
7504     short  value;
7505 };
7506
7507 static DWORD parse_format0_kern_subtable(GdiFont *font,
7508                                          const struct TT_format0_kern_subtable *tt_f0_ks,
7509                                          const USHORT *glyph_to_char,
7510                                          KERNINGPAIR *kern_pair, DWORD cPairs)
7511 {
7512     USHORT i, nPairs;
7513     const struct TT_kern_pair *tt_kern_pair;
7514
7515     TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
7516
7517     nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
7518
7519     TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
7520            nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
7521            GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
7522
7523     if (!kern_pair || !cPairs)
7524         return nPairs;
7525
7526     tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
7527
7528     nPairs = min(nPairs, cPairs);
7529
7530     for (i = 0; i < nPairs; i++)
7531     {
7532         kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
7533         kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
7534         /* this algorithm appears to better match what Windows does */
7535         kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
7536         if (kern_pair->iKernAmount < 0)
7537         {
7538             kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
7539             kern_pair->iKernAmount -= font->ppem;
7540         }
7541         else if (kern_pair->iKernAmount > 0)
7542         {
7543             kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
7544             kern_pair->iKernAmount += font->ppem;
7545         }
7546         kern_pair->iKernAmount /= font->ft_face->units_per_EM;
7547
7548         TRACE("left %u right %u value %d\n",
7549                kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
7550
7551         kern_pair++;
7552     }
7553     TRACE("copied %u entries\n", nPairs);
7554     return nPairs;
7555 }
7556
7557 /*************************************************************
7558  * freetype_GetKerningPairs
7559  */
7560 static DWORD freetype_GetKerningPairs( PHYSDEV dev, DWORD cPairs, KERNINGPAIR *kern_pair )
7561 {
7562     DWORD length;
7563     void *buf;
7564     const struct TT_kern_table *tt_kern_table;
7565     const struct TT_kern_subtable *tt_kern_subtable;
7566     USHORT i, nTables;
7567     USHORT *glyph_to_char;
7568     GdiFont *font;
7569     struct freetype_physdev *physdev = get_freetype_dev( dev );
7570
7571     if (!(font = physdev->font))
7572     {
7573         dev = GET_NEXT_PHYSDEV( dev, pGetKerningPairs );
7574         return dev->funcs->pGetKerningPairs( dev, cPairs, kern_pair );
7575     }
7576
7577     GDI_CheckNotLock();
7578     EnterCriticalSection( &freetype_cs );
7579     if (font->total_kern_pairs != (DWORD)-1)
7580     {
7581         if (cPairs && kern_pair)
7582         {
7583             cPairs = min(cPairs, font->total_kern_pairs);
7584             memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
7585         }
7586         else cPairs = font->total_kern_pairs;
7587
7588         LeaveCriticalSection( &freetype_cs );
7589         return cPairs;
7590     }
7591
7592     font->total_kern_pairs = 0;
7593
7594     length = get_font_data(font, MS_KERN_TAG, 0, NULL, 0);
7595
7596     if (length == GDI_ERROR)
7597     {
7598         TRACE("no kerning data in the font\n");
7599         LeaveCriticalSection( &freetype_cs );
7600         return 0;
7601     }
7602
7603     buf = HeapAlloc(GetProcessHeap(), 0, length);
7604     if (!buf)
7605     {
7606         WARN("Out of memory\n");
7607         LeaveCriticalSection( &freetype_cs );
7608         return 0;
7609     }
7610
7611     get_font_data(font, MS_KERN_TAG, 0, buf, length);
7612
7613     /* build a glyph index to char code map */
7614     glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
7615     if (!glyph_to_char)
7616     {
7617         WARN("Out of memory allocating a glyph index to char code map\n");
7618         HeapFree(GetProcessHeap(), 0, buf);
7619         LeaveCriticalSection( &freetype_cs );
7620         return 0;
7621     }
7622
7623     if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE)
7624     {
7625         FT_UInt glyph_code;
7626         FT_ULong char_code;
7627
7628         glyph_code = 0;
7629         char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
7630
7631         TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
7632                font->ft_face->num_glyphs, glyph_code, char_code);
7633
7634         while (glyph_code)
7635         {
7636             /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? "  !" : "" );*/
7637
7638             /* FIXME: This doesn't match what Windows does: it does some fancy
7639              * things with duplicate glyph index to char code mappings, while
7640              * we just avoid overriding existing entries.
7641              */
7642             if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
7643                 glyph_to_char[glyph_code] = (USHORT)char_code;
7644
7645             char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
7646         }
7647     }
7648     else
7649     {
7650         ULONG n;
7651
7652         FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
7653         for (n = 0; n <= 65535; n++)
7654             glyph_to_char[n] = (USHORT)n;
7655     }
7656
7657     tt_kern_table = buf;
7658     nTables = GET_BE_WORD(tt_kern_table->nTables);
7659     TRACE("version %u, nTables %u\n",
7660            GET_BE_WORD(tt_kern_table->version), nTables);
7661
7662     tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
7663
7664     for (i = 0; i < nTables; i++)
7665     {
7666         struct TT_kern_subtable tt_kern_subtable_copy;
7667
7668         tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
7669         tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
7670         tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
7671
7672         TRACE("version %u, length %u, coverage %u, subtable format %u\n",
7673                tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
7674                tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
7675
7676         /* According to the TrueType specification this is the only format
7677          * that will be properly interpreted by Windows and OS/2
7678          */
7679         if (tt_kern_subtable_copy.coverage.bits.format == 0)
7680         {
7681             DWORD new_chunk, old_total = font->total_kern_pairs;
7682
7683             new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
7684                                                     glyph_to_char, NULL, 0);
7685             font->total_kern_pairs += new_chunk;
7686
7687             if (!font->kern_pairs)
7688                 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
7689                                              font->total_kern_pairs * sizeof(*font->kern_pairs));
7690             else
7691                 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
7692                                                font->total_kern_pairs * sizeof(*font->kern_pairs));
7693
7694             parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
7695                         glyph_to_char, font->kern_pairs + old_total, new_chunk);
7696         }
7697         else
7698             TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
7699
7700         tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
7701     }
7702
7703     HeapFree(GetProcessHeap(), 0, glyph_to_char);
7704     HeapFree(GetProcessHeap(), 0, buf);
7705
7706     if (cPairs && kern_pair)
7707     {
7708         cPairs = min(cPairs, font->total_kern_pairs);
7709         memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
7710     }
7711     else cPairs = font->total_kern_pairs;
7712
7713     LeaveCriticalSection( &freetype_cs );
7714     return cPairs;
7715 }
7716
7717 static const struct gdi_dc_funcs freetype_funcs =
7718 {
7719     NULL,                               /* pAbortDoc */
7720     NULL,                               /* pAbortPath */
7721     NULL,                               /* pAlphaBlend */
7722     NULL,                               /* pAngleArc */
7723     NULL,                               /* pArc */
7724     NULL,                               /* pArcTo */
7725     NULL,                               /* pBeginPath */
7726     NULL,                               /* pBlendImage */
7727     NULL,                               /* pChoosePixelFormat */
7728     NULL,                               /* pChord */
7729     NULL,                               /* pCloseFigure */
7730     NULL,                               /* pCopyBitmap */
7731     NULL,                               /* pCreateBitmap */
7732     NULL,                               /* pCreateCompatibleDC */
7733     freetype_CreateDC,                  /* pCreateDC */
7734     NULL,                               /* pDeleteBitmap */
7735     freetype_DeleteDC,                  /* pDeleteDC */
7736     NULL,                               /* pDeleteObject */
7737     NULL,                               /* pDescribePixelFormat */
7738     NULL,                               /* pDeviceCapabilities */
7739     NULL,                               /* pEllipse */
7740     NULL,                               /* pEndDoc */
7741     NULL,                               /* pEndPage */
7742     NULL,                               /* pEndPath */
7743     freetype_EnumFonts,                 /* pEnumFonts */
7744     NULL,                               /* pEnumICMProfiles */
7745     NULL,                               /* pExcludeClipRect */
7746     NULL,                               /* pExtDeviceMode */
7747     NULL,                               /* pExtEscape */
7748     NULL,                               /* pExtFloodFill */
7749     NULL,                               /* pExtSelectClipRgn */
7750     NULL,                               /* pExtTextOut */
7751     NULL,                               /* pFillPath */
7752     NULL,                               /* pFillRgn */
7753     NULL,                               /* pFlattenPath */
7754     freetype_FontIsLinked,              /* pFontIsLinked */
7755     NULL,                               /* pFrameRgn */
7756     NULL,                               /* pGdiComment */
7757     freetype_GdiRealizationInfo,        /* pGdiRealizationInfo */
7758     freetype_GetCharABCWidths,          /* pGetCharABCWidths */
7759     freetype_GetCharABCWidthsI,         /* pGetCharABCWidthsI */
7760     freetype_GetCharWidth,              /* pGetCharWidth */
7761     NULL,                               /* pGetDeviceCaps */
7762     NULL,                               /* pGetDeviceGammaRamp */
7763     freetype_GetFontData,               /* pGetFontData */
7764     freetype_GetFontUnicodeRanges,      /* pGetFontUnicodeRanges */
7765     freetype_GetGlyphIndices,           /* pGetGlyphIndices */
7766     freetype_GetGlyphOutline,           /* pGetGlyphOutline */
7767     NULL,                               /* pGetICMProfile */
7768     NULL,                               /* pGetImage */
7769     freetype_GetKerningPairs,           /* pGetKerningPairs */
7770     NULL,                               /* pGetNearestColor */
7771     freetype_GetOutlineTextMetrics,     /* pGetOutlineTextMetrics */
7772     NULL,                               /* pGetPixel */
7773     NULL,                               /* pGetPixelFormat */
7774     NULL,                               /* pGetSystemPaletteEntries */
7775     freetype_GetTextCharsetInfo,        /* pGetTextCharsetInfo */
7776     freetype_GetTextExtentExPoint,      /* pGetTextExtentExPoint */
7777     freetype_GetTextExtentExPointI,     /* pGetTextExtentExPointI */
7778     freetype_GetTextFace,               /* pGetTextFace */
7779     freetype_GetTextMetrics,            /* pGetTextMetrics */
7780     NULL,                               /* pGradientFill */
7781     NULL,                               /* pIntersectClipRect */
7782     NULL,                               /* pInvertRgn */
7783     NULL,                               /* pLineTo */
7784     NULL,                               /* pModifyWorldTransform */
7785     NULL,                               /* pMoveTo */
7786     NULL,                               /* pOffsetClipRgn */
7787     NULL,                               /* pOffsetViewportOrg */
7788     NULL,                               /* pOffsetWindowOrg */
7789     NULL,                               /* pPaintRgn */
7790     NULL,                               /* pPatBlt */
7791     NULL,                               /* pPie */
7792     NULL,                               /* pPolyBezier */
7793     NULL,                               /* pPolyBezierTo */
7794     NULL,                               /* pPolyDraw */
7795     NULL,                               /* pPolyPolygon */
7796     NULL,                               /* pPolyPolyline */
7797     NULL,                               /* pPolygon */
7798     NULL,                               /* pPolyline */
7799     NULL,                               /* pPolylineTo */
7800     NULL,                               /* pPutImage */
7801     NULL,                               /* pRealizeDefaultPalette */
7802     NULL,                               /* pRealizePalette */
7803     NULL,                               /* pRectangle */
7804     NULL,                               /* pResetDC */
7805     NULL,                               /* pRestoreDC */
7806     NULL,                               /* pRoundRect */
7807     NULL,                               /* pSaveDC */
7808     NULL,                               /* pScaleViewportExt */
7809     NULL,                               /* pScaleWindowExt */
7810     NULL,                               /* pSelectBitmap */
7811     NULL,                               /* pSelectBrush */
7812     NULL,                               /* pSelectClipPath */
7813     freetype_SelectFont,                /* pSelectFont */
7814     NULL,                               /* pSelectPalette */
7815     NULL,                               /* pSelectPen */
7816     NULL,                               /* pSetArcDirection */
7817     NULL,                               /* pSetBkColor */
7818     NULL,                               /* pSetBkMode */
7819     NULL,                               /* pSetDCBrushColor */
7820     NULL,                               /* pSetDCPenColor */
7821     NULL,                               /* pSetDIBColorTable */
7822     NULL,                               /* pSetDIBitsToDevice */
7823     NULL,                               /* pSetDeviceClipping */
7824     NULL,                               /* pSetDeviceGammaRamp */
7825     NULL,                               /* pSetLayout */
7826     NULL,                               /* pSetMapMode */
7827     NULL,                               /* pSetMapperFlags */
7828     NULL,                               /* pSetPixel */
7829     NULL,                               /* pSetPixelFormat */
7830     NULL,                               /* pSetPolyFillMode */
7831     NULL,                               /* pSetROP2 */
7832     NULL,                               /* pSetRelAbs */
7833     NULL,                               /* pSetStretchBltMode */
7834     NULL,                               /* pSetTextAlign */
7835     NULL,                               /* pSetTextCharacterExtra */
7836     NULL,                               /* pSetTextColor */
7837     NULL,                               /* pSetTextJustification */
7838     NULL,                               /* pSetViewportExt */
7839     NULL,                               /* pSetViewportOrg */
7840     NULL,                               /* pSetWindowExt */
7841     NULL,                               /* pSetWindowOrg */
7842     NULL,                               /* pSetWorldTransform */
7843     NULL,                               /* pStartDoc */
7844     NULL,                               /* pStartPage */
7845     NULL,                               /* pStretchBlt */
7846     NULL,                               /* pStretchDIBits */
7847     NULL,                               /* pStrokeAndFillPath */
7848     NULL,                               /* pStrokePath */
7849     NULL,                               /* pSwapBuffers */
7850     NULL,                               /* pUnrealizePalette */
7851     NULL,                               /* pWidenPath */
7852     /* OpenGL not supported */
7853 };
7854
7855 #else /* HAVE_FREETYPE */
7856
7857 /*************************************************************************/
7858
7859 BOOL WineEngInit(void)
7860 {
7861     return FALSE;
7862 }
7863 BOOL WineEngDestroyFontInstance(HFONT hfont)
7864 {
7865     return FALSE;
7866 }
7867
7868 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
7869 {
7870     FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
7871     return 1;
7872 }
7873
7874 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
7875 {
7876     FIXME("(%s, %x, %p): stub\n", debugstr_w(file), flags, pdv);
7877     return TRUE;
7878 }
7879
7880 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
7881 {
7882     FIXME("(%p, %u, %p, %p): stub\n", pbFont, cbFont, pdv, pcFonts);
7883     return NULL;
7884 }
7885
7886 BOOL WineEngCreateScalableFontResource( DWORD hidden, LPCWSTR resource,
7887                                         LPCWSTR font_file, LPCWSTR font_path )
7888 {
7889     FIXME("stub\n");
7890     return FALSE;
7891 }
7892
7893 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
7894 {
7895     return FALSE;
7896 }
7897
7898 /*************************************************************************
7899  *             GetRasterizerCaps   (GDI32.@)
7900  */
7901 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
7902 {
7903     lprs->nSize = sizeof(RASTERIZER_STATUS);
7904     lprs->wFlags = 0;
7905     lprs->nLanguageID = 0;
7906     return TRUE;
7907 }
7908
7909 #endif /* HAVE_FREETYPE */