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

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