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

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