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