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 #include <dirent.h>
  37 #include <stdio.h>
  38 #include <assert.h>
  39
  40 #ifdef HAVE_CARBON_CARBON_H
  41 #define LoadResource __carbon_LoadResource
  42 #define CompareString __carbon_CompareString
  43 #define GetCurrentThread __carbon_GetCurrentThread
  44 #define GetCurrentProcess __carbon_GetCurrentProcess
  45 #define AnimatePalette __carbon_AnimatePalette
  46 #define EqualRgn __carbon_EqualRgn
  47 #define FillRgn __carbon_FillRgn
  48 #define FrameRgn __carbon_FrameRgn
  49 #define GetPixel __carbon_GetPixel
  50 #define InvertRgn __carbon_InvertRgn
  51 #define LineTo __carbon_LineTo
  52 #define OffsetRgn __carbon_OffsetRgn
  53 #define PaintRgn __carbon_PaintRgn
  54 #define Polygon __carbon_Polygon
  55 #define ResizePalette __carbon_ResizePalette
  56 #define SetRectRgn __carbon_SetRectRgn
  57 #include <Carbon/Carbon.h>
  58 #undef LoadResource
  59 #undef CompareString
  60 #undef GetCurrentThread
  61 #undef _CDECL
  62 #undef DPRINTF
  63 #undef GetCurrentProcess
  64 #undef AnimatePalette
  65 #undef EqualRgn
  66 #undef FillRgn
  67 #undef FrameRgn
  68 #undef GetPixel
  69 #undef InvertRgn
  70 #undef LineTo
  71 #undef OffsetRgn
  72 #undef PaintRgn
  73 #undef Polygon
  74 #undef ResizePalette
  75 #undef SetRectRgn
  76 #endif /* HAVE_CARBON_CARBON_H */
  77
  78 #include "windef.h"
  79 #include "winbase.h"
  80 #include "winternl.h"
  81 #include "winerror.h"
  82 #include "winreg.h"
  83 #include "wingdi.h"
  84 #include "gdi_private.h"
  85 #include "wine/unicode.h"
  86 #include "wine/debug.h"
  87 #include "wine/list.h"
  88
  89 WINE_DEFAULT_DEBUG_CHANNEL(font);
  90
  91 #ifdef HAVE_FREETYPE
  92
  93 #ifdef HAVE_FT2BUILD_H
  94 #include <ft2build.h>
  95 #endif
  96 #ifdef HAVE_FREETYPE_FREETYPE_H
  97 #include <freetype/freetype.h>
  98 #endif
  99 #ifdef HAVE_FREETYPE_FTGLYPH_H
 100 #include <freetype/ftglyph.h>
 101 #endif
 102 #ifdef HAVE_FREETYPE_TTTABLES_H
 103 #include <freetype/tttables.h>
 104 #endif
 105 #ifdef HAVE_FREETYPE_FTTYPES_H
 106 #include <freetype/fttypes.h>
 107 #endif
 108 #ifdef HAVE_FREETYPE_FTSNAMES_H
 109 #include <freetype/ftsnames.h>
 110 #else
 111 # ifdef HAVE_FREETYPE_FTNAMES_H
 112 # include <freetype/ftnames.h>
 113 # endif
 114 #endif
 115 #ifdef HAVE_FREETYPE_TTNAMEID_H
 116 #include <freetype/ttnameid.h>
 117 #endif
 118 #ifdef HAVE_FREETYPE_FTOUTLN_H
 119 #include <freetype/ftoutln.h>
 120 #endif
 121 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
 122 #include <freetype/internal/sfnt.h>
 123 #endif
 124 #ifdef HAVE_FREETYPE_FTTRIGON_H
 125 #include <freetype/fttrigon.h>
 126 #endif
 127 #ifdef HAVE_FREETYPE_FTWINFNT_H
 128 #include <freetype/ftwinfnt.h>
 129 #endif
 130 #ifdef HAVE_FREETYPE_FTMODAPI_H
 131 #include <freetype/ftmodapi.h>
 132 #endif
 133
 134 #ifndef HAVE_FT_TRUETYPEENGINETYPE
 135 typedef enum
 136 {
 137     FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
 138     FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
 139     FT_TRUETYPE_ENGINE_TYPE_PATENTED
 140 } FT_TrueTypeEngineType;
 141 #endif
 142
 143 static FT_Library library = 0;
 144 typedef struct
 145 {
 146     FT_Int major;
 147     FT_Int minor;
 148     FT_Int patch;
 149 } FT_Version_t;
 150 static FT_Version_t FT_Version;
 151 static DWORD FT_SimpleVersion;
 152
 153 static void *ft_handle = NULL;
 154
 155 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
 156 MAKE_FUNCPTR(FT_Vector_Unit);
 157 MAKE_FUNCPTR(FT_Done_Face);
 158 MAKE_FUNCPTR(FT_Get_Char_Index);
 159 MAKE_FUNCPTR(FT_Get_Module);
 160 MAKE_FUNCPTR(FT_Get_Sfnt_Name);
 161 MAKE_FUNCPTR(FT_Get_Sfnt_Name_Count);
 162 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
 163 MAKE_FUNCPTR(FT_Init_FreeType);
 164 MAKE_FUNCPTR(FT_Load_Glyph);
 165 MAKE_FUNCPTR(FT_Matrix_Multiply);
 166 #ifdef FT_MULFIX_INLINED
 167 #define pFT_MulFix FT_MULFIX_INLINED
 168 #else
 169 MAKE_FUNCPTR(FT_MulFix);
 170 #endif
 171 MAKE_FUNCPTR(FT_New_Face);
 172 MAKE_FUNCPTR(FT_New_Memory_Face);
 173 MAKE_FUNCPTR(FT_Outline_Get_Bitmap);
 174 MAKE_FUNCPTR(FT_Outline_Transform);
 175 MAKE_FUNCPTR(FT_Outline_Translate);
 176 MAKE_FUNCPTR(FT_Select_Charmap);
 177 MAKE_FUNCPTR(FT_Set_Charmap);
 178 MAKE_FUNCPTR(FT_Set_Pixel_Sizes);
 179 MAKE_FUNCPTR(FT_Vector_Transform);
 180 static void (*pFT_Library_Version)(FT_Library,FT_Int*,FT_Int*,FT_Int*);
 181 static FT_Error (*pFT_Load_Sfnt_Table)(FT_Face,FT_ULong,FT_Long,FT_Byte*,FT_ULong*);
 182 static FT_ULong (*pFT_Get_First_Char)(FT_Face,FT_UInt*);
 183 static FT_ULong (*pFT_Get_Next_Char)(FT_Face,FT_ULong,FT_UInt*);
 184 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type)(FT_Library);
 185 #ifdef HAVE_FREETYPE_FTWINFNT_H
 186 MAKE_FUNCPTR(FT_Get_WinFNT_Header);
 187 #endif
 188
 189 #ifdef SONAME_LIBFONTCONFIG
 190 #include <fontconfig/fontconfig.h>
 191 MAKE_FUNCPTR(FcConfigGetCurrent);
 192 MAKE_FUNCPTR(FcFontList);
 193 MAKE_FUNCPTR(FcFontSetDestroy);
 194 MAKE_FUNCPTR(FcInit);
 195 MAKE_FUNCPTR(FcObjectSetAdd);
 196 MAKE_FUNCPTR(FcObjectSetCreate);
 197 MAKE_FUNCPTR(FcObjectSetDestroy);
 198 MAKE_FUNCPTR(FcPatternCreate);
 199 MAKE_FUNCPTR(FcPatternDestroy);
 200 MAKE_FUNCPTR(FcPatternGetBool);
 201 MAKE_FUNCPTR(FcPatternGetString);
 202 #endif
 203
 204 #undef MAKE_FUNCPTR
 205
 206 #ifndef FT_MAKE_TAG
 207 #define FT_MAKE_TAG( ch0, ch1, ch2, ch3 ) \
 208         ( ((DWORD)(BYTE)(ch0) << 24) | ((DWORD)(BYTE)(ch1) << 16) | \
 209           ((DWORD)(BYTE)(ch2) << 8) | (DWORD)(BYTE)(ch3) )
 210 #endif
 211
 212 #ifndef ft_encoding_none
 213 #define FT_ENCODING_NONE ft_encoding_none
 214 #endif
 215 #ifndef ft_encoding_ms_symbol
 216 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
 217 #endif
 218 #ifndef ft_encoding_unicode
 219 #define FT_ENCODING_UNICODE ft_encoding_unicode
 220 #endif
 221 #ifndef ft_encoding_apple_roman
 222 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
 223 #endif
 224
 225 #ifdef WORDS_BIGENDIAN
 226 #define GET_BE_WORD(x) (x)
 227 #else
 228 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
 229 #endif
 230
 231 /* This is basically a copy of FT_Bitmap_Size with an extra element added */
 232 typedef struct {
 233     FT_Short height;
 234     FT_Short width;
 235     FT_Pos size;
 236     FT_Pos x_ppem;
 237     FT_Pos y_ppem;
 238     FT_Short internal_leading;
 239 } Bitmap_Size;
 240
 241 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
 242    So to let this compile on older versions of FreeType we'll define the
 243    new structure here. */
 244 typedef struct {
 245     FT_Short height, width;
 246     FT_Pos size, x_ppem, y_ppem;
 247 } My_FT_Bitmap_Size;
 248
 249 struct enum_data
 250 {
 251     ENUMLOGFONTEXW elf;
 252     NEWTEXTMETRICEXW ntm;
 253     DWORD type;
 254 };
 255
 256 typedef struct tagFace {
 257     struct list entry;
 258     WCHAR *StyleName;
 259     char *file;
 260     void *font_data_ptr;
 261     DWORD font_data_size;
 262     FT_Long face_index;
 263     FONTSIGNATURE fs;
 264     FONTSIGNATURE fs_links;
 265     DWORD ntmFlags;
 266     FT_Fixed font_version;
 267     BOOL scalable;
 268     Bitmap_Size size;     /* set if face is a bitmap */
 269     BOOL external; /* TRUE if we should manually add this font to the registry */
 270     struct tagFamily *family;
 271     /* Cached data for Enum */
 272     struct enum_data *cached_enum_data;
 273 } Face;
 274
 275 typedef struct tagFamily {
 276     struct list entry;
 277     const WCHAR *FamilyName;
 278     struct list faces;
 279 } Family;
 280
 281 typedef struct {
 282     GLYPHMETRICS gm;
 283     INT adv; /* These three hold to widths of the unrotated chars */
 284     INT lsb;
 285     INT bbx;
 286     BOOL init;
 287 } GM;
 288
 289 typedef struct {
 290     FLOAT eM11, eM12;
 291     FLOAT eM21, eM22;
 292 } FMAT2;
 293
 294 typedef struct {
 295     DWORD hash;
 296     LOGFONTW lf;
 297     FMAT2 matrix;
 298     BOOL can_use_bitmap;
 299 } FONT_DESC;
 300
 301 typedef struct tagHFONTLIST {
 302     struct list entry;
 303     HFONT hfont;
 304 } HFONTLIST;
 305
 306 typedef struct {
 307     struct list entry;
 308     Face *face;
 309     GdiFont *font;
 310 } CHILD_FONT;
 311
 312 struct tagGdiFont {
 313     struct list entry;
 314     GM **gm;
 315     DWORD gmsize;
 316     struct list hfontlist;
 317     OUTLINETEXTMETRICW *potm;
 318     DWORD total_kern_pairs;
 319     KERNINGPAIR *kern_pairs;
 320     struct list child_fonts;
 321
 322     /* the following members can be accessed without locking, they are never modified after creation */
 323     FT_Face ft_face;
 324     struct font_mapping *mapping;
 325     LPWSTR name;
 326     int charset;
 327     int codepage;
 328     BOOL fake_italic;
 329     BOOL fake_bold;
 330     BYTE underline;
 331     BYTE strikeout;
 332     INT orientation;
 333     FONT_DESC font_desc;
 334     LONG aveWidth, ppem;
 335     double scale_y;
 336     SHORT yMax;
 337     SHORT yMin;
 338     DWORD ntmFlags;
 339     FONTSIGNATURE fs;
 340     GdiFont *base_font;
 341     VOID *GSUB_Table;
 342     DWORD cache_num;
 343 };
 344
 345 typedef struct {
 346     struct list entry;
 347     const WCHAR *font_name;
 348     struct list links;
 349 } SYSTEM_LINKS;
 350
 351 #define GM_BLOCK_SIZE 128
 352 #define FONT_GM(font,idx) (&(font)->gm[(idx) / GM_BLOCK_SIZE][(idx) % GM_BLOCK_SIZE])
 353
 354 static struct list gdi_font_list = LIST_INIT(gdi_font_list);
 355 static struct list unused_gdi_font_list = LIST_INIT(unused_gdi_font_list);
 356 #define UNUSED_CACHE_SIZE 10
 357 static struct list child_font_list = LIST_INIT(child_font_list);
 358 static struct list system_links = LIST_INIT(system_links);
 359
 360 static struct list font_subst_list = LIST_INIT(font_subst_list);
 361
 362 static struct list font_list = LIST_INIT(font_list);
 363
 364 static const WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
 365 static const WCHAR defSans[] = {'A','r','i','a','l','\0'};
 366 static const WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
 367
 368 static const WCHAR fontsW[] = {'\\','f','o','n','t','s','\0'};
 369 static const WCHAR win9x_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 370                                            'W','i','n','d','o','w','s','\\',
 371                                            'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 372                                            'F','o','n','t','s','\0'};
 373
 374 static const WCHAR winnt_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 375                                            'W','i','n','d','o','w','s',' ','N','T','\\',
 376                                            'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 377                                            'F','o','n','t','s','\0'};
 378
 379 static const WCHAR system_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
 380 static const WCHAR FixedSys_Value[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
 381 static const WCHAR System_Value[] = {'F','O','N','T','S','.','F','O','N','\0'};
 382 static const WCHAR OEMFont_Value[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
 383
 384 static const WCHAR * const SystemFontValues[4] = {
 385     System_Value,
 386     OEMFont_Value,
 387     FixedSys_Value,
 388     NULL
 389 };
 390
 391 static const WCHAR external_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
 392                                                'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
 393
 394 static const WCHAR ArabicW[] = {'A','r','a','b','i','c','\0'};
 395 static const WCHAR BalticW[] = {'B','a','l','t','i','c','\0'};
 396 static const WCHAR CHINESE_BIG5W[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
 397 static const WCHAR CHINESE_GB2312W[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
 398 static const WCHAR Central_EuropeanW[] = {'C','e','n','t','r','a','l',' ',
 399                                     'E','u','r','o','p','e','a','n','\0'};
 400 static const WCHAR CyrillicW[] = {'C','y','r','i','l','l','i','c','\0'};
 401 static const WCHAR GreekW[] = {'G','r','e','e','k','\0'};
 402 static const WCHAR HangulW[] = {'H','a','n','g','u','l','\0'};
 403 static const WCHAR Hangul_Johab_W[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
 404 static const WCHAR HebrewW[] = {'H','e','b','r','e','w','\0'};
 405 static const WCHAR JapaneseW[] = {'J','a','p','a','n','e','s','e','\0'};
 406 static const WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
 407 static const WCHAR ThaiW[] = {'T','h','a','i','\0'};
 408 static const WCHAR TurkishW[] = {'T','u','r','k','i','s','h','\0'};
 409 static const WCHAR VietnameseW[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
 410 static const WCHAR WesternW[] = {'W','e','s','t','e','r','n','\0'};
 411 static const WCHAR OEM_DOSW[] = {'O','E','M','/','D','O','S','\0'};
 412
 413 static const WCHAR * const ElfScriptsW[32] = { /* these are in the order of the fsCsb[0] bits */
 414     WesternW, /*00*/
 415     Central_EuropeanW,
 416     CyrillicW,
 417     GreekW,
 418     TurkishW,
 419     HebrewW,
 420     ArabicW,
 421     BalticW,
 422     VietnameseW, /*08*/
 423     NULL, NULL, NULL, NULL, NULL, NULL, NULL, /*15*/
 424     ThaiW,
 425     JapaneseW,
 426     CHINESE_GB2312W,
 427     HangulW,
 428     CHINESE_BIG5W,
 429     Hangul_Johab_W,
 430     NULL, NULL, /*23*/
 431     NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 432     SymbolW /*31*/
 433 };
 434
 435 typedef struct {
 436     WCHAR *name;
 437     INT charset;
 438 } NameCs;
 439
 440 typedef struct tagFontSubst {
 441     struct list entry;
 442     NameCs from;
 443     NameCs to;
 444 } FontSubst;
 445
 446 struct font_mapping
 447 {
 448     struct list entry;
 449     int         refcount;
 450     dev_t       dev;
 451     ino_t       ino;
 452     void       *data;
 453     size_t      size;
 454 };
 455
 456 static struct list mappings_list = LIST_INIT( mappings_list );
 457
 458 static BOOL have_installed_roman_font = FALSE; /* CreateFontInstance will fail if this is still FALSE */
 459
 460 static CRITICAL_SECTION freetype_cs;
 461 static CRITICAL_SECTION_DEBUG critsect_debug =
 462 {
 463     0, 0, &freetype_cs,
 464     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 465       0, 0, { (DWORD_PTR)(__FILE__ ": freetype_cs") }
 466 };
 467 static CRITICAL_SECTION freetype_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 468
 469 static const WCHAR font_mutex_nameW[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
 470
 471 static const WCHAR szDefaultFallbackLink[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f',0};
 472 static BOOL use_default_fallback = FALSE;
 473
 474 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph);
 475
 476 /****************************************
 477  *   Notes on .fon files
 478  *
 479  * The fonts System, FixedSys and Terminal are special.  There are typically multiple
 480  * versions installed for different resolutions and codepages.  Windows stores which one to use
 481  * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
 482  *    Key            Meaning
 483  *  FIXEDFON.FON    FixedSys
 484  *  FONTS.FON       System
 485  *  OEMFONT.FON     Terminal
 486  *  LogPixels       Current dpi set by the display control panel applet
 487  *                  (HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontDPI
 488  *                  also has a LogPixels value that appears to mirror this)
 489  *
 490  * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
 491  * (vgaoem.fon would be your oemfont.fon if you have a US setup).
 492  * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
 493  * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
 494  * so that makes sense.
 495  *
 496  * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
 497  * to be mapped into the registry on Windows 2000 at least).
 498  * I have
 499  * woafont=app850.fon
 500  * ega80woa.fon=ega80850.fon
 501  * ega40woa.fon=ega40850.fon
 502  * cga80woa.fon=cga80850.fon
 503  * cga40woa.fon=cga40850.fon
 504  */
 505
 506 /* These are all structures needed for the GSUB table */
 507
 508 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
 509 #define TATEGAKI_LOWER_BOUND  0x02F1
 510
 511 typedef struct {
 512     DWORD version;
 513     WORD ScriptList;
 514     WORD FeatureList;
 515     WORD LookupList;
 516 } GSUB_Header;
 517
 518 typedef struct {
 519     CHAR ScriptTag[4];
 520     WORD Script;
 521 } GSUB_ScriptRecord;
 522
 523 typedef struct {
 524     WORD ScriptCount;
 525     GSUB_ScriptRecord ScriptRecord[1];
 526 } GSUB_ScriptList;
 527
 528 typedef struct {
 529     CHAR LangSysTag[4];
 530     WORD LangSys;
 531 } GSUB_LangSysRecord;
 532
 533 typedef struct {
 534     WORD DefaultLangSys;
 535     WORD LangSysCount;
 536     GSUB_LangSysRecord LangSysRecord[1];
 537 } GSUB_Script;
 538
 539 typedef struct {
 540     WORD LookupOrder; /* Reserved */
 541     WORD ReqFeatureIndex;
 542     WORD FeatureCount;
 543     WORD FeatureIndex[1];
 544 } GSUB_LangSys;
 545
 546 typedef struct {
 547     CHAR FeatureTag[4];
 548     WORD Feature;
 549 } GSUB_FeatureRecord;
 550
 551 typedef struct {
 552     WORD FeatureCount;
 553     GSUB_FeatureRecord FeatureRecord[1];
 554 } GSUB_FeatureList;
 555
 556 typedef struct {
 557     WORD FeatureParams; /* Reserved */
 558     WORD LookupCount;
 559     WORD LookupListIndex[1];
 560 } GSUB_Feature;
 561
 562 typedef struct {
 563     WORD LookupCount;
 564     WORD Lookup[1];
 565 } GSUB_LookupList;
 566
 567 typedef struct {
 568     WORD LookupType;
 569     WORD LookupFlag;
 570     WORD SubTableCount;
 571     WORD SubTable[1];
 572 } GSUB_LookupTable;
 573
 574 typedef struct {
 575     WORD CoverageFormat;
 576     WORD GlyphCount;
 577     WORD GlyphArray[1];
 578 } GSUB_CoverageFormat1;
 579
 580 typedef struct {
 581     WORD Start;
 582     WORD End;
 583     WORD StartCoverageIndex;
 584 } GSUB_RangeRecord;
 585
 586 typedef struct {
 587     WORD CoverageFormat;
 588     WORD RangeCount;
 589     GSUB_RangeRecord RangeRecord[1];
 590 } GSUB_CoverageFormat2;
 591
 592 typedef struct {
 593     WORD SubstFormat; /* = 1 */
 594     WORD Coverage;
 595     WORD DeltaGlyphID;
 596 } GSUB_SingleSubstFormat1;
 597
 598 typedef struct {
 599     WORD SubstFormat; /* = 2 */
 600     WORD Coverage;
 601     WORD GlyphCount;
 602     WORD Substitute[1];
 603 }GSUB_SingleSubstFormat2;
 604
 605 #ifdef HAVE_CARBON_CARBON_H
 606 static char *find_cache_dir(void)
 607 {
 608     FSRef ref;
 609     OSErr err;
 610     static char cached_path[MAX_PATH];
 611     static const char *wine = "/Wine", *fonts = "/Fonts";
 612
 613     if(*cached_path) return cached_path;
 614
 615     err = FSFindFolder(kUserDomain, kCachedDataFolderType, kCreateFolder, &ref);
 616     if(err != noErr)
 617     {
 618         WARN("can't create cached data folder\n");
 619         return NULL;
 620     }
 621     err = FSRefMakePath(&ref, (unsigned char*)cached_path, sizeof(cached_path));
 622     if(err != noErr)
 623     {
 624         WARN("can't create cached data path\n");
 625         *cached_path = '\0';
 626         return NULL;
 627     }
 628     if(strlen(cached_path) + strlen(wine) + strlen(fonts) + 1 > sizeof(cached_path))
 629     {
 630         ERR("Could not create full path\n");
 631         *cached_path = '\0';
 632         return NULL;
 633     }
 634     strcat(cached_path, wine);
 635
 636     if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
 637     {
 638         WARN("Couldn't mkdir %s\n", cached_path);
 639         *cached_path = '\0';
 640         return NULL;
 641     }
 642     strcat(cached_path, fonts);
 643     if(mkdir(cached_path, 0700) == -1 && errno != EEXIST)
 644     {
 645         WARN("Couldn't mkdir %s\n", cached_path);
 646         *cached_path = '\0';
 647         return NULL;
 648     }
 649     return cached_path;
 650 }
 651
 652 /******************************************************************
 653  *            expand_mac_font
 654  *
 655  * Extracts individual TrueType font files from a Mac suitcase font
 656  * and saves them into the user's caches directory (see
 657  * find_cache_dir()).
 658  * Returns a NULL terminated array of filenames.
 659  *
 660  * We do this because they are apps that try to read ttf files
 661  * themselves and they don't like Mac suitcase files.
 662  */
 663 static char **expand_mac_font(const char *path)
 664 {
 665     FSRef ref;
 666     SInt16 res_ref;
 667     OSStatus s;
 668     unsigned int idx;
 669     const char *out_dir;
 670     const char *filename;
 671     int output_len;
 672     struct {
 673         char **array;
 674         unsigned int size, max_size;
 675     } ret;
 676
 677     TRACE("path %s\n", path);
 678
 679     s = FSPathMakeRef((unsigned char*)path, &ref, FALSE);
 680     if(s != noErr)
 681     {
 682         WARN("failed to get ref\n");
 683         return NULL;
 684     }
 685
 686     s = FSOpenResourceFile(&ref, 0, NULL, fsRdPerm, &res_ref);
 687     if(s != noErr)
 688     {
 689         TRACE("no data fork, so trying resource fork\n");
 690         res_ref = FSOpenResFile(&ref, fsRdPerm);
 691         if(res_ref == -1)
 692         {
 693             TRACE("unable to open resource fork\n");
 694             return NULL;
 695         }
 696     }
 697
 698     ret.size = 0;
 699     ret.max_size = 10;
 700     ret.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.max_size * sizeof(*ret.array));
 701     if(!ret.array)
 702     {
 703         CloseResFile(res_ref);
 704         return NULL;
 705     }
 706
 707     out_dir = find_cache_dir();
 708
 709     filename = strrchr(path, '/');
 710     if(!filename) filename = path;
 711     else filename++;
 712
 713     /* output filename has the form out_dir/filename_%04x.ttf */
 714     output_len = strlen(out_dir) + 1 + strlen(filename) + 5 + 5;
 715
 716     UseResFile(res_ref);
 717     idx = 1;
 718     while(1)
 719     {
 720         FamRec *fam_rec;
 721         unsigned short *num_faces_ptr, num_faces, face;
 722         AsscEntry *assoc;
 723         Handle fond;
 724         ResType fond_res = FT_MAKE_TAG('F','O','N','D');
 725
 726         fond = Get1IndResource(fond_res, idx);
 727         if(!fond) break;
 728         TRACE("got fond resource %d\n", idx);
 729         HLock(fond);
 730
 731         fam_rec = *(FamRec**)fond;
 732         num_faces_ptr = (unsigned short *)(fam_rec + 1);
 733         num_faces = GET_BE_WORD(*num_faces_ptr);
 734         num_faces++;
 735         assoc = (AsscEntry*)(num_faces_ptr + 1);
 736         TRACE("num faces %04x\n", num_faces);
 737         for(face = 0; face < num_faces; face++, assoc++)
 738         {
 739             Handle sfnt;
 740             ResType sfnt_res = FT_MAKE_TAG('s','f','n','t');
 741             unsigned short size, font_id;
 742             char *output;
 743
 744             size = GET_BE_WORD(assoc->fontSize);
 745             font_id = GET_BE_WORD(assoc->fontID);
 746             if(size != 0)
 747             {
 748                 TRACE("skipping id %04x because it's not scalable (fixed size %d)\n", font_id, size);
 749                 continue;
 750             }
 751
 752             TRACE("trying to load sfnt id %04x\n", font_id);
 753             sfnt = GetResource(sfnt_res, font_id);
 754             if(!sfnt)
 755             {
 756                 TRACE("can't get sfnt resource %04x\n", font_id);
 757                 continue;
 758             }
 759
 760             output = HeapAlloc(GetProcessHeap(), 0, output_len);
 761             if(output)
 762             {
 763                 int fd;
 764
 765                 sprintf(output, "%s/%s_%04x.ttf", out_dir, filename, font_id);
 766
 767                 fd = open(output, O_CREAT | O_EXCL | O_WRONLY, 0600);
 768                 if(fd != -1 || errno == EEXIST)
 769                 {
 770                     if(fd != -1)
 771                     {
 772                         unsigned char *sfnt_data;
 773
 774                         HLock(sfnt);
 775                         sfnt_data = *(unsigned char**)sfnt;
 776                         write(fd, sfnt_data, GetHandleSize(sfnt));
 777                         HUnlock(sfnt);
 778                         close(fd);
 779                     }
 780                     if(ret.size >= ret.max_size - 1) /* Always want the last element to be NULL */
 781                     {
 782                         ret.max_size *= 2;
 783                         ret.array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ret.array, ret.max_size * sizeof(*ret.array));
 784                     }
 785                     ret.array[ret.size++] = output;
 786                 }
 787                 else
 788                 {
 789                     WARN("unable to create %s\n", output);
 790                     HeapFree(GetProcessHeap(), 0, output);
 791                 }
 792             }
 793             ReleaseResource(sfnt);
 794         }
 795         HUnlock(fond);
 796         ReleaseResource(fond);
 797         idx++;
 798     }
 799     CloseResFile(res_ref);
 800
 801     return ret.array;
 802 }
 803
 804 #endif /* HAVE_CARBON_CARBON_H */
 805
 806 static inline BOOL is_win9x(void)
 807 {
 808     return GetVersion() & 0x80000000;
 809 }
 810 /*
 811    This function builds an FT_Fixed from a double. It fails if the absolute
 812    value of the float number is greater than 32768.
 813 */
 814 static inline FT_Fixed FT_FixedFromFloat(double f)
 815 {
 816         return f * 0x10000;
 817 }
 818
 819 /*
 820    This function builds an FT_Fixed from a FIXED. It simply put f.value
 821    in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
 822 */
 823 static inline FT_Fixed FT_FixedFromFIXED(FIXED f)
 824 {
 825         return (FT_Fixed)((long)f.value << 16 | (unsigned long)f.fract);
 826 }
 827
 828
 829 static Face *find_face_from_filename(const WCHAR *file_name, const WCHAR *face_name)
 830 {
 831     Family *family;
 832     Face *face;
 833     const char *file;
 834     DWORD len = WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, NULL, 0, NULL, NULL);
 835     char *file_nameA = HeapAlloc(GetProcessHeap(), 0, len);
 836
 837     WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, file_nameA, len, NULL, NULL);
 838     TRACE("looking for file %s name %s\n", debugstr_a(file_nameA), debugstr_w(face_name));
 839
 840     LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
 841     {
 842         if(face_name && strcmpiW(face_name, family->FamilyName))
 843             continue;
 844         LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
 845         {
 846             if (!face->file)
 847                 continue;
 848             file = strrchr(face->file, '/');
 849             if(!file)
 850                 file = face->file;
 851             else
 852                 file++;
 853             if(!strcasecmp(file, file_nameA))
 854             {
 855                 HeapFree(GetProcessHeap(), 0, file_nameA);
 856                 return face;
 857             }
 858         }
 859     }
 860     HeapFree(GetProcessHeap(), 0, file_nameA);
 861     return NULL;
 862 }
 863
 864 static Family *find_family_from_name(const WCHAR *name)
 865 {
 866     Family *family;
 867
 868     LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
 869     {
 870         if(!strcmpiW(family->FamilyName, name))
 871             return family;
 872     }
 873
 874     return NULL;
 875 }
 876
 877 static void DumpSubstList(void)
 878 {
 879     FontSubst *psub;
 880
 881     LIST_FOR_EACH_ENTRY(psub, &font_subst_list, FontSubst, entry)
 882     {
 883         if(psub->from.charset != -1 || psub->to.charset != -1)
 884             TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
 885               psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
 886         else
 887             TRACE("%s -> %s\n", debugstr_w(psub->from.name),
 888                   debugstr_w(psub->to.name));
 889     }
 890     return;
 891 }
 892
 893 static LPWSTR strdupW(LPCWSTR p)
 894 {
 895     LPWSTR ret;
 896     DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
 897     ret = HeapAlloc(GetProcessHeap(), 0, len);
 898     memcpy(ret, p, len);
 899     return ret;
 900 }
 901
 902 static LPSTR strdupA(LPCSTR p)
 903 {
 904     LPSTR ret;
 905     DWORD len = (strlen(p) + 1);
 906     ret = HeapAlloc(GetProcessHeap(), 0, len);
 907     memcpy(ret, p, len);
 908     return ret;
 909 }
 910
 911 static FontSubst *get_font_subst(const struct list *subst_list, const WCHAR *from_name,
 912                                  INT from_charset)
 913 {
 914     FontSubst *element;
 915
 916     LIST_FOR_EACH_ENTRY(element, subst_list, FontSubst, entry)
 917     {
 918         if(!strcmpiW(element->from.name, from_name) &&
 919            (element->from.charset == from_charset ||
 920             element->from.charset == -1))
 921             return element;
 922     }
 923
 924     return NULL;
 925 }
 926
 927 #define ADD_FONT_SUBST_FORCE  1
 928
 929 static BOOL add_font_subst(struct list *subst_list, FontSubst *subst, INT flags)
 930 {
 931     FontSubst *from_exist, *to_exist;
 932
 933     from_exist = get_font_subst(subst_list, subst->from.name, subst->from.charset);
 934
 935     if(from_exist && (flags & ADD_FONT_SUBST_FORCE))
 936     {
 937         list_remove(&from_exist->entry);
 938         HeapFree(GetProcessHeap(), 0, &from_exist->from.name);
 939         HeapFree(GetProcessHeap(), 0, &from_exist->to.name);
 940         HeapFree(GetProcessHeap(), 0, from_exist);
 941         from_exist = NULL;
 942     }
 943
 944     if(!from_exist)
 945     {
 946         to_exist = get_font_subst(subst_list, subst->to.name, subst->to.charset);
 947
 948         if(to_exist)
 949         {
 950             HeapFree(GetProcessHeap(), 0, subst->to.name);
 951             subst->to.name = strdupW(to_exist->to.name);
 952         }
 953
 954         list_add_tail(subst_list, &subst->entry);
 955
 956         return TRUE;
 957     }
 958
 959     HeapFree(GetProcessHeap(), 0, subst->from.name);
 960     HeapFree(GetProcessHeap(), 0, subst->to.name);
 961     HeapFree(GetProcessHeap(), 0, subst);
 962     return FALSE;
 963 }
 964
 965 static void split_subst_info(NameCs *nc, LPSTR str)
 966 {
 967     CHAR *p = strrchr(str, ',');
 968     DWORD len;
 969
 970     nc->charset = -1;
 971     if(p && *(p+1)) {
 972         nc->charset = strtol(p+1, NULL, 10);
 973         *p = '\0';
 974     }
 975     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 976     nc->name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 977     MultiByteToWideChar(CP_ACP, 0, str, -1, nc->name, len);
 978 }
 979
 980 static void LoadSubstList(void)
 981 {
 982     FontSubst *psub;
 983     HKEY hkey;
 984     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
 985     LPSTR value;
 986     LPVOID data;
 987
 988     if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
 989                    "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
 990                    &hkey) == ERROR_SUCCESS) {
 991
 992         RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 993                          &valuelen, &datalen, NULL, NULL);
 994
 995         valuelen++; /* returned value doesn't include room for '\0' */
 996         value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
 997         data = HeapAlloc(GetProcessHeap(), 0, datalen);
 998
 999         dlen = datalen;
1000         vlen = valuelen;
1001         while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
1002                             &dlen) == ERROR_SUCCESS) {
1003             TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
1004
1005             psub = HeapAlloc(GetProcessHeap(), 0, sizeof(*psub));
1006             split_subst_info(&psub->from, value);
1007             split_subst_info(&psub->to, data);
1008
1009             /* Win 2000 doesn't allow mapping between different charsets
1010                or mapping of DEFAULT_CHARSET */
1011             if ((psub->from.charset && psub->to.charset != psub->from.charset) ||
1012                psub->to.charset == DEFAULT_CHARSET) {
1013                 HeapFree(GetProcessHeap(), 0, psub->to.name);
1014                 HeapFree(GetProcessHeap(), 0, psub->from.name);
1015                 HeapFree(GetProcessHeap(), 0, psub);
1016             } else {
1017                 add_font_subst(&font_subst_list, psub, 0);
1018             }
1019             /* reset dlen and vlen */
1020             dlen = datalen;
1021             vlen = valuelen;
1022         }
1023         HeapFree(GetProcessHeap(), 0, data);
1024         HeapFree(GetProcessHeap(), 0, value);
1025         RegCloseKey(hkey);
1026     }
1027 }
1028
1029
1030 /*****************************************************************
1031  *       get_name_table_entry
1032  *
1033  * Supply the platform, encoding, language and name ids in req
1034  * and if the name exists the function will fill in the string
1035  * and string_len members.  The string is owned by FreeType so
1036  * don't free it.  Returns TRUE if the name is found else FALSE.
1037  */
1038 static BOOL get_name_table_entry(FT_Face ft_face, FT_SfntName *req)
1039 {
1040     FT_SfntName name;
1041     FT_UInt num_names, name_index;
1042
1043     if(FT_IS_SFNT(ft_face))
1044     {
1045         num_names = pFT_Get_Sfnt_Name_Count(ft_face);
1046
1047         for(name_index = 0; name_index < num_names; name_index++)
1048         {
1049             if(!pFT_Get_Sfnt_Name(ft_face, name_index, &name))
1050             {
1051                 if((name.platform_id == req->platform_id) &&
1052                    (name.encoding_id == req->encoding_id) &&
1053                    (name.language_id == req->language_id) &&
1054                    (name.name_id     == req->name_id))
1055                 {
1056                     req->string = name.string;
1057                     req->string_len = name.string_len;
1058                     return TRUE;
1059                 }
1060             }
1061         }
1062     }
1063     req->string = NULL;
1064     req->string_len = 0;
1065     return FALSE;
1066 }
1067
1068 static WCHAR *get_familyname(FT_Face ft_face)
1069 {
1070     WCHAR *family = NULL;
1071     FT_SfntName name;
1072
1073     name.platform_id = TT_PLATFORM_MICROSOFT;
1074     name.encoding_id = TT_MS_ID_UNICODE_CS;
1075     name.language_id = GetUserDefaultLCID();
1076     name.name_id     = TT_NAME_ID_FONT_FAMILY;
1077
1078     if(get_name_table_entry(ft_face, &name))
1079     {
1080         FT_UInt i;
1081
1082         /* String is not nul terminated and string_len is a byte length. */
1083         family = HeapAlloc(GetProcessHeap(), 0, name.string_len + 2);
1084         for(i = 0; i < name.string_len / 2; i++)
1085         {
1086             WORD *tmp = (WORD *)&name.string[i * 2];
1087             family[i] = GET_BE_WORD(*tmp);
1088         }
1089         family[i] = 0;
1090         TRACE("Got localised name %s\n", debugstr_w(family));
1091     }
1092
1093     return family;
1094 }
1095
1096
1097 /*****************************************************************
1098  *  load_sfnt_table
1099  *
1100  * Wrapper around FT_Load_Sfnt_Table to cope with older versions
1101  * of FreeType that don't export this function.
1102  *
1103  */
1104 static FT_Error load_sfnt_table(FT_Face ft_face, FT_ULong table, FT_Long offset, FT_Byte *buf, FT_ULong *len)
1105 {
1106
1107     FT_Error err;
1108
1109     /* If the FT_Load_Sfnt_Table function is there we'll use it */
1110     if(pFT_Load_Sfnt_Table)
1111     {
1112         err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, len);
1113     }
1114 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
1115     else  /* Do it the hard way */
1116     {
1117         TT_Face tt_face = (TT_Face) ft_face;
1118         SFNT_Interface *sfnt;
1119         if (FT_Version.major==2 && FT_Version.minor==0)
1120         {
1121             /* 2.0.x */
1122             sfnt = *(SFNT_Interface**)((char*)tt_face + 528);
1123         }
1124         else
1125         {
1126             /* A field was added in the middle of the structure in 2.1.x */
1127             sfnt = *(SFNT_Interface**)((char*)tt_face + 532);
1128         }
1129         err = sfnt->load_any(tt_face, table, offset, buf, len);
1130     }
1131 #else
1132     else
1133     {
1134         static int msg;
1135         if(!msg)
1136         {
1137             MESSAGE("This version of Wine was compiled with freetype headers later than 2.2.0\n"
1138                     "but is being run with a freetype library without the FT_Load_Sfnt_Table function.\n"
1139                     "Please upgrade your freetype library.\n");
1140             msg++;
1141         }
1142         err = FT_Err_Unimplemented_Feature;
1143     }
1144 #endif
1145     return err;
1146 }
1147
1148 static inline int TestStyles(DWORD flags, DWORD styles)
1149 {
1150     return (flags & styles) == styles;
1151 }
1152
1153 static int StyleOrdering(Face *face)
1154 {
1155     if (TestStyles(face->ntmFlags, NTM_BOLD | NTM_ITALIC))
1156         return 3;
1157     if (TestStyles(face->ntmFlags, NTM_ITALIC))
1158         return 2;
1159     if (TestStyles(face->ntmFlags, NTM_BOLD))
1160         return 1;
1161     if (TestStyles(face->ntmFlags, NTM_REGULAR))
1162         return 0;
1163
1164     WARN("Don't know how to order font %s %s with flags 0x%08x\n",
1165          debugstr_w(face->family->FamilyName),
1166          debugstr_w(face->StyleName),
1167          face->ntmFlags);
1168
1169     return 9999;
1170 }
1171
1172 /* Add a style of face to a font family using an ordering of the list such
1173    that regular fonts come before bold and italic, and single styles come
1174    before compound styles.  */
1175 static void AddFaceToFamily(Face *face, Family *family)
1176 {
1177     struct list *entry;
1178
1179     LIST_FOR_EACH( entry, &family->faces )
1180     {
1181         Face *ent = LIST_ENTRY(entry, Face, entry);
1182         if (StyleOrdering(face) < StyleOrdering(ent)) break;
1183     }
1184     list_add_before( entry, &face->entry );
1185 }
1186
1187 #define ADDFONT_EXTERNAL_FONT 0x01
1188 #define ADDFONT_FORCE_BITMAP  0x02
1189 static INT AddFontToList(const char *file, void *font_data_ptr, DWORD font_data_size, char *fake_family, const WCHAR *target_family, DWORD flags)
1190 {
1191     FT_Face ft_face;
1192     TT_OS2 *pOS2;
1193     TT_Header *pHeader = NULL;
1194     WCHAR *english_family, *localised_family, *StyleW;
1195     DWORD len;
1196     Family *family;
1197     Face *face;
1198     struct list *family_elem_ptr, *face_elem_ptr;
1199     FT_Error err;
1200     FT_Long face_index = 0, num_faces;
1201 #ifdef HAVE_FREETYPE_FTWINFNT_H
1202     FT_WinFNT_HeaderRec winfnt_header;
1203 #endif
1204     int i, bitmap_num, internal_leading;
1205     FONTSIGNATURE fs;
1206
1207     /* we always load external fonts from files - otherwise we would get a crash in update_reg_entries */
1208     assert(file || !(flags & ADDFONT_EXTERNAL_FONT));
1209
1210 #ifdef HAVE_CARBON_CARBON_H
1211     if(file && !fake_family)
1212     {
1213         char **mac_list = expand_mac_font(file);
1214         if(mac_list)
1215         {
1216             BOOL had_one = FALSE;
1217             char **cursor;
1218             for(cursor = mac_list; *cursor; cursor++)
1219             {
1220                 had_one = TRUE;
1221                 AddFontToList(*cursor, NULL, 0, NULL, NULL, flags);
1222                 HeapFree(GetProcessHeap(), 0, *cursor);
1223             }
1224             HeapFree(GetProcessHeap(), 0, mac_list);
1225             if(had_one)
1226                 return 1;
1227         }
1228     }
1229 #endif /* HAVE_CARBON_CARBON_H */
1230
1231     do {
1232         char *family_name = fake_family;
1233
1234         if (file)
1235         {
1236             TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
1237             err = pFT_New_Face(library, file, face_index, &ft_face);
1238         } else
1239         {
1240             TRACE("Loading font from ptr %p size %d, index %ld\n", font_data_ptr, font_data_size, face_index);
1241             err = pFT_New_Memory_Face(library, font_data_ptr, font_data_size, face_index, &ft_face);
1242         }
1243
1244         if(err != 0) {
1245             WARN("Unable to load font %s/%p err = %x\n", debugstr_a(file), font_data_ptr, err);
1246             return 0;
1247         }
1248
1249         if(!FT_IS_SFNT(ft_face) && (FT_IS_SCALABLE(ft_face) || !(flags & ADDFONT_FORCE_BITMAP))) { /* for now we'll accept TT/OT or bitmap fonts*/
1250             WARN("Ignoring font %s/%p\n", debugstr_a(file), font_data_ptr);
1251             pFT_Done_Face(ft_face);
1252             return 0;
1253         }
1254
1255         /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
1256         if(!FT_IS_SCALABLE(ft_face) && FT_SimpleVersion < ((2 << 16) | (1 << 8) | (9 << 0))) {
1257             WARN("FreeType version < 2.1.9, skipping bitmap font %s/%p\n", debugstr_a(file), font_data_ptr);
1258             pFT_Done_Face(ft_face);
1259             return 0;
1260         }
1261
1262         if(FT_IS_SFNT(ft_face))
1263         {
1264             if(!(pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2)) ||
1265                !pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea) ||
1266                !(pHeader = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_head)))
1267             {
1268                 TRACE("Font %s/%p lacks either an OS2, HHEA or HEAD table.\n"
1269                       "Skipping this font.\n", debugstr_a(file), font_data_ptr);
1270                 pFT_Done_Face(ft_face);
1271                 return 0;
1272             }
1273
1274             /* Wine uses ttfs as an intermediate step in building its bitmap fonts;
1275                we don't want to load these. */
1276             if(!memcmp(pOS2->achVendID, "Wine", sizeof(pOS2->achVendID)))
1277             {
1278                 FT_ULong len = 0;
1279
1280                 if(!load_sfnt_table(ft_face, FT_MAKE_TAG('E','B','S','C'), 0, NULL, &len))
1281                 {
1282                     TRACE("Skipping Wine bitmap-only TrueType font %s\n", debugstr_a(file));
1283                     pFT_Done_Face(ft_face);
1284                     return 0;
1285                 }
1286             }
1287         }
1288
1289         if(!ft_face->family_name || !ft_face->style_name) {
1290             TRACE("Font %s/%p lacks either a family or style name\n", debugstr_a(file), font_data_ptr);
1291             pFT_Done_Face(ft_face);
1292             return 0;
1293         }
1294
1295         if(ft_face->family_name[0] == '.') /* Ignore fonts with names beginning with a dot */
1296         {
1297             TRACE("Ignoring %s since its family name begins with a dot\n", debugstr_a(file));
1298             pFT_Done_Face(ft_face);
1299             return 0;
1300         }
1301
1302         if (target_family)
1303         {
1304             localised_family = get_familyname(ft_face);
1305             if (localised_family && strcmpiW(localised_family,target_family)!=0)
1306             {
1307                 TRACE("Skipping Index %i: Incorrect Family name for replacement\n",(INT)face_index);
1308                 HeapFree(GetProcessHeap(), 0, localised_family);
1309                 num_faces = ft_face->num_faces;
1310                 pFT_Done_Face(ft_face);
1311                 continue;
1312             }
1313             HeapFree(GetProcessHeap(), 0, localised_family);
1314         }
1315
1316         if(!family_name)
1317             family_name = ft_face->family_name;
1318
1319         bitmap_num = 0;
1320         do {
1321             My_FT_Bitmap_Size *size = NULL;
1322             FT_ULong tmp_size;
1323
1324             if(!FT_IS_SCALABLE(ft_face))
1325                 size = (My_FT_Bitmap_Size *)ft_face->available_sizes + bitmap_num;
1326
1327             len = MultiByteToWideChar(CP_ACP, 0, family_name, -1, NULL, 0);
1328             english_family = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1329             MultiByteToWideChar(CP_ACP, 0, family_name, -1, english_family, len);
1330
1331             localised_family = NULL;
1332             if(!fake_family) {
1333                 localised_family = get_familyname(ft_face);
1334                 if(localised_family && !strcmpW(localised_family, english_family)) {
1335                     HeapFree(GetProcessHeap(), 0, localised_family);
1336                     localised_family = NULL;
1337                 }
1338             }
1339
1340             family = NULL;
1341             LIST_FOR_EACH(family_elem_ptr, &font_list) {
1342                 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1343                 if(!strcmpW(family->FamilyName, localised_family ? localised_family : english_family))
1344                     break;
1345                 family = NULL;
1346             }
1347             if(!family) {
1348                 family = HeapAlloc(GetProcessHeap(), 0, sizeof(*family));
1349                 family->FamilyName = strdupW(localised_family ? localised_family : english_family);
1350                 list_init(&family->faces);
1351                 list_add_tail(&font_list, &family->entry);
1352
1353                 if(localised_family) {
1354                     FontSubst *subst = HeapAlloc(GetProcessHeap(), 0, sizeof(*subst));
1355                     subst->from.name = strdupW(english_family);
1356                     subst->from.charset = -1;
1357                     subst->to.name = strdupW(localised_family);
1358                     subst->to.charset = -1;
1359                     add_font_subst(&font_subst_list, subst, 0);
1360                 }
1361             }
1362             HeapFree(GetProcessHeap(), 0, localised_family);
1363             HeapFree(GetProcessHeap(), 0, english_family);
1364
1365             len = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0);
1366             StyleW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1367             MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, StyleW, len);
1368
1369             internal_leading = 0;
1370             memset(&fs, 0, sizeof(fs));
1371
1372             pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
1373             if(pOS2) {
1374                 fs.fsCsb[0] = pOS2->ulCodePageRange1;
1375                 fs.fsCsb[1] = pOS2->ulCodePageRange2;
1376                 fs.fsUsb[0] = pOS2->ulUnicodeRange1;
1377                 fs.fsUsb[1] = pOS2->ulUnicodeRange2;
1378                 fs.fsUsb[2] = pOS2->ulUnicodeRange3;
1379                 fs.fsUsb[3] = pOS2->ulUnicodeRange4;
1380                 if(pOS2->version == 0) {
1381                     FT_UInt dummy;
1382
1383                     if(!pFT_Get_First_Char || (pFT_Get_First_Char( ft_face, &dummy ) < 0x100))
1384                         fs.fsCsb[0] |= FS_LATIN1;
1385                     else
1386                         fs.fsCsb[0] |= FS_SYMBOL;
1387                 }
1388             }
1389 #ifdef HAVE_FREETYPE_FTWINFNT_H
1390             else if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header)) {
1391                 CHARSETINFO csi;
1392                 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header.pixel_height, winfnt_header.charset,
1393                       winfnt_header.vertical_resolution,winfnt_header.horizontal_resolution, winfnt_header.nominal_point_size);
1394                 if(TranslateCharsetInfo((DWORD*)(UINT_PTR)winfnt_header.charset, &csi, TCI_SRCCHARSET))
1395                     fs = csi.fs;
1396                 internal_leading = winfnt_header.internal_leading;
1397             }
1398 #endif
1399
1400             face_elem_ptr = list_head(&family->faces);
1401             while(face_elem_ptr) {
1402                 face = LIST_ENTRY(face_elem_ptr, Face, entry);
1403                 face_elem_ptr = list_next(&family->faces, face_elem_ptr);
1404                 if(!strcmpW(face->StyleName, StyleW) &&
1405                    (FT_IS_SCALABLE(ft_face) || ((size->y_ppem == face->size.y_ppem) && !memcmp(&fs, &face->fs, sizeof(fs)) ))) {
1406                     TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
1407                           debugstr_w(family->FamilyName), debugstr_w(StyleW),
1408                           face->font_version,  pHeader ? pHeader->Font_Revision : 0);
1409
1410                     if(fake_family) {
1411                         TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
1412                         HeapFree(GetProcessHeap(), 0, StyleW);
1413                         pFT_Done_Face(ft_face);
1414                         return 1;
1415                     }
1416                     if(!pHeader || pHeader->Font_Revision <= face->font_version) {
1417                         TRACE("Original font is newer so skipping this one\n");
1418                         HeapFree(GetProcessHeap(), 0, StyleW);
1419                         pFT_Done_Face(ft_face);
1420                         return 1;
1421                     } else {
1422                         TRACE("Replacing original with this one\n");
1423                         list_remove(&face->entry);
1424                         HeapFree(GetProcessHeap(), 0, face->file);
1425                         HeapFree(GetProcessHeap(), 0, face->StyleName);
1426                         HeapFree(GetProcessHeap(), 0, face);
1427                         break;
1428                     }
1429                 }
1430             }
1431             face = HeapAlloc(GetProcessHeap(), 0, sizeof(*face));
1432             face->cached_enum_data = NULL;
1433             face->StyleName = StyleW;
1434             if (file)
1435             {
1436                 face->file = strdupA(file);
1437                 face->font_data_ptr = NULL;
1438                 face->font_data_size = 0;
1439             }
1440             else
1441             {
1442                 face->file = NULL;
1443                 face->font_data_ptr = font_data_ptr;
1444                 face->font_data_size = font_data_size;
1445             }
1446             face->face_index = face_index;
1447             face->ntmFlags = 0;
1448             if (ft_face->style_flags & FT_STYLE_FLAG_ITALIC)
1449                 face->ntmFlags |= NTM_ITALIC;
1450             if (ft_face->style_flags & FT_STYLE_FLAG_BOLD)
1451                 face->ntmFlags |= NTM_BOLD;
1452             if (face->ntmFlags == 0) face->ntmFlags = NTM_REGULAR;
1453             face->font_version = pHeader ? pHeader->Font_Revision : 0;
1454             face->family = family;
1455             face->external = (flags & ADDFONT_EXTERNAL_FONT) ? TRUE : FALSE;
1456             face->fs = fs;
1457             memset(&face->fs_links, 0, sizeof(face->fs_links));
1458
1459             if(FT_IS_SCALABLE(ft_face)) {
1460                 memset(&face->size, 0, sizeof(face->size));
1461                 face->scalable = TRUE;
1462             } else {
1463                 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
1464                       size->height, size->width, size->size >> 6,
1465                       size->x_ppem >> 6, size->y_ppem >> 6);
1466                 face->size.height = size->height;
1467                 face->size.width = size->width;
1468                 face->size.size = size->size;
1469                 face->size.x_ppem = size->x_ppem;
1470                 face->size.y_ppem = size->y_ppem;
1471                 face->size.internal_leading = internal_leading;
1472                 face->scalable = FALSE;
1473             }
1474
1475             /* check for the presence of the 'CFF ' table to check if the font is Type1 */
1476             tmp_size = 0;
1477             if (pFT_Load_Sfnt_Table && !pFT_Load_Sfnt_Table(ft_face, FT_MAKE_TAG('C','F','F',' '), 0, NULL, &tmp_size))
1478             {
1479                 TRACE("Font %s/%p is OTF Type1\n", wine_dbgstr_a(file), font_data_ptr);
1480                 face->ntmFlags |= NTM_PS_OPENTYPE;
1481             }
1482
1483             TRACE("fsCsb = %08x %08x/%08x %08x %08x %08x\n",
1484                   face->fs.fsCsb[0], face->fs.fsCsb[1],
1485                   face->fs.fsUsb[0], face->fs.fsUsb[1],
1486                   face->fs.fsUsb[2], face->fs.fsUsb[3]);
1487
1488
1489             if(face->fs.fsCsb[0] == 0) { /* let's see if we can find any interesting cmaps */
1490                 for(i = 0; i < ft_face->num_charmaps; i++) {
1491                     switch(ft_face->charmaps[i]->encoding) {
1492                     case FT_ENCODING_UNICODE:
1493                     case FT_ENCODING_APPLE_ROMAN:
1494                         face->fs.fsCsb[0] |= FS_LATIN1;
1495                         break;
1496                     case FT_ENCODING_MS_SYMBOL:
1497                         face->fs.fsCsb[0] |= FS_SYMBOL;
1498                         break;
1499                     default:
1500                         break;
1501                     }
1502                 }
1503             }
1504
1505             if (!(face->fs.fsCsb[0] & FS_SYMBOL))
1506                 have_installed_roman_font = TRUE;
1507
1508             AddFaceToFamily(face, family);
1509
1510         } while(!FT_IS_SCALABLE(ft_face) && ++bitmap_num < ft_face->num_fixed_sizes);
1511
1512         num_faces = ft_face->num_faces;
1513         pFT_Done_Face(ft_face);
1514         TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
1515               debugstr_w(StyleW));
1516     } while(num_faces > ++face_index);
1517     return num_faces;
1518 }
1519
1520 static INT AddFontFileToList(const char *file, char *fake_family, const WCHAR *target_family, DWORD flags)
1521 {
1522     return AddFontToList(file, NULL, 0, fake_family, target_family, flags);
1523 }
1524
1525 static void DumpFontList(void)
1526 {
1527     Family *family;
1528     Face *face;
1529     struct list *family_elem_ptr, *face_elem_ptr;
1530
1531     LIST_FOR_EACH(family_elem_ptr, &font_list) {
1532         family = LIST_ENTRY(family_elem_ptr, Family, entry);
1533         TRACE("Family: %s\n", debugstr_w(family->FamilyName));
1534         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1535             face = LIST_ENTRY(face_elem_ptr, Face, entry);
1536             TRACE("\t%s\t%08x", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
1537             if(!face->scalable)
1538                 TRACE(" %d", face->size.height);
1539             TRACE("\n");
1540         }
1541     }
1542     return;
1543 }
1544
1545 /***********************************************************
1546  * The replacement list is a way to map an entire font
1547  * family onto another family.  For example adding
1548  *
1549  * [HKCU\Software\Wine\Fonts\Replacements]
1550  * "Wingdings"="Winedings"
1551  *
1552  * would enumerate the Winedings font both as Winedings and
1553  * Wingdings.  However if a real Wingdings font is present the
1554  * replacement does not take place.
1555  *
1556  */
1557 static void LoadReplaceList(void)
1558 {
1559     HKEY hkey;
1560     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1561     LPWSTR value;
1562     LPVOID data;
1563     Family *family;
1564     Face *face;
1565     struct list *family_elem_ptr, *face_elem_ptr;
1566     CHAR familyA[400];
1567
1568     /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
1569     if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
1570     {
1571         RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1572                          &valuelen, &datalen, NULL, NULL);
1573
1574         valuelen++; /* returned value doesn't include room for '\0' */
1575         value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1576         data = HeapAlloc(GetProcessHeap(), 0, datalen);
1577
1578         dlen = datalen;
1579         vlen = valuelen;
1580         while(RegEnumValueW(hkey, i++, value, &vlen, NULL, &type, data,
1581                             &dlen) == ERROR_SUCCESS) {
1582             TRACE("Got %s=%s\n", debugstr_w(value), debugstr_w(data));
1583             /* "NewName"="Oldname" */
1584             WideCharToMultiByte(CP_ACP, 0, value, -1, familyA, sizeof(familyA), NULL, NULL);
1585
1586             /* Find the old family and hence all of the font files
1587                in that family */
1588             LIST_FOR_EACH(family_elem_ptr, &font_list) {
1589                 family = LIST_ENTRY(family_elem_ptr, Family, entry);
1590                 if(!strcmpiW(family->FamilyName, data)) {
1591                     LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1592                         face = LIST_ENTRY(face_elem_ptr, Face, entry);
1593                         TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
1594                               debugstr_w(face->StyleName), familyA);
1595                         /* Now add a new entry with the new family name */
1596                         AddFontToList(face->file, face->font_data_ptr, face->font_data_size, familyA, family->FamilyName, ADDFONT_FORCE_BITMAP | (face->external ? ADDFONT_EXTERNAL_FONT : 0));
1597                     }
1598                     break;
1599                 }
1600             }
1601             /* reset dlen and vlen */
1602             dlen = datalen;
1603             vlen = valuelen;
1604         }
1605         HeapFree(GetProcessHeap(), 0, data);
1606         HeapFree(GetProcessHeap(), 0, value);
1607         RegCloseKey(hkey);
1608     }
1609 }
1610
1611 /*************************************************************
1612  * init_system_links
1613  */
1614 static BOOL init_system_links(void)
1615 {
1616     static const WCHAR system_link[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1617                                         'W','i','n','d','o','w','s',' ','N','T','\\',
1618                                         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
1619                                         'S','y','s','t','e','m','L','i','n','k',0};
1620     HKEY hkey;
1621     BOOL ret = FALSE;
1622     DWORD type, max_val, max_data, val_len, data_len, index;
1623     WCHAR *value, *data;
1624     WCHAR *entry, *next;
1625     SYSTEM_LINKS *font_link, *system_font_link;
1626     CHILD_FONT *child_font;
1627     static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
1628     static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
1629     static const WCHAR System[] = {'S','y','s','t','e','m',0};
1630     FONTSIGNATURE fs;
1631     Family *family;
1632     Face *face;
1633     FontSubst *psub;
1634
1635     if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
1636     {
1637         RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
1638         value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
1639         data = HeapAlloc(GetProcessHeap(), 0, max_data);
1640         val_len = max_val + 1;
1641         data_len = max_data;
1642         index = 0;
1643         while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
1644         {
1645             TRACE("%s:\n", debugstr_w(value));
1646
1647             memset(&fs, 0, sizeof(fs));
1648             font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
1649             psub = get_font_subst(&font_subst_list, value, -1);
1650             font_link->font_name = (psub)? strdupW(psub->to.name) : strdupW(value);
1651             list_init(&font_link->links);
1652             for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
1653             {
1654                 WCHAR *face_name;
1655                 CHILD_FONT *child_font;
1656
1657                 TRACE("\t%s\n", debugstr_w(entry));
1658
1659                 next = entry + strlenW(entry) + 1;
1660
1661                 face_name = strchrW(entry, ',');
1662                 if(face_name)
1663                 {
1664                     *face_name++ = 0;
1665                     while(isspaceW(*face_name))
1666                         face_name++;
1667
1668                     psub = get_font_subst(&font_subst_list, face_name, -1);
1669                     if(psub)
1670                         face_name = psub->to.name;
1671                 }
1672                 face = find_face_from_filename(entry, face_name);
1673                 if(!face)
1674                 {
1675                     TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
1676                     continue;
1677                 }
1678
1679                 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1680                 child_font->face = face;
1681                 child_font->font = NULL;
1682                 fs.fsCsb[0] |= face->fs.fsCsb[0];
1683                 fs.fsCsb[1] |= face->fs.fsCsb[1];
1684                 TRACE("Adding file %s index %ld\n", child_font->face->file, child_font->face->face_index);
1685                 list_add_tail(&font_link->links, &child_font->entry);
1686             }
1687             family = find_family_from_name(font_link->font_name);
1688             if(family)
1689             {
1690                 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
1691                 {
1692                     face->fs_links = fs;
1693                 }
1694             }
1695             list_add_tail(&system_links, &font_link->entry);
1696             val_len = max_val + 1;
1697             data_len = max_data;
1698         }
1699
1700         HeapFree(GetProcessHeap(), 0, value);
1701         HeapFree(GetProcessHeap(), 0, data);
1702         RegCloseKey(hkey);
1703     }
1704
1705     /* Explicitly add an entry for the system font, this links to Tahoma and any links
1706        that Tahoma has */
1707
1708     system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
1709     system_font_link->font_name = strdupW(System);
1710     list_init(&system_font_link->links);
1711
1712     face = find_face_from_filename(tahoma_ttf, Tahoma);
1713     if(face)
1714     {
1715         child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1716         child_font->face = face;
1717         child_font->font = NULL;
1718         TRACE("Found Tahoma in %s index %ld\n", child_font->face->file, child_font->face->face_index);
1719         list_add_tail(&system_font_link->links, &child_font->entry);
1720     }
1721     LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
1722     {
1723         if(!strcmpiW(font_link->font_name, Tahoma))
1724         {
1725             CHILD_FONT *font_link_entry;
1726             LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
1727             {
1728                 CHILD_FONT *new_child;
1729                 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
1730                 new_child->face = font_link_entry->face;
1731                 new_child->font = NULL;
1732                 list_add_tail(&system_font_link->links, &new_child->entry);
1733             }
1734             break;
1735         }
1736     }
1737     list_add_tail(&system_links, &system_font_link->entry);
1738     return ret;
1739 }
1740
1741 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
1742 {
1743     DIR *dir;
1744     struct dirent *dent;
1745     char path[MAX_PATH];
1746
1747     TRACE("Loading fonts from %s\n", debugstr_a(dirname));
1748
1749     dir = opendir(dirname);
1750     if(!dir) {
1751         WARN("Can't open directory %s\n", debugstr_a(dirname));
1752         return FALSE;
1753     }
1754     while((dent = readdir(dir)) != NULL) {
1755         struct stat statbuf;
1756
1757         if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
1758             continue;
1759
1760         TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
1761
1762         sprintf(path, "%s/%s", dirname, dent->d_name);
1763
1764         if(stat(path, &statbuf) == -1)
1765         {
1766             WARN("Can't stat %s\n", debugstr_a(path));
1767             continue;
1768         }
1769         if(S_ISDIR(statbuf.st_mode))
1770             ReadFontDir(path, external_fonts);
1771         else
1772             AddFontFileToList(path, NULL, NULL, external_fonts ? ADDFONT_EXTERNAL_FONT : 0);
1773     }
1774     closedir(dir);
1775     return TRUE;
1776 }
1777
1778 static void load_fontconfig_fonts(void)
1779 {
1780 #ifdef SONAME_LIBFONTCONFIG
1781     void *fc_handle = NULL;
1782     FcConfig *config;
1783     FcPattern *pat;
1784     FcObjectSet *os;
1785     FcFontSet *fontset;
1786     int i, len;
1787     char *file;
1788     const char *ext;
1789
1790     fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
1791     if(!fc_handle) {
1792         TRACE("Wine cannot find the fontconfig library (%s).\n",
1793               SONAME_LIBFONTCONFIG);
1794         return;
1795     }
1796 #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;}
1797 LOAD_FUNCPTR(FcConfigGetCurrent);
1798 LOAD_FUNCPTR(FcFontList);
1799 LOAD_FUNCPTR(FcFontSetDestroy);
1800 LOAD_FUNCPTR(FcInit);
1801 LOAD_FUNCPTR(FcObjectSetAdd);
1802 LOAD_FUNCPTR(FcObjectSetCreate);
1803 LOAD_FUNCPTR(FcObjectSetDestroy);
1804 LOAD_FUNCPTR(FcPatternCreate);
1805 LOAD_FUNCPTR(FcPatternDestroy);
1806 LOAD_FUNCPTR(FcPatternGetBool);
1807 LOAD_FUNCPTR(FcPatternGetString);
1808 #undef LOAD_FUNCPTR
1809
1810     if(!pFcInit()) return;
1811
1812     config = pFcConfigGetCurrent();
1813     pat = pFcPatternCreate();
1814     os = pFcObjectSetCreate();
1815     pFcObjectSetAdd(os, FC_FILE);
1816     pFcObjectSetAdd(os, FC_SCALABLE);
1817     fontset = pFcFontList(config, pat, os);
1818     if(!fontset) return;
1819     for(i = 0; i < fontset->nfont; i++) {
1820         FcBool scalable;
1821
1822         if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
1823             continue;
1824         TRACE("fontconfig: %s\n", file);
1825
1826         /* We're just interested in OT/TT fonts for now, so this hack just
1827            picks up the scalable fonts without extensions .pf[ab] to save time
1828            loading every other font */
1829
1830         if(pFcPatternGetBool(fontset->fonts[i], FC_SCALABLE, 0, &scalable) == FcResultMatch && !scalable)
1831         {
1832             TRACE("not scalable\n");
1833             continue;
1834         }
1835
1836         len = strlen( file );
1837         if(len < 4) continue;
1838         ext = &file[ len - 3 ];
1839         if(strcasecmp(ext, "pfa") && strcasecmp(ext, "pfb"))
1840             AddFontFileToList(file, NULL, NULL,  ADDFONT_EXTERNAL_FONT);
1841     }
1842     pFcFontSetDestroy(fontset);
1843     pFcObjectSetDestroy(os);
1844     pFcPatternDestroy(pat);
1845  sym_not_found:
1846 #endif
1847     return;
1848 }
1849
1850 static BOOL load_font_from_data_dir(LPCWSTR file)
1851 {
1852     BOOL ret = FALSE;
1853     const char *data_dir = wine_get_data_dir();
1854
1855     if (!data_dir) data_dir = wine_get_build_dir();
1856
1857     if (data_dir)
1858     {
1859         INT len;
1860         char *unix_name;
1861
1862         len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
1863
1864         unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
1865
1866         strcpy(unix_name, data_dir);
1867         strcat(unix_name, "/fonts/");
1868
1869         WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
1870
1871         EnterCriticalSection( &freetype_cs );
1872         ret = AddFontFileToList(unix_name, NULL, NULL, ADDFONT_FORCE_BITMAP);
1873         LeaveCriticalSection( &freetype_cs );
1874         HeapFree(GetProcessHeap(), 0, unix_name);
1875     }
1876     return ret;
1877 }
1878
1879 static BOOL load_font_from_winfonts_dir(LPCWSTR file)
1880 {
1881     static const WCHAR slashW[] = {'\\','\0'};
1882     BOOL ret = FALSE;
1883     WCHAR windowsdir[MAX_PATH];
1884     char *unixname;
1885
1886     GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1887     strcatW(windowsdir, fontsW);
1888     strcatW(windowsdir, slashW);
1889     strcatW(windowsdir, file);
1890     if ((unixname = wine_get_unix_file_name(windowsdir))) {
1891         EnterCriticalSection( &freetype_cs );
1892         ret = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
1893         LeaveCriticalSection( &freetype_cs );
1894         HeapFree(GetProcessHeap(), 0, unixname);
1895     }
1896     return ret;
1897 }
1898
1899 static void load_system_fonts(void)
1900 {
1901     HKEY hkey;
1902     WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
1903     const WCHAR * const *value;
1904     DWORD dlen, type;
1905     static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
1906     char *unixname;
1907
1908     if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
1909         GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1910         strcatW(windowsdir, fontsW);
1911         for(value = SystemFontValues; *value; value++) {
1912             dlen = sizeof(data);
1913             if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
1914                type == REG_SZ) {
1915                 BOOL added = FALSE;
1916
1917                 sprintfW(pathW, fmtW, windowsdir, data);
1918                 if((unixname = wine_get_unix_file_name(pathW))) {
1919                     added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
1920                     HeapFree(GetProcessHeap(), 0, unixname);
1921                 }
1922                 if (!added)
1923                     load_font_from_data_dir(data);
1924             }
1925         }
1926         RegCloseKey(hkey);
1927     }
1928 }
1929
1930 /*************************************************************
1931  *
1932  * This adds registry entries for any externally loaded fonts
1933  * (fonts from fontconfig or FontDirs).  It also deletes entries
1934  * of no longer existing fonts.
1935  *
1936  */
1937 static void update_reg_entries(void)
1938 {
1939     HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
1940     LPWSTR valueW;
1941     DWORD len, len_fam;
1942     Family *family;
1943     Face *face;
1944     struct list *family_elem_ptr, *face_elem_ptr;
1945     WCHAR *file;
1946     static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
1947     static const WCHAR spaceW[] = {' ', '\0'};
1948     char *path;
1949
1950     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
1951                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
1952         ERR("Can't create Windows font reg key\n");
1953         goto end;
1954     }
1955
1956     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
1957                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
1958         ERR("Can't create Windows font reg key\n");
1959         goto end;
1960     }
1961
1962     if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
1963                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &external_key, NULL) != ERROR_SUCCESS) {
1964         ERR("Can't create external font reg key\n");
1965         goto end;
1966     }
1967
1968     /* enumerate the fonts and add external ones to the two keys */
1969
1970     LIST_FOR_EACH(family_elem_ptr, &font_list) {
1971         family = LIST_ENTRY(family_elem_ptr, Family, entry);
1972         len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
1973         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1974             face = LIST_ENTRY(face_elem_ptr, Face, entry);
1975             if(!face->external) continue;
1976             len = len_fam;
1977             if (!(face->ntmFlags & NTM_REGULAR))
1978                 len = len_fam + strlenW(face->StyleName) + 1;
1979             valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1980             strcpyW(valueW, family->FamilyName);
1981             if(len != len_fam) {
1982                 strcatW(valueW, spaceW);
1983                 strcatW(valueW, face->StyleName);
1984             }
1985             strcatW(valueW, TrueType);
1986
1987             file = wine_get_dos_file_name(face->file);
1988             if(file)
1989                 len = strlenW(file) + 1;
1990             else
1991             {
1992                 if((path = strrchr(face->file, '/')) == NULL)
1993                     path = face->file;
1994                 else
1995                     path++;
1996                 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
1997
1998                 file = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1999                 MultiByteToWideChar(CP_ACP, 0, path, -1, file, len);
2000             }
2001             RegSetValueExW(winnt_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2002             RegSetValueExW(win9x_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2003             RegSetValueExW(external_key, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
2004
2005             HeapFree(GetProcessHeap(), 0, file);
2006             HeapFree(GetProcessHeap(), 0, valueW);
2007         }
2008     }
2009  end:
2010     if(external_key) RegCloseKey(external_key);
2011     if(win9x_key) RegCloseKey(win9x_key);
2012     if(winnt_key) RegCloseKey(winnt_key);
2013     return;
2014 }
2015
2016 static void delete_external_font_keys(void)
2017 {
2018     HKEY winnt_key = 0, win9x_key = 0, external_key = 0;
2019     DWORD dlen, vlen, datalen, valuelen, i, type;
2020     LPWSTR valueW;
2021     LPVOID data;
2022
2023     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key,
2024                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &winnt_key, NULL) != ERROR_SUCCESS) {
2025         ERR("Can't create Windows font reg key\n");
2026         goto end;
2027     }
2028
2029     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key,
2030                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &win9x_key, NULL) != ERROR_SUCCESS) {
2031         ERR("Can't create Windows font reg key\n");
2032         goto end;
2033     }
2034
2035     if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &external_key) != ERROR_SUCCESS) {
2036         ERR("Can't create external font reg key\n");
2037         goto end;
2038     }
2039
2040     /* Delete all external fonts added last time */
2041
2042     RegQueryInfoKeyW(external_key, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2043                      &valuelen, &datalen, NULL, NULL);
2044     valuelen++; /* returned value doesn't include room for '\0' */
2045     valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2046     data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
2047
2048     dlen = datalen * sizeof(WCHAR);
2049     vlen = valuelen;
2050     i = 0;
2051     while(RegEnumValueW(external_key, i++, valueW, &vlen, NULL, &type, data,
2052                         &dlen) == ERROR_SUCCESS) {
2053
2054         RegDeleteValueW(winnt_key, valueW);
2055         RegDeleteValueW(win9x_key, valueW);
2056         /* reset dlen and vlen */
2057         dlen = datalen;
2058         vlen = valuelen;
2059     }
2060     HeapFree(GetProcessHeap(), 0, data);
2061     HeapFree(GetProcessHeap(), 0, valueW);
2062
2063     /* Delete the old external fonts key */
2064     RegCloseKey(external_key);
2065     RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
2066
2067  end:
2068     if(win9x_key) RegCloseKey(win9x_key);
2069     if(winnt_key) RegCloseKey(winnt_key);
2070 }
2071
2072 /*************************************************************
2073  *    WineEngAddFontResourceEx
2074  *
2075  */
2076 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2077 {
2078     INT ret = 0;
2079     if (ft_handle)  /* do it only if we have freetype up and running */
2080     {
2081         char *unixname;
2082
2083         if(flags)
2084             FIXME("Ignoring flags %x\n", flags);
2085
2086         if((unixname = wine_get_unix_file_name(file)))
2087         {
2088             EnterCriticalSection( &freetype_cs );
2089             ret = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2090             LeaveCriticalSection( &freetype_cs );
2091             HeapFree(GetProcessHeap(), 0, unixname);
2092         }
2093         if (!ret && !strchrW(file, '\\')) {
2094             /* Try in %WINDIR%/fonts, needed for Fotobuch Designer */
2095             ret = load_font_from_winfonts_dir(file);
2096             if (!ret) {
2097                 /* Try in datadir/fonts (or builddir/fonts),
2098                  * needed for Magic the Gathering Online
2099                  */
2100                 ret = load_font_from_data_dir(file);
2101             }
2102         }
2103     }
2104    return ret;
2105 }
2106
2107 /*************************************************************
2108  *    WineEngAddFontMemResourceEx
2109  *
2110  */
2111 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
2112 {
2113     if (ft_handle)  /* do it only if we have freetype up and running */
2114     {
2115         PVOID pFontCopy = HeapAlloc(GetProcessHeap(), 0, cbFont);
2116
2117         TRACE("Copying %d bytes of data from %p to %p\n", cbFont, pbFont, pFontCopy);
2118         memcpy(pFontCopy, pbFont, cbFont);
2119
2120         EnterCriticalSection( &freetype_cs );
2121         *pcFonts = AddFontToList(NULL, pFontCopy, cbFont, NULL, NULL, ADDFONT_FORCE_BITMAP);
2122         LeaveCriticalSection( &freetype_cs );
2123
2124         if (*pcFonts == 0)
2125         {
2126             TRACE("AddFontToList failed\n");
2127             HeapFree(GetProcessHeap(), 0, pFontCopy);
2128             return NULL;
2129         }
2130         /* FIXME: is the handle only for use in RemoveFontMemResourceEx or should it be a true handle?
2131          * For now return something unique but quite random
2132          */
2133         TRACE("Returning handle %lx\n", ((INT_PTR)pFontCopy)^0x87654321);
2134         return (HANDLE)(((INT_PTR)pFontCopy)^0x87654321);
2135     }
2136
2137     *pcFonts = 0;
2138     return 0;
2139 }
2140
2141 /*************************************************************
2142  *    WineEngRemoveFontResourceEx
2143  *
2144  */
2145 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
2146 {
2147     FIXME(":stub\n");
2148     return TRUE;
2149 }
2150
2151 static const struct nls_update_font_list
2152 {
2153     UINT ansi_cp, oem_cp;
2154     const char *oem, *fixed, *system;
2155     const char *courier, *serif, *small, *sserif;
2156     /* these are for font substitutes */
2157     const char *shelldlg, *tmsrmn;
2158     const char *fixed_0, *system_0, *courier_0, *serif_0, *small_0, *sserif_0,
2159                *helv_0, *tmsrmn_0;
2160     const struct subst
2161     {
2162         const char *from, *to;
2163     } arial_0, courier_new_0, times_new_roman_0;
2164 } nls_update_font_list[] =
2165 {
2166     /* Latin 1 (United States) */
2167     { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
2168       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2169       "Tahoma","Times New Roman",
2170       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2171       { 0 }, { 0 }, { 0 }
2172     },
2173     /* Latin 1 (Multilingual) */
2174     { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
2175       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2176       "Tahoma","Times New Roman",  /* FIXME unverified */
2177       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2178       { 0 }, { 0 }, { 0 }
2179     },
2180     /* Eastern Europe */
2181     { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
2182       "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
2183       "Tahoma","Times New Roman", /* FIXME unverified */
2184       "Fixedsys,238", "System,238",
2185       "Courier New,238", "MS Serif,238", "Small Fonts,238",
2186       "MS Sans Serif,238", "MS Sans Serif,238", "MS Serif,238",
2187       { "Arial CE,0", "Arial,238" },
2188       { "Courier New CE,0", "Courier New,238" },
2189       { "Times New Roman CE,0", "Times New Roman,238" }
2190     },
2191     /* Cyrillic */
2192     { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
2193       "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
2194       "Tahoma","Times New Roman", /* FIXME unverified */
2195       "Fixedsys,204", "System,204",
2196       "Courier New,204", "MS Serif,204", "Small Fonts,204",
2197       "MS Sans Serif,204", "MS Sans Serif,204", "MS Serif,204",
2198       { "Arial Cyr,0", "Arial,204" },
2199       { "Courier New Cyr,0", "Courier New,204" },
2200       { "Times New Roman Cyr,0", "Times New Roman,204" }
2201     },
2202     /* Greek */
2203     { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
2204       "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
2205       "Tahoma","Times New Roman", /* FIXME unverified */
2206       "Fixedsys,161", "System,161",
2207       "Courier New,161", "MS Serif,161", "Small Fonts,161",
2208       "MS Sans Serif,161", "MS Sans Serif,161", "MS Serif,161",
2209       { "Arial Greek,0", "Arial,161" },
2210       { "Courier New Greek,0", "Courier New,161" },
2211       { "Times New Roman Greek,0", "Times New Roman,161" }
2212     },
2213     /* Turkish */
2214     { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
2215       "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
2216       "Tahoma","Times New Roman", /* FIXME unverified */
2217       "Fixedsys,162", "System,162",
2218       "Courier New,162", "MS Serif,162", "Small Fonts,162",
2219       "MS Sans Serif,162", "MS Sans Serif,162", "MS Serif,162",
2220       { "Arial Tur,0", "Arial,162" },
2221       { "Courier New Tur,0", "Courier New,162" },
2222       { "Times New Roman Tur,0", "Times New Roman,162" }
2223     },
2224     /* Hebrew */
2225     { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
2226       "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
2227       "Tahoma","Times New Roman", /* FIXME unverified */
2228       "Fixedsys,177", "System,177",
2229       "Courier New,177", "MS Serif,177", "Small Fonts,177",
2230       "MS Sans Serif,177", "MS Sans Serif,177", "MS Serif,177",
2231       { 0 }, { 0 }, { 0 }
2232     },
2233     /* Arabic */
2234     { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
2235       "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
2236       "Tahoma","Times New Roman", /* FIXME unverified */
2237       "Fixedsys,178", "System,178",
2238       "Courier New,178", "MS Serif,178", "Small Fonts,178",
2239       "MS Sans Serif,178", "MS Sans Serif,178", "MS Serif,178",
2240       { 0 }, { 0 }, { 0 }
2241     },
2242     /* Baltic */
2243     { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
2244       "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
2245       "Tahoma","Times New Roman", /* FIXME unverified */
2246       "Fixedsys,186", "System,186",
2247       "Courier New,186", "MS Serif,186", "Small Fonts,186",
2248       "MS Sans Serif,186", "MS Sans Serif,186", "MS Serif,186",
2249       { "Arial Baltic,0", "Arial,186" },
2250       { "Courier New Baltic,0", "Courier New,186" },
2251       { "Times New Roman Baltic,0", "Times New Roman,186" }
2252     },
2253     /* Vietnamese */
2254     { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
2255       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2256       "Tahoma","Times New Roman", /* FIXME unverified */
2257       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2258       { 0 }, { 0 }, { 0 }
2259     },
2260     /* Thai */
2261     { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
2262       "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
2263       "Tahoma","Times New Roman", /* FIXME unverified */
2264       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2265       { 0 }, { 0 }, { 0 }
2266     },
2267     /* Japanese */
2268     { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
2269       "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
2270       "MS UI Gothic","MS Serif",
2271       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2272       { 0 }, { 0 }, { 0 }
2273     },
2274     /* Chinese Simplified */
2275     { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
2276       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2277       "Tahoma", "Times New Roman", /* FIXME unverified */
2278       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2279       { 0 }, { 0 }, { 0 }
2280     },
2281     /* Korean */
2282     { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
2283       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2284       "Gulim",  "Batang",
2285       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2286       { 0 }, { 0 }, { 0 }
2287     },
2288     /* Chinese Traditional */
2289     { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
2290       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
2291       "PMingLiU",  "MingLiU",
2292       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2293       { 0 }, { 0 }, { 0 }
2294     }
2295 };
2296
2297 static inline BOOL is_dbcs_ansi_cp(UINT ansi_cp)
2298 {
2299     return ( ansi_cp == 932       /* CP932 for Japanese */
2300             || ansi_cp == 936     /* CP936 for Chinese Simplified */
2301             || ansi_cp == 949     /* CP949 for Korean */
2302             || ansi_cp == 950 );  /* CP950 for Chinese Traditional */
2303 }
2304
2305 static inline HKEY create_fonts_NT_registry_key(void)
2306 {
2307     HKEY hkey = 0;
2308
2309     RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
2310                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2311     return hkey;
2312 }
2313
2314 static inline HKEY create_fonts_9x_registry_key(void)
2315 {
2316     HKEY hkey = 0;
2317
2318     RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
2319                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2320     return hkey;
2321 }
2322
2323 static inline HKEY create_config_fonts_registry_key(void)
2324 {
2325     HKEY hkey = 0;
2326
2327     RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
2328                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
2329     return hkey;
2330 }
2331
2332 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl)
2333 {
2334     RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
2335     RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
2336     RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)fl->sserif, strlen(fl->sserif)+1);
2337     RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
2338 }
2339
2340 static void set_value_key(HKEY hkey, const char *name, const char *value)
2341 {
2342     if (value)
2343         RegSetValueExA(hkey, name, 0, REG_SZ, (const BYTE *)value, strlen(value) + 1);
2344     else if (name)
2345         RegDeleteValueA(hkey, name);
2346 }
2347
2348 static void update_font_info(void)
2349 {
2350     char buf[40], cpbuf[40];
2351     DWORD len, type;
2352     HKEY hkey = 0;
2353     UINT i, ansi_cp = 0, oem_cp = 0;
2354     BOOL done = FALSE;
2355
2356     if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL) != ERROR_SUCCESS)
2357         return;
2358
2359     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
2360                    (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
2361     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
2362                    (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
2363     sprintf( cpbuf, "%u,%u", ansi_cp, oem_cp );
2364
2365     /* Setup Default_Fallback usage for DBCS ANSI codepages */
2366     if (is_dbcs_ansi_cp(ansi_cp))
2367         use_default_fallback = TRUE;
2368
2369     len = sizeof(buf);
2370     if (RegQueryValueExA(hkey, "Codepages", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
2371     {
2372         if (!strcmp( buf, cpbuf ))  /* already set correctly */
2373         {
2374             RegCloseKey(hkey);
2375             return;
2376         }
2377         TRACE("updating registry, codepages changed %s -> %u,%u\n", buf, ansi_cp, oem_cp);
2378     }
2379     else TRACE("updating registry, codepages changed none -> %u,%u\n", ansi_cp, oem_cp);
2380
2381     RegSetValueExA(hkey, "Codepages", 0, REG_SZ, (const BYTE *)cpbuf, strlen(cpbuf)+1);
2382     RegCloseKey(hkey);
2383
2384     for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
2385     {
2386         HKEY hkey;
2387
2388         if (nls_update_font_list[i].ansi_cp == ansi_cp &&
2389             nls_update_font_list[i].oem_cp == oem_cp)
2390         {
2391             hkey = create_config_fonts_registry_key();
2392             RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
2393             RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
2394             RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
2395             RegCloseKey(hkey);
2396
2397             hkey = create_fonts_NT_registry_key();
2398             add_font_list(hkey, &nls_update_font_list[i]);
2399             RegCloseKey(hkey);
2400
2401             hkey = create_fonts_9x_registry_key();
2402             add_font_list(hkey, &nls_update_font_list[i]);
2403             RegCloseKey(hkey);
2404
2405             if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
2406             {
2407                 RegSetValueExA(hkey, "MS Shell Dlg", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].shelldlg,
2408                                strlen(nls_update_font_list[i].shelldlg)+1);
2409                 RegSetValueExA(hkey, "Tms Rmn", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].tmsrmn,
2410                                strlen(nls_update_font_list[i].tmsrmn)+1);
2411
2412                 set_value_key(hkey, "Fixedsys,0", nls_update_font_list[i].fixed_0);
2413                 set_value_key(hkey, "System,0", nls_update_font_list[i].system_0);
2414                 set_value_key(hkey, "Courier,0", nls_update_font_list[i].courier_0);
2415                 set_value_key(hkey, "MS Serif,0", nls_update_font_list[i].serif_0);
2416                 set_value_key(hkey, "Small Fonts,0", nls_update_font_list[i].small_0);
2417                 set_value_key(hkey, "MS Sans Serif,0", nls_update_font_list[i].sserif_0);
2418                 set_value_key(hkey, "Helv,0", nls_update_font_list[i].helv_0);
2419                 set_value_key(hkey, "Tms Rmn,0", nls_update_font_list[i].tmsrmn_0);
2420
2421                 set_value_key(hkey, nls_update_font_list[i].arial_0.from, nls_update_font_list[i].arial_0.to);
2422                 set_value_key(hkey, nls_update_font_list[i].courier_new_0.from, nls_update_font_list[i].courier_new_0.to);
2423                 set_value_key(hkey, nls_update_font_list[i].times_new_roman_0.from, nls_update_font_list[i].times_new_roman_0.to);
2424
2425                 RegCloseKey(hkey);
2426             }
2427             done = TRUE;
2428         }
2429         else
2430         {
2431             /* Delete the FontSubstitutes from other locales */
2432             if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes", &hkey ))
2433             {
2434                 set_value_key(hkey, nls_update_font_list[i].arial_0.from, NULL);
2435                 set_value_key(hkey, nls_update_font_list[i].courier_new_0.from, NULL);
2436                 set_value_key(hkey, nls_update_font_list[i].times_new_roman_0.from, NULL);
2437                 RegCloseKey(hkey);
2438             }
2439         }
2440     }
2441     if (!done)
2442         FIXME("there is no font defaults for codepages %u,%u\n", ansi_cp, oem_cp);
2443 }
2444
2445
2446 static BOOL init_freetype(void)
2447 {
2448     ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
2449     if(!ft_handle) {
2450         WINE_MESSAGE(
2451       "Wine cannot find the FreeType font library.  To enable Wine to\n"
2452       "use TrueType fonts please install a version of FreeType greater than\n"
2453       "or equal to 2.0.5.\n"
2454       "http://www.freetype.org\n");
2455         return FALSE;
2456     }
2457
2458 #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;}
2459
2460     LOAD_FUNCPTR(FT_Vector_Unit)
2461     LOAD_FUNCPTR(FT_Done_Face)
2462     LOAD_FUNCPTR(FT_Get_Char_Index)
2463     LOAD_FUNCPTR(FT_Get_Module)
2464     LOAD_FUNCPTR(FT_Get_Sfnt_Name)
2465     LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
2466     LOAD_FUNCPTR(FT_Get_Sfnt_Table)
2467     LOAD_FUNCPTR(FT_Init_FreeType)
2468     LOAD_FUNCPTR(FT_Load_Glyph)
2469     LOAD_FUNCPTR(FT_Matrix_Multiply)
2470 #ifndef FT_MULFIX_INLINED
2471     LOAD_FUNCPTR(FT_MulFix)
2472 #endif
2473     LOAD_FUNCPTR(FT_New_Face)
2474     LOAD_FUNCPTR(FT_New_Memory_Face)
2475     LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
2476     LOAD_FUNCPTR(FT_Outline_Transform)
2477     LOAD_FUNCPTR(FT_Outline_Translate)
2478     LOAD_FUNCPTR(FT_Select_Charmap)
2479     LOAD_FUNCPTR(FT_Set_Charmap)
2480     LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
2481     LOAD_FUNCPTR(FT_Vector_Transform)
2482
2483 #undef LOAD_FUNCPTR
2484     /* Don't warn if these ones are missing */
2485     pFT_Library_Version = wine_dlsym(ft_handle, "FT_Library_Version", NULL, 0);
2486     pFT_Load_Sfnt_Table = wine_dlsym(ft_handle, "FT_Load_Sfnt_Table", NULL, 0);
2487     pFT_Get_First_Char = wine_dlsym(ft_handle, "FT_Get_First_Char", NULL, 0);
2488     pFT_Get_Next_Char = wine_dlsym(ft_handle, "FT_Get_Next_Char", NULL, 0);
2489     pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
2490 #ifdef HAVE_FREETYPE_FTWINFNT_H
2491     pFT_Get_WinFNT_Header = wine_dlsym(ft_handle, "FT_Get_WinFNT_Header", NULL, 0);
2492 #endif
2493       if(!wine_dlsym(ft_handle, "FT_Get_Postscript_Name", NULL, 0) &&
2494          !wine_dlsym(ft_handle, "FT_Sqrt64", NULL, 0)) {
2495         /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
2496            <= 2.0.3 has FT_Sqrt64 */
2497           goto sym_not_found;
2498       }
2499
2500     if(pFT_Init_FreeType(&library) != 0) {
2501         ERR("Can't init FreeType library\n");
2502         wine_dlclose(ft_handle, NULL, 0);
2503         ft_handle = NULL;
2504         return FALSE;
2505     }
2506     FT_Version.major = FT_Version.minor = FT_Version.patch = -1;
2507     if (pFT_Library_Version)
2508         pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
2509
2510     if (FT_Version.major<=0)
2511     {
2512         FT_Version.major=2;
2513         FT_Version.minor=0;
2514         FT_Version.patch=5;
2515     }
2516     TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
2517     FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
2518                        ((FT_Version.minor <<  8) & 0x00ff00) |
2519                        ((FT_Version.patch      ) & 0x0000ff);
2520
2521     return TRUE;
2522
2523 sym_not_found:
2524     WINE_MESSAGE(
2525       "Wine cannot find certain functions that it needs inside the FreeType\n"
2526       "font library.  To enable Wine to use TrueType fonts please upgrade\n"
2527       "FreeType to at least version 2.0.5.\n"
2528       "http://www.freetype.org\n");
2529     wine_dlclose(ft_handle, NULL, 0);
2530     ft_handle = NULL;
2531     return FALSE;
2532 }
2533
2534 /*************************************************************
2535  *    WineEngInit
2536  *
2537  * Initialize FreeType library and create a list of available faces
2538  */
2539 BOOL WineEngInit(void)
2540 {
2541     static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
2542     static const WCHAR pathW[] = {'P','a','t','h',0};
2543     HKEY hkey;
2544     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
2545     LPVOID data;
2546     WCHAR windowsdir[MAX_PATH];
2547     char *unixname;
2548     HANDLE font_mutex;
2549     const char *data_dir;
2550
2551     TRACE("\n");
2552
2553     /* update locale dependent font info in registry */
2554     update_font_info();
2555
2556     if(!init_freetype()) return FALSE;
2557
2558     if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL) {
2559         ERR("Failed to create font mutex\n");
2560         return FALSE;
2561     }
2562     WaitForSingleObject(font_mutex, INFINITE);
2563
2564     delete_external_font_keys();
2565
2566     /* load the system bitmap fonts */
2567     load_system_fonts();
2568
2569     /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
2570     GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
2571     strcatW(windowsdir, fontsW);
2572     if((unixname = wine_get_unix_file_name(windowsdir)))
2573     {
2574         ReadFontDir(unixname, FALSE);
2575         HeapFree(GetProcessHeap(), 0, unixname);
2576     }
2577
2578     /* load the system truetype fonts */
2579     data_dir = wine_get_data_dir();
2580     if (!data_dir) data_dir = wine_get_build_dir();
2581     if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/")))) {
2582         strcpy(unixname, data_dir);
2583         strcat(unixname, "/fonts/");
2584         ReadFontDir(unixname, TRUE);
2585         HeapFree(GetProcessHeap(), 0, unixname);
2586     }
2587
2588     /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
2589        for any fonts not installed in %WINDOWSDIR%\Fonts.  They will have their
2590        full path as the entry.  Also look for any .fon fonts, since ReadFontDir
2591        will skip these. */
2592     if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
2593                    is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
2594                    &hkey) == ERROR_SUCCESS) {
2595         LPWSTR valueW;
2596         RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2597                          &valuelen, &datalen, NULL, NULL);
2598
2599         valuelen++; /* returned value doesn't include room for '\0' */
2600         valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
2601         data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
2602         if (valueW && data)
2603         {
2604             dlen = datalen * sizeof(WCHAR);
2605             vlen = valuelen;
2606             while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, data,
2607                                 &dlen) == ERROR_SUCCESS) {
2608                 if(((LPWSTR)data)[0] && ((LPWSTR)data)[1] == ':')
2609                 {
2610                     if((unixname = wine_get_unix_file_name((LPWSTR)data)))
2611                     {
2612                         AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2613                         HeapFree(GetProcessHeap(), 0, unixname);
2614                     }
2615                 }
2616                 else if(dlen / 2 >= 6 && !strcmpiW(((LPWSTR)data) + dlen / 2 - 5, dot_fonW))
2617                 {
2618                     WCHAR pathW[MAX_PATH];
2619                     static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
2620                     BOOL added = FALSE;
2621
2622                     sprintfW(pathW, fmtW, windowsdir, data);
2623                     if((unixname = wine_get_unix_file_name(pathW)))
2624                     {
2625                         added = AddFontFileToList(unixname, NULL, NULL, ADDFONT_FORCE_BITMAP);
2626                         HeapFree(GetProcessHeap(), 0, unixname);
2627                     }
2628                     if (!added)
2629                         load_font_from_data_dir(data);
2630                 }
2631                 /* reset dlen and vlen */
2632                 dlen = datalen;
2633                 vlen = valuelen;
2634             }
2635         }
2636         HeapFree(GetProcessHeap(), 0, data);
2637         HeapFree(GetProcessHeap(), 0, valueW);
2638         RegCloseKey(hkey);
2639     }
2640
2641     load_fontconfig_fonts();
2642
2643     /* then look in any directories that we've specified in the config file */
2644     /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
2645     if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
2646     {
2647         DWORD len;
2648         LPWSTR valueW;
2649         LPSTR valueA, ptr;
2650
2651         if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
2652         {
2653             len += sizeof(WCHAR);
2654             valueW = HeapAlloc( GetProcessHeap(), 0, len );
2655             if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
2656             {
2657                 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
2658                 valueA = HeapAlloc( GetProcessHeap(), 0, len );
2659                 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
2660                 TRACE( "got font path %s\n", debugstr_a(valueA) );
2661                 ptr = valueA;
2662                 while (ptr)
2663                 {
2664                     LPSTR next = strchr( ptr, ':' );
2665                     if (next) *next++ = 0;
2666                     ReadFontDir( ptr, TRUE );
2667                     ptr = next;
2668                 }
2669                 HeapFree( GetProcessHeap(), 0, valueA );
2670             }
2671             HeapFree( GetProcessHeap(), 0, valueW );
2672         }
2673         RegCloseKey(hkey);
2674     }
2675
2676     DumpFontList();
2677     LoadSubstList();
2678     DumpSubstList();
2679     LoadReplaceList();
2680     update_reg_entries();
2681
2682     init_system_links();
2683
2684     ReleaseMutex(font_mutex);
2685     return TRUE;
2686 }
2687
2688
2689 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
2690 {
2691     TT_OS2 *pOS2;
2692     TT_HoriHeader *pHori;
2693
2694     LONG ppem;
2695
2696     pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
2697     pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
2698
2699     if(height == 0) height = 16;
2700
2701     /* Calc. height of EM square:
2702      *
2703      * For +ve lfHeight we have
2704      * lfHeight = (winAscent + winDescent) * ppem / units_per_em
2705      * Re-arranging gives:
2706      * ppem = units_per_em * lfheight / (winAscent + winDescent)
2707      *
2708      * For -ve lfHeight we have
2709      * |lfHeight| = ppem
2710      * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
2711      * with il = winAscent + winDescent - units_per_em]
2712      *
2713      */
2714
2715     if(height > 0) {
2716         if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
2717             ppem = MulDiv(ft_face->units_per_EM, height,
2718                           pHori->Ascender - pHori->Descender);
2719         else
2720             ppem = MulDiv(ft_face->units_per_EM, height,
2721                           pOS2->usWinAscent + pOS2->usWinDescent);
2722     }
2723     else
2724         ppem = -height;
2725
2726     return ppem;
2727 }
2728
2729 static struct font_mapping *map_font_file( const char *name )
2730 {
2731     struct font_mapping *mapping;
2732     struct stat st;
2733     int fd;
2734
2735     if ((fd = open( name, O_RDONLY )) == -1) return NULL;
2736     if (fstat( fd, &st ) == -1) goto error;
2737
2738     LIST_FOR_EACH_ENTRY( mapping, &mappings_list, struct font_mapping, entry )
2739     {
2740         if (mapping->dev == st.st_dev && mapping->ino == st.st_ino)
2741         {
2742             mapping->refcount++;
2743             close( fd );
2744             return mapping;
2745         }
2746     }
2747     if (!(mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(*mapping) )))
2748         goto error;
2749
2750     mapping->data = mmap( NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );
2751     close( fd );
2752
2753     if (mapping->data == MAP_FAILED)
2754     {
2755         HeapFree( GetProcessHeap(), 0, mapping );
2756         return NULL;
2757     }
2758     mapping->refcount = 1;
2759     mapping->dev = st.st_dev;
2760     mapping->ino = st.st_ino;
2761     mapping->size = st.st_size;
2762     list_add_tail( &mappings_list, &mapping->entry );
2763     return mapping;
2764
2765 error:
2766     close( fd );
2767     return NULL;
2768 }
2769
2770 static void unmap_font_file( struct font_mapping *mapping )
2771 {
2772     if (!--mapping->refcount)
2773     {
2774         list_remove( &mapping->entry );
2775         munmap( mapping->data, mapping->size );
2776         HeapFree( GetProcessHeap(), 0, mapping );
2777     }
2778 }
2779
2780 static LONG load_VDMX(GdiFont*, LONG);
2781
2782 static FT_Face OpenFontFace(GdiFont *font, Face *face, LONG width, LONG height)
2783 {
2784     FT_Error err;
2785     FT_Face ft_face;
2786     void *data_ptr;
2787     DWORD data_size;
2788
2789     TRACE("%s/%p, %ld, %d x %d\n", debugstr_a(face->file), face->font_data_ptr, face->face_index, width, height);
2790
2791     if (face->file)
2792     {
2793         if (!(font->mapping = map_font_file( face->file )))
2794         {
2795             WARN("failed to map %s\n", debugstr_a(face->file));
2796             return 0;
2797         }
2798         data_ptr = font->mapping->data;
2799         data_size = font->mapping->size;
2800     }
2801     else
2802     {
2803         data_ptr = face->font_data_ptr;
2804         data_size = face->font_data_size;
2805     }
2806
2807     err = pFT_New_Memory_Face(library, data_ptr, data_size, face->face_index, &ft_face);
2808     if(err) {
2809         ERR("FT_New_Face rets %d\n", err);
2810         return 0;
2811     }
2812
2813     /* set it here, as load_VDMX needs it */
2814     font->ft_face = ft_face;
2815
2816     if(FT_IS_SCALABLE(ft_face)) {
2817         /* load the VDMX table if we have one */
2818         font->ppem = load_VDMX(font, height);
2819         if(font->ppem == 0)
2820             font->ppem = calc_ppem_for_height(ft_face, height);
2821         TRACE("height %d => ppem %d\n", height, font->ppem);
2822
2823         if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
2824             WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", 0, font->ppem, err);
2825     } else {
2826         font->ppem = height;
2827         if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
2828             WARN("FT_Set_Pixel_Sizes %d, %d rets %x\n", width, height, err);
2829     }
2830     return ft_face;
2831 }
2832
2833
2834 static int get_nearest_charset(Face *face, int *cp)
2835 {
2836   /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
2837      a single face with the requested charset.  The idea is to check if
2838      the selected font supports the current ANSI codepage, if it does
2839      return the corresponding charset, else return the first charset */
2840
2841     CHARSETINFO csi;
2842     int acp = GetACP(), i;
2843     DWORD fs0;
2844
2845     *cp = acp;
2846     if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
2847         if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
2848             return csi.ciCharset;
2849
2850     for(i = 0; i < 32; i++) {
2851         fs0 = 1L << i;
2852         if(face->fs.fsCsb[0] & fs0) {
2853             if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
2854                 *cp = csi.ciACP;
2855                 return csi.ciCharset;
2856             }
2857             else
2858                 FIXME("TCI failing on %x\n", fs0);
2859         }
2860     }
2861
2862     FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08x file = %s\n",
2863           face->fs.fsCsb[0], face->file);
2864     *cp = acp;
2865     return DEFAULT_CHARSET;
2866 }
2867
2868 static GdiFont *alloc_font(void)
2869 {
2870     GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
2871     ret->gmsize = 1;
2872     ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM*));
2873     ret->gm[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
2874     ret->potm = NULL;
2875     ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
2876     ret->total_kern_pairs = (DWORD)-1;
2877     ret->kern_pairs = NULL;
2878     list_init(&ret->hfontlist);
2879     list_init(&ret->child_fonts);
2880     return ret;
2881 }
2882
2883 static void free_font(GdiFont *font)
2884 {
2885     struct list *cursor, *cursor2;
2886     DWORD i;
2887
2888     LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
2889     {
2890         CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
2891         struct list *first_hfont;
2892         HFONTLIST *hfontlist;
2893         list_remove(cursor);
2894         if(child->font)
2895         {
2896             first_hfont = list_head(&child->font->hfontlist);
2897             hfontlist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2898             DeleteObject(hfontlist->hfont);
2899             HeapFree(GetProcessHeap(), 0, hfontlist);
2900             free_font(child->font);
2901         }
2902         HeapFree(GetProcessHeap(), 0, child);
2903     }
2904
2905     if (font->ft_face) pFT_Done_Face(font->ft_face);
2906     if (font->mapping) unmap_font_file( font->mapping );
2907     HeapFree(GetProcessHeap(), 0, font->kern_pairs);
2908     HeapFree(GetProcessHeap(), 0, font->potm);
2909     HeapFree(GetProcessHeap(), 0, font->name);
2910     for (i = 0; i < font->gmsize; i++)
2911         HeapFree(GetProcessHeap(),0,font->gm[i]);
2912     HeapFree(GetProcessHeap(), 0, font->gm);
2913     HeapFree(GetProcessHeap(), 0, font->GSUB_Table);
2914     HeapFree(GetProcessHeap(), 0, font);
2915 }
2916
2917
2918 /*************************************************************
2919  * load_VDMX
2920  *
2921  * load the vdmx entry for the specified height
2922  */
2923
2924 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
2925           ( ( (FT_ULong)_x4 << 24 ) |     \
2926             ( (FT_ULong)_x3 << 16 ) |     \
2927             ( (FT_ULong)_x2 <<  8 ) |     \
2928               (FT_ULong)_x1         )
2929
2930 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
2931
2932 typedef struct {
2933     BYTE bCharSet;
2934     BYTE xRatio;
2935     BYTE yStartRatio;
2936     BYTE yEndRatio;
2937 } Ratios;
2938
2939 typedef struct {
2940     WORD recs;
2941     BYTE startsz;
2942     BYTE endsz;
2943 } VDMX_group;
2944
2945 static LONG load_VDMX(GdiFont *font, LONG height)
2946 {
2947     WORD hdr[3], tmp;
2948     VDMX_group group;
2949     BYTE devXRatio, devYRatio;
2950     USHORT numRecs, numRatios;
2951     DWORD result, offset = -1;
2952     LONG ppem = 0;
2953     int i;
2954
2955     result = WineEngGetFontData(font, MS_VDMX_TAG, 0, hdr, 6);
2956
2957     if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
2958         return ppem;
2959
2960     /* FIXME: need the real device aspect ratio */
2961     devXRatio = 1;
2962     devYRatio = 1;
2963
2964     numRecs = GET_BE_WORD(hdr[1]);
2965     numRatios = GET_BE_WORD(hdr[2]);
2966
2967     TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
2968     for(i = 0; i < numRatios; i++) {
2969         Ratios ratio;
2970
2971         offset = (3 * 2) + (i * sizeof(Ratios));
2972         WineEngGetFontData(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
2973         offset = -1;
2974
2975         TRACE("Ratios[%d] %d  %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
2976
2977         if((ratio.xRatio == 0 &&
2978             ratio.yStartRatio == 0 &&
2979             ratio.yEndRatio == 0) ||
2980            (devXRatio == ratio.xRatio &&
2981             devYRatio >= ratio.yStartRatio &&
2982             devYRatio <= ratio.yEndRatio))
2983             {
2984                 offset = (3 * 2) + (numRatios * 4) + (i * 2);
2985                 WineEngGetFontData(font, MS_VDMX_TAG, offset, &tmp, 2);
2986                 offset = GET_BE_WORD(tmp);
2987                 break;
2988             }
2989     }
2990
2991     if(offset == -1) {
2992         FIXME("No suitable ratio found\n");
2993         return ppem;
2994     }
2995
2996     if(WineEngGetFontData(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
2997         USHORT recs;
2998         BYTE startsz, endsz;
2999         WORD *vTable;
3000
3001         recs = GET_BE_WORD(group.recs);
3002         startsz = group.startsz;
3003         endsz = group.endsz;
3004
3005         TRACE("recs=%d  startsz=%d  endsz=%d\n", recs, startsz, endsz);
3006
3007         vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
3008         result = WineEngGetFontData(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
3009         if(result == GDI_ERROR) {
3010             FIXME("Failed to retrieve vTable\n");
3011             goto end;
3012         }
3013
3014         if(height > 0) {
3015             for(i = 0; i < recs; i++) {
3016                 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
3017                 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
3018                 ppem = GET_BE_WORD(vTable[i * 3]);
3019
3020                 if(yMax + -yMin == height) {
3021                     font->yMax = yMax;
3022                     font->yMin = yMin;
3023                     TRACE("ppem %d found; height=%d  yMax=%d  yMin=%d\n", ppem, height, font->yMax, font->yMin);
3024                     break;
3025                 }
3026                 if(yMax + -yMin > height) {
3027                     if(--i < 0) {
3028                         ppem = 0;
3029                         goto end; /* failed */
3030                     }
3031                     font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
3032                     font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
3033                     ppem = GET_BE_WORD(vTable[i * 3]);
3034                     TRACE("ppem %d found; height=%d  yMax=%d  yMin=%d\n", ppem, height, font->yMax, font->yMin);
3035                     break;
3036                 }
3037             }
3038             if(!font->yMax) {
3039                 ppem = 0;
3040                 TRACE("ppem not found for height %d\n", height);
3041             }
3042         } else {
3043             ppem = -height;
3044             if(ppem < startsz || ppem > endsz)
3045                 goto end;
3046
3047             for(i = 0; i < recs; i++) {
3048                 USHORT yPelHeight;
3049                 yPelHeight = GET_BE_WORD(vTable[i * 3]);
3050
3051                 if(yPelHeight > ppem)
3052                     break; /* failed */
3053
3054                 if(yPelHeight == ppem) {
3055                     font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
3056                     font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
3057                     TRACE("ppem %d found; yMax=%d  yMin=%d\n", ppem, font->yMax, font->yMin);
3058                     break;
3059                 }
3060             }
3061         }
3062         end:
3063         HeapFree(GetProcessHeap(), 0, vTable);
3064     }
3065
3066     return ppem;
3067 }
3068
3069 static BOOL fontcmp(const GdiFont *font, FONT_DESC *fd)
3070 {
3071     if(font->font_desc.hash != fd->hash) return TRUE;
3072     if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
3073     if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
3074     if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
3075     return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
3076 }
3077
3078 static void calc_hash(FONT_DESC *pfd)
3079 {
3080     DWORD hash = 0, *ptr, two_chars;
3081     WORD *pwc;
3082     unsigned int i;
3083
3084     for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
3085         hash ^= *ptr;
3086     for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
3087         hash ^= *ptr;
3088     for(i = 0, ptr = (DWORD*)pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
3089         two_chars = *ptr;
3090         pwc = (WCHAR *)&two_chars;
3091         if(!*pwc) break;
3092         *pwc = toupperW(*pwc);
3093         pwc++;
3094         *pwc = toupperW(*pwc);
3095         hash ^= two_chars;
3096         if(!*pwc) break;
3097     }
3098     hash ^= !pfd->can_use_bitmap;
3099     pfd->hash = hash;
3100     return;
3101 }
3102
3103 static GdiFont *find_in_cache(HFONT hfont, const LOGFONTW *plf, const FMAT2 *pmat, BOOL can_use_bitmap)
3104 {
3105     GdiFont *ret;
3106     FONT_DESC fd;
3107     HFONTLIST *hflist;
3108     struct list *font_elem_ptr, *hfontlist_elem_ptr;
3109
3110     fd.lf = *plf;
3111     fd.matrix = *pmat;
3112     fd.can_use_bitmap = can_use_bitmap;
3113     calc_hash(&fd);
3114
3115     /* try the in-use list */
3116     LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
3117         ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3118         if(!fontcmp(ret, &fd)) {
3119             if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
3120             LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
3121                 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
3122                 if(hflist->hfont == hfont)
3123                     return ret;
3124             }
3125             hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
3126             hflist->hfont = hfont;
3127             list_add_head(&ret->hfontlist, &hflist->entry);
3128             return ret;
3129         }
3130     }
3131
3132     /* then the unused list */
3133     font_elem_ptr = list_head(&unused_gdi_font_list);
3134     while(font_elem_ptr) {
3135         ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3136         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3137         if(!fontcmp(ret, &fd)) {
3138             if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
3139             assert(list_empty(&ret->hfontlist));
3140             TRACE("Found %p in unused list\n", ret);
3141             list_remove(&ret->entry);
3142             list_add_head(&gdi_font_list, &ret->entry);
3143             hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
3144             hflist->hfont = hfont;
3145             list_add_head(&ret->hfontlist, &hflist->entry);
3146             return ret;
3147         }
3148     }
3149     return NULL;
3150 }
3151
3152 static void add_to_cache(GdiFont *font)
3153 {
3154     static DWORD cache_num = 1;
3155
3156     font->cache_num = cache_num++;
3157     list_add_head(&gdi_font_list, &font->entry);
3158 }
3159
3160 /*************************************************************
3161  * create_child_font_list
3162  */
3163 static BOOL create_child_font_list(GdiFont *font)
3164 {
3165     BOOL ret = FALSE;
3166     SYSTEM_LINKS *font_link;
3167     CHILD_FONT *font_link_entry, *new_child;
3168
3169     LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
3170     {
3171         if(!strcmpW(font_link->font_name, font->name))
3172         {
3173             TRACE("found entry in system list\n");
3174             LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
3175             {
3176                 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
3177                 new_child->face = font_link_entry->face;
3178                 new_child->font = NULL;
3179                 list_add_tail(&font->child_fonts, &new_child->entry);
3180                 TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
3181             }
3182             ret = TRUE;
3183             break;
3184         }
3185     }
3186     /*
3187      * if not SYMBOL or OEM then we also get all the fonts for Microsoft
3188      * Sans Serif.  This is how asian windows get default fallbacks for fonts
3189      */
3190     if (use_default_fallback && font->charset != SYMBOL_CHARSET &&
3191         font->charset != OEM_CHARSET &&
3192         strcmpW(font->name,szDefaultFallbackLink) != 0)
3193         LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
3194         {
3195             if(!strcmpW(font_link->font_name,szDefaultFallbackLink))
3196             {
3197                 TRACE("found entry in default fallback list\n");
3198                 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
3199                 {
3200                     new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
3201                     new_child->face = font_link_entry->face;
3202                     new_child->font = NULL;
3203                     list_add_tail(&font->child_fonts, &new_child->entry);
3204                     TRACE("font %s %ld\n", debugstr_a(new_child->face->file), new_child->face->face_index);
3205                 }
3206                 ret = TRUE;
3207                 break;
3208             }
3209         }
3210
3211     return ret;
3212 }
3213
3214 static BOOL select_charmap(FT_Face ft_face, FT_Encoding encoding)
3215 {
3216     FT_Error ft_err = FT_Err_Invalid_CharMap_Handle;
3217
3218     if (pFT_Set_Charmap)
3219     {
3220         FT_Int i;
3221         FT_CharMap cmap0, cmap1, cmap2, cmap3, cmap_def;
3222
3223         cmap0 = cmap1 = cmap2 = cmap3 = cmap_def = NULL;
3224
3225         for (i = 0; i < ft_face->num_charmaps; i++)
3226         {
3227             if (ft_face->charmaps[i]->encoding == encoding)
3228             {
3229                 TRACE("found cmap with platform_id %u, encoding_id %u\n",
3230                        ft_face->charmaps[i]->platform_id, ft_face->charmaps[i]->encoding_id);
3231
3232                 switch (ft_face->charmaps[i]->platform_id)
3233                 {
3234                     default:
3235                         cmap_def = ft_face->charmaps[i];
3236                         break;
3237                     case 0: /* Apple Unicode */
3238                         cmap0 = ft_face->charmaps[i];
3239                         break;
3240                     case 1: /* Macintosh */
3241                         cmap1 = ft_face->charmaps[i];
3242                         break;
3243                     case 2: /* ISO */
3244                         cmap2 = ft_face->charmaps[i];
3245                         break;
3246                     case 3: /* Microsoft */
3247                         cmap3 = ft_face->charmaps[i];
3248                         break;
3249                 }
3250             }
3251
3252             if (cmap3) /* prefer Microsoft cmap table */
3253                 ft_err = pFT_Set_Charmap(ft_face, cmap3);
3254             else if (cmap1)
3255                 ft_err = pFT_Set_Charmap(ft_face, cmap1);
3256             else if (cmap2)
3257                 ft_err = pFT_Set_Charmap(ft_face, cmap2);
3258             else if (cmap0)
3259                 ft_err = pFT_Set_Charmap(ft_face, cmap0);
3260             else if (cmap_def)
3261                 ft_err = pFT_Set_Charmap(ft_face, cmap_def);
3262         }
3263         return ft_err == FT_Err_Ok;
3264     }
3265
3266     return pFT_Select_Charmap(ft_face, encoding) == FT_Err_Ok;
3267 }
3268
3269 /*************************************************************
3270  * WineEngCreateFontInstance
3271  *
3272  */
3273 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
3274 {
3275     GdiFont *ret;
3276     Face *face, *best, *best_bitmap;
3277     Family *family, *last_resort_family;
3278     struct list *family_elem_ptr, *face_elem_ptr;
3279     INT height, width = 0;
3280     unsigned int score = 0, new_score;
3281     signed int diff = 0, newdiff;
3282     BOOL bd, it, can_use_bitmap;
3283     LOGFONTW lf;
3284     CHARSETINFO csi;
3285     HFONTLIST *hflist;
3286     FMAT2 dcmat;
3287     FontSubst *psub = NULL;
3288
3289     if (!GetObjectW( hfont, sizeof(lf), &lf )) return NULL;
3290     lf.lfWidth = abs(lf.lfWidth);
3291
3292     can_use_bitmap = GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_RA_ABLE;
3293
3294     TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
3295           debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
3296           lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
3297           lf.lfEscapement);
3298
3299     if(dc->GraphicsMode == GM_ADVANCED)
3300         memcpy(&dcmat, &dc->xformWorld2Vport, sizeof(FMAT2));
3301     else
3302     {
3303         /* Windows 3.1 compatibility mode GM_COMPATIBLE has only limited
3304            font scaling abilities. */
3305         dcmat.eM11 = dcmat.eM22 = fabs(dc->xformWorld2Vport.eM22);
3306         dcmat.eM21 = dcmat.eM12 = 0;
3307     }
3308
3309     TRACE("DC transform %f %f %f %f\n", dcmat.eM11, dcmat.eM12,
3310                                         dcmat.eM21, dcmat.eM22);
3311
3312     EnterCriticalSection( &freetype_cs );
3313
3314     /* check the cache first */
3315     if((ret = find_in_cache(hfont, &lf, &dcmat, can_use_bitmap)) != NULL) {
3316         TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
3317         LeaveCriticalSection( &freetype_cs );
3318         return ret;
3319     }
3320
3321     TRACE("not in cache\n");
3322     if(list_empty(&font_list)) /* No fonts installed */
3323     {
3324         TRACE("No fonts installed\n");
3325         LeaveCriticalSection( &freetype_cs );
3326         return NULL;
3327     }
3328     if(!have_installed_roman_font)
3329     {
3330         TRACE("No roman font installed\n");
3331         LeaveCriticalSection( &freetype_cs );
3332         return NULL;
3333     }
3334
3335     ret = alloc_font();
3336
3337     ret->font_desc.matrix = dcmat;
3338     ret->font_desc.lf = lf;
3339     ret->font_desc.can_use_bitmap = can_use_bitmap;
3340     calc_hash(&ret->font_desc);
3341     hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
3342     hflist->hfont = hfont;
3343     list_add_head(&ret->hfontlist, &hflist->entry);
3344
3345     /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
3346        SYMBOL_CHARSET so that Symbol gets picked irrespective of the
3347        original value lfCharSet.  Note this is a special case for
3348        Symbol and doesn't happen at least for "Wingdings*" */
3349
3350     if(!strcmpiW(lf.lfFaceName, SymbolW))
3351         lf.lfCharSet = SYMBOL_CHARSET;
3352
3353     if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
3354         switch(lf.lfCharSet) {
3355         case DEFAULT_CHARSET:
3356             csi.fs.fsCsb[0] = 0;
3357             break;
3358         default:
3359             FIXME("Untranslated charset %d\n", lf.lfCharSet);
3360             csi.fs.fsCsb[0] = 0;
3361             break;
3362         }
3363     }
3364
3365     family = NULL;
3366     if(lf.lfFaceName[0] != '\0') {
3367         SYSTEM_LINKS *font_link;
3368         CHILD_FONT *font_link_entry;
3369         LPWSTR FaceName = lf.lfFaceName;
3370
3371         /*
3372          * Check for a leading '@' this signals that the font is being
3373          * requested in tategaki mode (vertical writing substitution) but
3374          * does not affect the fontface that is to be selected.
3375          */
3376         if (lf.lfFaceName[0]=='@')
3377             FaceName = &lf.lfFaceName[1];
3378
3379         psub = get_font_subst(&font_subst_list, FaceName, lf.lfCharSet);
3380
3381         if(psub) {
3382             TRACE("substituting %s,%d -> %s,%d\n", debugstr_w(FaceName), lf.lfCharSet,
3383                   debugstr_w(psub->to.name), (psub->to.charset != -1) ? psub->to.charset : lf.lfCharSet);
3384             if (psub->to.charset != -1)
3385                 lf.lfCharSet = psub->to.charset;
3386         }
3387
3388         /* We want a match on name and charset or just name if
3389            charset was DEFAULT_CHARSET.  If the latter then
3390            we fixup the returned charset later in get_nearest_charset
3391            where we'll either use the charset of the current ansi codepage
3392            or if that's unavailable the first charset that the font supports.
3393         */
3394         LIST_FOR_EACH(family_elem_ptr, &font_list) {
3395             family = LIST_ENTRY(family_elem_ptr, Family, entry);
3396             if (!strcmpiW(family->FamilyName, FaceName) ||
3397                 (psub && !strcmpiW(family->FamilyName, psub->to.name)))
3398             {
3399                 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3400                     face = LIST_ENTRY(face_elem_ptr, Face, entry);
3401                     if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
3402                         if(face->scalable || can_use_bitmap)
3403                             goto found;
3404                 }
3405             }
3406         }
3407
3408         /*
3409          * Try check the SystemLink list first for a replacement font.
3410          * We may find good replacements there.
3411          */
3412         LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
3413         {
3414             if(!strcmpiW(font_link->font_name, FaceName))
3415             {
3416                 TRACE("found entry in system list\n");
3417                 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
3418                 {
3419                     face = font_link_entry->face;
3420                     family = face->family;
3421                     if(csi.fs.fsCsb[0] &
3422                         (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]) || !csi.fs.fsCsb[0])
3423                     {
3424                         if(face->scalable || can_use_bitmap)
3425                             goto found;
3426                     }
3427                 }
3428             }
3429         }
3430     }
3431
3432     psub = NULL; /* substitution is no more relevant */
3433
3434     /* If requested charset was DEFAULT_CHARSET then try using charset
3435        corresponding to the current ansi codepage */
3436     if (!csi.fs.fsCsb[0])
3437     {
3438         INT acp = GetACP();
3439         if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
3440             FIXME("TCI failed on codepage %d\n", acp);
3441             csi.fs.fsCsb[0] = 0;
3442         } else
3443             lf.lfCharSet = csi.ciCharset;
3444     }
3445
3446     /* Face families are in the top 4 bits of lfPitchAndFamily,
3447        so mask with 0xF0 before testing */
3448
3449     if((lf.lfPitchAndFamily & FIXED_PITCH) ||
3450        (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
3451         strcpyW(lf.lfFaceName, defFixed);
3452     else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
3453         strcpyW(lf.lfFaceName, defSerif);
3454     else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
3455         strcpyW(lf.lfFaceName, defSans);
3456     else
3457         strcpyW(lf.lfFaceName, defSans);
3458     LIST_FOR_EACH(family_elem_ptr, &font_list) {
3459         family = LIST_ENTRY(family_elem_ptr, Family, entry);
3460         if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
3461             LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3462                 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3463                 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
3464                     if(face->scalable || can_use_bitmap)
3465                         goto found;
3466             }
3467         }
3468     }
3469
3470     last_resort_family = NULL;
3471     LIST_FOR_EACH(family_elem_ptr, &font_list) {
3472         family = LIST_ENTRY(family_elem_ptr, Family, entry);
3473         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3474             face = LIST_ENTRY(face_elem_ptr, Face, entry);
3475             if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) {
3476                 if(face->scalable)
3477                     goto found;
3478                 if(can_use_bitmap && !last_resort_family)
3479                     last_resort_family = family;
3480             }
3481         }
3482     }
3483
3484     if(last_resort_family) {
3485         family = last_resort_family;
3486         csi.fs.fsCsb[0] = 0;
3487         goto found;
3488     }
3489
3490     LIST_FOR_EACH(family_elem_ptr, &font_list) {
3491         family = LIST_ENTRY(family_elem_ptr, Family, entry);
3492         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3493             face = LIST_ENTRY(face_elem_ptr, Face, entry);
3494             if(face->scalable) {
3495                 csi.fs.fsCsb[0] = 0;
3496                 WARN("just using first face for now\n");
3497                 goto found;
3498             }
3499             if(can_use_bitmap && !last_resort_family)
3500                 last_resort_family = family;
3501         }
3502     }
3503     if(!last_resort_family) {
3504         FIXME("can't find a single appropriate font - bailing\n");
3505         free_font(ret);
3506         LeaveCriticalSection( &freetype_cs );
3507         return NULL;
3508     }
3509
3510     WARN("could only find a bitmap font - this will probably look awful!\n");
3511     family = last_resort_family;
3512     csi.fs.fsCsb[0] = 0;
3513
3514 found:
3515     it = lf.lfItalic ? 1 : 0;
3516     bd = lf.lfWeight > 550 ? 1 : 0;
3517
3518     height = lf.lfHeight;
3519
3520     face = best = best_bitmap = NULL;
3521     LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
3522     {
3523         if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
3524         {
3525             BOOL italic, bold;
3526
3527             italic = (face->ntmFlags & NTM_ITALIC) ? 1 : 0;
3528             bold = (face->ntmFlags & NTM_BOLD) ? 1 : 0;
3529             new_score = (italic ^ it) + (bold ^ bd);
3530             if(!best || new_score <= score)
3531             {
3532                 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
3533                       italic, bold, it, bd);
3534                 score = new_score;
3535                 best = face;
3536                 if(best->scalable  && score == 0) break;
3537                 if(!best->scalable)
3538                 {
3539                     if(height > 0)
3540                         newdiff = height - (signed int)(best->size.height);
3541                     else
3542                         newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
3543                     if(!best_bitmap || new_score < score ||
3544                        (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
3545                     {
3546                         TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
3547                         diff = newdiff;
3548                         best_bitmap = best;
3549                         if(score == 0 && diff == 0) break;
3550                     }
3551                 }
3552             }
3553         }
3554     }
3555     if(best)
3556         face = best->scalable ? best : best_bitmap;
3557     ret->fake_italic = (it && !(face->ntmFlags & NTM_ITALIC));
3558     ret->fake_bold = (bd && !(face->ntmFlags & NTM_BOLD));
3559
3560     ret->fs = face->fs;
3561
3562     if(csi.fs.fsCsb[0]) {
3563         ret->charset = lf.lfCharSet;
3564         ret->codepage = csi.ciACP;
3565     }
3566     else
3567         ret->charset = get_nearest_charset(face, &ret->codepage);
3568
3569     TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family->FamilyName),
3570           debugstr_w(face->StyleName), face->file, face->font_data_ptr, face->face_index);
3571
3572     ret->aveWidth = height ? lf.lfWidth : 0;
3573
3574     if(!face->scalable) {
3575         /* Windows uses integer scaling factors for bitmap fonts */
3576         INT scale, scaled_height;
3577
3578         /* FIXME: rotation of bitmap fonts is ignored */
3579         height = abs(GDI_ROUND( (double)height * ret->font_desc.matrix.eM22 ));
3580         if (ret->aveWidth)
3581             ret->aveWidth = (double)ret->aveWidth * ret->font_desc.matrix.eM11;
3582         ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
3583
3584         if (height != 0) height = diff;
3585         height += face->size.height;
3586
3587         scale = (height + face->size.height - 1) / face->size.height;
3588         scaled_height = scale * face->size.height;
3589         /* XP allows not more than 10% deviation */
3590         if (scale > 1 && scaled_height - height > scaled_height / 10) scale--;
3591         ret->scale_y = scale;
3592
3593         width = face->size.x_ppem >> 6;
3594         height = face->size.y_ppem >> 6;
3595     }
3596     else
3597         ret->scale_y = 1.0;
3598     TRACE("font scale y: %f\n", ret->scale_y);
3599
3600     ret->ft_face = OpenFontFace(ret, face, width, height);
3601
3602     if (!ret->ft_face)
3603     {
3604         free_font( ret );
3605         LeaveCriticalSection( &freetype_cs );
3606         return 0;
3607     }
3608
3609     ret->ntmFlags = face->ntmFlags;
3610
3611     if (ret->charset == SYMBOL_CHARSET &&
3612         select_charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
3613         /* No ops */
3614     }
3615     else if (select_charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
3616         /* No ops */
3617     }
3618     else {
3619         select_charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
3620     }
3621
3622     ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
3623     ret->name = psub ? strdupW(psub->from.name) : strdupW(family->FamilyName);
3624     ret->underline = lf.lfUnderline ? 0xff : 0;
3625     ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
3626     create_child_font_list(ret);
3627
3628     if (lf.lfFaceName[0]=='@') /* We need to try to load the GSUB table */
3629     {
3630         int length = WineEngGetFontData (ret, GSUB_TAG , 0, NULL, 0);
3631         if (length != GDI_ERROR)
3632         {
3633             ret->GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
3634             WineEngGetFontData(ret, GSUB_TAG , 0, ret->GSUB_Table, length);
3635             TRACE("Loaded GSUB table of %i bytes\n",length);
3636         }
3637     }
3638
3639     TRACE("caching: gdiFont=%p  hfont=%p\n", ret, hfont);
3640
3641     add_to_cache(ret);
3642     LeaveCriticalSection( &freetype_cs );
3643     return ret;
3644 }
3645
3646 static void dump_gdi_font_list(void)
3647 {
3648     GdiFont *gdiFont;
3649     struct list *elem_ptr;
3650
3651     TRACE("---------- gdiFont Cache ----------\n");
3652     LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
3653         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
3654         TRACE("gdiFont=%p %s %d\n",
3655               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
3656     }
3657
3658     TRACE("---------- Unused gdiFont Cache ----------\n");
3659     LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
3660         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
3661         TRACE("gdiFont=%p %s %d\n",
3662               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
3663     }
3664 }
3665
3666 /*************************************************************
3667  * WineEngDestroyFontInstance
3668  *
3669  * free the gdiFont associated with this handle
3670  *
3671  */
3672 BOOL WineEngDestroyFontInstance(HFONT handle)
3673 {
3674     GdiFont *gdiFont;
3675     HFONTLIST *hflist;
3676     BOOL ret = FALSE;
3677     struct list *font_elem_ptr, *hfontlist_elem_ptr;
3678     int i = 0;
3679
3680     EnterCriticalSection( &freetype_cs );
3681
3682     LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
3683     {
3684         struct list *first_hfont = list_head(&gdiFont->hfontlist);
3685         hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
3686         if(hflist->hfont == handle)
3687         {
3688             TRACE("removing child font %p from child list\n", gdiFont);
3689             list_remove(&gdiFont->entry);
3690             LeaveCriticalSection( &freetype_cs );
3691             return TRUE;
3692         }
3693     }
3694
3695     TRACE("destroying hfont=%p\n", handle);
3696     if(TRACE_ON(font))
3697         dump_gdi_font_list();
3698
3699     font_elem_ptr = list_head(&gdi_font_list);
3700     while(font_elem_ptr) {
3701         gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3702         font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
3703
3704         hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
3705         while(hfontlist_elem_ptr) {
3706             hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
3707             hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
3708             if(hflist->hfont == handle) {
3709                 list_remove(&hflist->entry);
3710                 HeapFree(GetProcessHeap(), 0, hflist);
3711                 ret = TRUE;
3712             }
3713         }
3714         if(list_empty(&gdiFont->hfontlist)) {
3715             TRACE("Moving to Unused list\n");
3716             list_remove(&gdiFont->entry);
3717             list_add_head(&unused_gdi_font_list, &gdiFont->entry);
3718         }
3719     }
3720
3721
3722     font_elem_ptr = list_head(&unused_gdi_font_list);
3723     while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
3724         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3725     while(font_elem_ptr) {
3726         gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3727         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3728         TRACE("freeing %p\n", gdiFont);
3729         list_remove(&gdiFont->entry);
3730         free_font(gdiFont);
3731     }
3732     LeaveCriticalSection( &freetype_cs );
3733     return ret;
3734 }
3735
3736 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
3737                            NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
3738 {
3739     GdiFont *font;
3740     LONG width, height;
3741
3742     if (face->cached_enum_data)
3743     {
3744         TRACE("Cached\n");
3745         *pelf = face->cached_enum_data->elf;
3746         *pntm = face->cached_enum_data->ntm;
3747         *ptype = face->cached_enum_data->type;
3748         return;
3749     }
3750
3751     font = alloc_font();
3752
3753     if(face->scalable) {
3754         height = -2048; /* 2048 is the most common em size */
3755         width = 0;
3756     } else {
3757         height = face->size.y_ppem >> 6;
3758         width = face->size.x_ppem >> 6;
3759     }
3760     font->scale_y = 1.0;
3761
3762     if (!(font->ft_face = OpenFontFace(font, face, width, height)))
3763     {
3764         free_font(font);
3765         return;
3766     }
3767
3768     font->name = strdupW(face->family->FamilyName);
3769     font->ntmFlags = face->ntmFlags;
3770
3771     if (WineEngGetOutlineTextMetrics(font, 0, NULL))
3772     {
3773         memcpy(&pntm->ntmTm, &font->potm->otmTextMetrics, sizeof(TEXTMETRICW));
3774
3775         pntm->ntmTm.ntmSizeEM = font->potm->otmEMSquare;
3776
3777         lstrcpynW(pelf->elfLogFont.lfFaceName,
3778                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFamilyName),
3779                  LF_FACESIZE);
3780         lstrcpynW(pelf->elfFullName,
3781                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFaceName),
3782                  LF_FULLFACESIZE);
3783         lstrcpynW(pelf->elfStyle,
3784                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpStyleName),
3785                  LF_FACESIZE);
3786     }
3787     else
3788     {
3789         WineEngGetTextMetrics(font, (TEXTMETRICW *)&pntm->ntmTm);
3790
3791         pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
3792
3793         lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
3794         lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FULLFACESIZE);
3795         lstrcpynW(pelf->elfStyle, face->StyleName, LF_FACESIZE);
3796     }
3797
3798     pntm->ntmTm.ntmFlags = face->ntmFlags;
3799     pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
3800     pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
3801     pntm->ntmFontSig = face->fs;
3802
3803     pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
3804
3805     pelf->elfLogFont.lfEscapement = 0;
3806     pelf->elfLogFont.lfOrientation = 0;
3807     pelf->elfLogFont.lfHeight = pntm->ntmTm.tmHeight;
3808     pelf->elfLogFont.lfWidth = pntm->ntmTm.tmAveCharWidth;
3809     pelf->elfLogFont.lfWeight = pntm->ntmTm.tmWeight;
3810     pelf->elfLogFont.lfItalic = pntm->ntmTm.tmItalic;
3811     pelf->elfLogFont.lfUnderline = pntm->ntmTm.tmUnderlined;
3812     pelf->elfLogFont.lfStrikeOut = pntm->ntmTm.tmStruckOut;
3813     pelf->elfLogFont.lfCharSet = pntm->ntmTm.tmCharSet;
3814     pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
3815     pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
3816     pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
3817     pelf->elfLogFont.lfPitchAndFamily = (pntm->ntmTm.tmPitchAndFamily & 0xf1) + 1;
3818
3819     *ptype = 0;
3820     if (pntm->ntmTm.tmPitchAndFamily & TMPF_TRUETYPE)
3821         *ptype |= TRUETYPE_FONTTYPE;
3822     if (pntm->ntmTm.tmPitchAndFamily & TMPF_DEVICE)
3823         *ptype |= DEVICE_FONTTYPE;
3824     if(!(pntm->ntmTm.tmPitchAndFamily & TMPF_VECTOR))
3825         *ptype |= RASTER_FONTTYPE;
3826
3827     face->cached_enum_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*face->cached_enum_data));
3828     if (face->cached_enum_data)
3829     {
3830         face->cached_enum_data->elf = *pelf;
3831         face->cached_enum_data->ntm = *pntm;
3832         face->cached_enum_data->type = *ptype;
3833     }
3834
3835     free_font(font);
3836 }
3837
3838 /*************************************************************
3839  * WineEngEnumFonts
3840  *
3841  */
3842 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
3843 {
3844     Family *family;
3845     Face *face;
3846     struct list *family_elem_ptr, *face_elem_ptr;
3847     ENUMLOGFONTEXW elf;
3848     NEWTEXTMETRICEXW ntm;
3849     DWORD type;
3850     FONTSIGNATURE fs;
3851     CHARSETINFO csi;
3852     LOGFONTW lf;
3853     int i;
3854
3855     if (!plf)
3856     {
3857         lf.lfCharSet = DEFAULT_CHARSET;
3858         lf.lfPitchAndFamily = 0;
3859         lf.lfFaceName[0] = 0;
3860         plf = &lf;
3861     }
3862
3863     TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
3864
3865     EnterCriticalSection( &freetype_cs );
3866     if(plf->lfFaceName[0]) {
3867         FontSubst *psub;
3868         psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
3869
3870         if(psub) {
3871             TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
3872                   debugstr_w(psub->to.name));
3873             lf = *plf;
3874             strcpyW(lf.lfFaceName, psub->to.name);
3875             plf = &lf;
3876         }
3877
3878         LIST_FOR_EACH(family_elem_ptr, &font_list) {
3879             family = LIST_ENTRY(family_elem_ptr, Family, entry);
3880             if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
3881                 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3882                     face = LIST_ENTRY(face_elem_ptr, Face, entry);
3883                     GetEnumStructs(face, &elf, &ntm, &type);
3884                     for(i = 0; i < 32; i++) {
3885                         if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3886                             elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3887                             strcpyW(elf.elfScript, OEM_DOSW);
3888                             i = 32; /* break out of loop */
3889                         } else if(!(face->fs.fsCsb[0] & (1L << i)))
3890                             continue;
3891                         else {
3892                             fs.fsCsb[0] = 1L << i;
3893                             fs.fsCsb[1] = 0;
3894                             if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3895                                                      TCI_SRCFONTSIG))
3896                                 csi.ciCharset = DEFAULT_CHARSET;
3897                             if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3898                             if(csi.ciCharset != DEFAULT_CHARSET) {
3899                                 elf.elfLogFont.lfCharSet =
3900                                     ntm.ntmTm.tmCharSet = csi.ciCharset;
3901                                 if(ElfScriptsW[i])
3902                                     strcpyW(elf.elfScript, ElfScriptsW[i]);
3903                                 else
3904                                     FIXME("Unknown elfscript for bit %d\n", i);
3905                             }
3906                         }
3907                         TRACE("enuming face %s full %s style %s charset %d type %d script %s it %d weight %d ntmflags %08x\n",
3908                               debugstr_w(elf.elfLogFont.lfFaceName),
3909                               debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3910                               csi.ciCharset, type, debugstr_w(elf.elfScript),
3911                               elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3912                               ntm.ntmTm.ntmFlags);
3913                         /* release section before callback (FIXME) */
3914                         LeaveCriticalSection( &freetype_cs );
3915                         if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return 0;
3916                         EnterCriticalSection( &freetype_cs );
3917                     }
3918                 }
3919             }
3920         }
3921     } else {
3922         LIST_FOR_EACH(family_elem_ptr, &font_list) {
3923             family = LIST_ENTRY(family_elem_ptr, Family, entry);
3924             face_elem_ptr = list_head(&family->faces);
3925             face = LIST_ENTRY(face_elem_ptr, Face, entry);
3926             GetEnumStructs(face, &elf, &ntm, &type);
3927             for(i = 0; i < 32; i++) {
3928                 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3929                     elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3930                     strcpyW(elf.elfScript, OEM_DOSW);
3931                     i = 32; /* break out of loop */
3932                 } else if(!(face->fs.fsCsb[0] & (1L << i)))
3933                     continue;
3934                 else {
3935                     fs.fsCsb[0] = 1L << i;
3936                     fs.fsCsb[1] = 0;
3937                     if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3938                                              TCI_SRCFONTSIG))
3939                         csi.ciCharset = DEFAULT_CHARSET;
3940                     if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3941                     if(csi.ciCharset != DEFAULT_CHARSET) {
3942                         elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet =
3943                           csi.ciCharset;
3944                           if(ElfScriptsW[i])
3945                               strcpyW(elf.elfScript, ElfScriptsW[i]);
3946                           else
3947                               FIXME("Unknown elfscript for bit %d\n", i);
3948                     }
3949                 }
3950                 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
3951                       debugstr_w(elf.elfLogFont.lfFaceName),
3952                       debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3953                       csi.ciCharset, type, debugstr_w(elf.elfScript),
3954                       elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3955                       ntm.ntmTm.ntmFlags);
3956                 /* release section before callback (FIXME) */
3957                 LeaveCriticalSection( &freetype_cs );
3958                 if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return 0;
3959                 EnterCriticalSection( &freetype_cs );
3960             }
3961         }
3962     }
3963     LeaveCriticalSection( &freetype_cs );
3964     return 1;
3965 }
3966
3967 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
3968 {
3969     pt->x.value = vec->x >> 6;
3970     pt->x.fract = (vec->x & 0x3f) << 10;
3971     pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
3972     pt->y.value = vec->y >> 6;
3973     pt->y.fract = (vec->y & 0x3f) << 10;
3974     pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
3975     return;
3976 }
3977
3978 /***************************************************
3979  * According to the MSDN documentation on WideCharToMultiByte,
3980  * certain codepages cannot set the default_used parameter.
3981  * This returns TRUE if the codepage can set that parameter, false else
3982  * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
3983  */
3984 static BOOL codepage_sets_default_used(UINT codepage)
3985 {
3986    switch (codepage)
3987    {
3988        case CP_UTF7:
3989        case CP_UTF8:
3990        case CP_SYMBOL:
3991            return FALSE;
3992        default:
3993            return TRUE;
3994    }
3995 }
3996
3997 /*
3998  * GSUB Table handling functions
3999  */
4000
4001 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
4002 {
4003     const GSUB_CoverageFormat1* cf1;
4004
4005     cf1 = (GSUB_CoverageFormat1*)table;
4006
4007     if (GET_BE_WORD(cf1->CoverageFormat) == 1)
4008     {
4009         int count = GET_BE_WORD(cf1->GlyphCount);
4010         int i;
4011         TRACE("Coverage Format 1, %i glyphs\n",count);
4012         for (i = 0; i < count; i++)
4013             if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
4014                 return i;
4015         return -1;
4016     }
4017     else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
4018     {
4019         const GSUB_CoverageFormat2* cf2;
4020         int i;
4021         int count;
4022         cf2 = (GSUB_CoverageFormat2*)cf1;
4023
4024         count = GET_BE_WORD(cf2->RangeCount);
4025         TRACE("Coverage Format 2, %i ranges\n",count);
4026         for (i = 0; i < count; i++)
4027         {
4028             if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
4029                 return -1;
4030             if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
4031                 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
4032             {
4033                 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
4034                     glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
4035             }
4036         }
4037         return -1;
4038     }
4039     else
4040         ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
4041
4042     return -1;
4043 }
4044
4045 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
4046 {
4047     const GSUB_ScriptList *script;
4048     const GSUB_Script *deflt = NULL;
4049     int i;
4050     script = (GSUB_ScriptList*)((LPBYTE)header + GET_BE_WORD(header->ScriptList));
4051
4052     TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
4053     for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
4054     {
4055         const GSUB_Script *scr;
4056         int offset;
4057
4058         offset = GET_BE_WORD(script->ScriptRecord[i].Script);
4059         scr = (GSUB_Script*)((LPBYTE)script + offset);
4060
4061         if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
4062             return scr;
4063         if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
4064             deflt = scr;
4065     }
4066     return deflt;
4067 }
4068
4069 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
4070 {
4071     int i;
4072     int offset;
4073     const GSUB_LangSys *Lang;
4074
4075     TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
4076
4077     for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
4078     {
4079         offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
4080         Lang = (GSUB_LangSys*)((LPBYTE)script + offset);
4081
4082         if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
4083             return Lang;
4084     }
4085     offset = GET_BE_WORD(script->DefaultLangSys);
4086     if (offset)
4087     {
4088         Lang = (GSUB_LangSys*)((LPBYTE)script + offset);
4089         return Lang;
4090     }
4091     return NULL;
4092 }
4093
4094 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
4095 {
4096     int i;
4097     const GSUB_FeatureList *feature;
4098     feature = (GSUB_FeatureList*)((LPBYTE)header + GET_BE_WORD(header->FeatureList));
4099
4100     TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
4101     for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
4102     {
4103         int index = GET_BE_WORD(lang->FeatureIndex[i]);
4104         if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
4105         {
4106             const GSUB_Feature *feat;
4107             feat = (GSUB_Feature*)((LPBYTE)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
4108             return feat;
4109         }
4110     }
4111     return NULL;
4112 }
4113
4114 static FT_UInt GSUB_apply_feature(const GSUB_Header * header, const GSUB_Feature* feature, UINT glyph)
4115 {
4116     int i;
4117     int offset;
4118     const GSUB_LookupList *lookup;
4119     lookup = (GSUB_LookupList*)((LPBYTE)header + GET_BE_WORD(header->LookupList));
4120
4121     TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
4122     for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
4123     {
4124         const GSUB_LookupTable *look;
4125         offset = GET_BE_WORD(lookup->Lookup[GET_BE_WORD(feature->LookupListIndex[i])]);
4126         look = (GSUB_LookupTable*)((LPBYTE)lookup + offset);
4127         TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
4128         if (GET_BE_WORD(look->LookupType) != 1)
4129             FIXME("We only handle SubType 1\n");
4130         else
4131         {
4132             int j;
4133
4134             for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
4135             {
4136                 const GSUB_SingleSubstFormat1 *ssf1;
4137                 offset = GET_BE_WORD(look->SubTable[j]);
4138                 ssf1 = (GSUB_SingleSubstFormat1*)((LPBYTE)look+offset);
4139                 if (GET_BE_WORD(ssf1->SubstFormat) == 1)
4140                 {
4141                     int offset = GET_BE_WORD(ssf1->Coverage);
4142                     TRACE("  subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
4143                     if (GSUB_is_glyph_covered((LPBYTE)ssf1+offset, glyph) != -1)
4144                     {
4145                         TRACE("  Glyph 0x%x ->",glyph);
4146                         glyph += GET_BE_WORD(ssf1->DeltaGlyphID);
4147                         TRACE(" 0x%x\n",glyph);
4148                     }
4149                 }
4150                 else
4151                 {
4152                     const GSUB_SingleSubstFormat2 *ssf2;
4153                     INT index;
4154                     INT offset;
4155
4156                     ssf2 = (GSUB_SingleSubstFormat2 *)ssf1;
4157                     offset = GET_BE_WORD(ssf1->Coverage);
4158                     TRACE("  subtype 2,  glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
4159                     index = GSUB_is_glyph_covered((LPBYTE)ssf2+offset, glyph);
4160                     TRACE("  Coverage index %i\n",index);
4161                     if (index != -1)
4162                     {
4163                         TRACE("    Glyph is 0x%x ->",glyph);
4164                         glyph = GET_BE_WORD(ssf2->Substitute[index]);
4165                         TRACE("0x%x\n",glyph);
4166                     }
4167                 }
4168             }
4169         }
4170     }
4171     return glyph;
4172 }
4173
4174 static const char* get_opentype_script(const GdiFont *font)
4175 {
4176     /*
4177      * I am not sure if this is the correct way to generate our script tag
4178      */
4179
4180     switch (font->charset)
4181     {
4182         case ANSI_CHARSET: return "latn";
4183         case BALTIC_CHARSET: return "latn"; /* ?? */
4184         case CHINESEBIG5_CHARSET: return "hani";
4185         case EASTEUROPE_CHARSET: return "latn"; /* ?? */
4186         case GB2312_CHARSET: return "hani";
4187         case GREEK_CHARSET: return "grek";
4188         case HANGUL_CHARSET: return "hang";
4189         case RUSSIAN_CHARSET: return "cyrl";
4190         case SHIFTJIS_CHARSET: return "kana";
4191         case TURKISH_CHARSET: return "latn"; /* ?? */
4192         case VIETNAMESE_CHARSET: return "latn";
4193         case JOHAB_CHARSET: return "latn"; /* ?? */
4194         case ARABIC_CHARSET: return "arab";
4195         case HEBREW_CHARSET: return "hebr";
4196         case THAI_CHARSET: return "thai";
4197         default: return "latn";
4198     }
4199 }
4200
4201 static FT_UInt get_GSUB_vert_glyph(const GdiFont *font, UINT glyph)
4202 {
4203     const GSUB_Header *header;
4204     const GSUB_Script *script;
4205     const GSUB_LangSys *language;
4206     const GSUB_Feature *feature;
4207
4208     if (!font->GSUB_Table)
4209         return glyph;
4210
4211     header = font->GSUB_Table;
4212
4213     script = GSUB_get_script_table(header, get_opentype_script(font));
4214     if (!script)
4215     {
4216         TRACE("Script not found\n");
4217         return glyph;
4218     }
4219     language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
4220     if (!language)
4221     {
4222         TRACE("Language not found\n");
4223         return glyph;
4224     }
4225     feature  =  GSUB_get_feature(header, language, "vrt2");
4226     if (!feature)
4227         feature  =  GSUB_get_feature(header, language, "vert");
4228     if (!feature)
4229     {
4230         TRACE("vrt2/vert feature not found\n");
4231         return glyph;
4232     }
4233     return GSUB_apply_feature(header, feature, glyph);
4234 }
4235
4236 static FT_UInt get_glyph_index(const GdiFont *font, UINT glyph)
4237 {
4238     FT_UInt glyphId;
4239
4240     if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
4241         WCHAR wc = (WCHAR)glyph;
4242         BOOL default_used;
4243         BOOL *default_used_pointer;
4244         FT_UInt ret;
4245         char buf;
4246         default_used_pointer = NULL;
4247         default_used = FALSE;
4248         if (codepage_sets_default_used(font->codepage))
4249             default_used_pointer = &default_used;
4250         if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
4251             ret = 0;
4252         else
4253             ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
4254         TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
4255         return get_GSUB_vert_glyph(font,ret);
4256     }
4257
4258     if(font->ft_face->charmap->encoding == FT_ENCODING_MS_SYMBOL && glyph < 0x100)
4259         glyph = glyph + 0xf000;
4260     glyphId = pFT_Get_Char_Index(font->ft_face, glyph);
4261     return get_GSUB_vert_glyph(font,glyphId);
4262 }
4263
4264 /*************************************************************
4265  * WineEngGetGlyphIndices
4266  *
4267  */
4268 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
4269                                 LPWORD pgi, DWORD flags)
4270 {
4271     int i;
4272     int default_char = -1;
4273
4274     if  (flags & GGI_MARK_NONEXISTING_GLYPHS) default_char = 0xffff;  /* XP would use 0x1f for bitmap fonts */
4275
4276     for(i = 0; i < count; i++)
4277     {
4278         pgi[i] = get_glyph_index(font, lpstr[i]);
4279         if  (pgi[i] == 0)
4280         {
4281             if (default_char == -1)
4282             {
4283                 if (FT_IS_SFNT(font->ft_face))
4284                 {
4285                     TT_OS2 *pOS2 = pFT_Get_Sfnt_Table(font->ft_face, ft_sfnt_os2);
4286                     default_char = (pOS2->usDefaultChar ? get_glyph_index(font, pOS2->usDefaultChar) : 0);
4287                 }
4288                 else
4289                 {
4290                     TEXTMETRICW textm;
4291                     WineEngGetTextMetrics(font, &textm);
4292                     default_char = textm.tmDefaultChar;
4293                 }
4294             }
4295             pgi[i] = default_char;
4296         }
4297     }
4298     return count;
4299 }
4300
4301 static inline BOOL is_identity_FMAT2(const FMAT2 *matrix)
4302 {
4303     static const FMAT2 identity = { 1.0, 0.0, 0.0, 1.0 };
4304     return !memcmp(matrix, &identity, sizeof(FMAT2));
4305 }
4306
4307 static inline BOOL is_identity_MAT2(const MAT2 *matrix)
4308 {
4309     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
4310     return !memcmp(matrix, &identity, sizeof(MAT2));
4311 }
4312
4313 /*************************************************************
4314  * WineEngGetGlyphOutline
4315  *
4316  * Behaves in exactly the same way as the win32 api GetGlyphOutline
4317  * except that the first parameter is the HWINEENGFONT of the font in
4318  * question rather than an HDC.
4319  *
4320  */
4321 DWORD WineEngGetGlyphOutline(GdiFont *incoming_font, UINT glyph, UINT format,
4322                              LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
4323                              const MAT2* lpmat)
4324 {
4325     static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
4326     FT_Face ft_face = incoming_font->ft_face;
4327     GdiFont *font = incoming_font;
4328     FT_UInt glyph_index;
4329     DWORD width, height, pitch, needed = 0;
4330     FT_Bitmap ft_bitmap;
4331     FT_Error err;
4332     INT left, right, top = 0, bottom = 0, adv, lsb, bbx;
4333     FT_Angle angle = 0;
4334     FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
4335     double widthRatio = 1.0;
4336     FT_Matrix transMat = identityMat;
4337     FT_Matrix transMatUnrotated;
4338     BOOL needsTransform = FALSE;
4339     BOOL tategaki = (font->GSUB_Table != NULL);
4340     UINT original_index;
4341
4342     TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
4343           buflen, buf, lpmat);
4344
4345     TRACE("font transform %f %f %f %f\n",
4346           font->font_desc.matrix.eM11, font->font_desc.matrix.eM12,
4347           font->font_desc.matrix.eM21, font->font_desc.matrix.eM22);
4348
4349     EnterCriticalSection( &freetype_cs );
4350
4351     if(format & GGO_GLYPH_INDEX) {
4352         glyph_index = get_GSUB_vert_glyph(incoming_font,glyph);
4353         original_index = glyph;
4354         format &= ~GGO_GLYPH_INDEX;
4355     } else {
4356         get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
4357         ft_face = font->ft_face;
4358         original_index = glyph_index;
4359     }
4360
4361     /* tategaki never appears to happen to lower glyph index */
4362     if (glyph_index < TATEGAKI_LOWER_BOUND )
4363         tategaki = FALSE;
4364
4365     if(original_index >= font->gmsize * GM_BLOCK_SIZE) {
4366         font->gmsize = (original_index / GM_BLOCK_SIZE + 1);
4367         font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
4368                                font->gmsize * sizeof(GM*));
4369     } else {
4370         if (format == GGO_METRICS && font->gm[original_index / GM_BLOCK_SIZE] != NULL &&
4371             FONT_GM(font,original_index)->init && (!lpmat || is_identity_MAT2(lpmat)))
4372         {
4373             *lpgm = FONT_GM(font,original_index)->gm;
4374             TRACE("cached: %u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
4375                   wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
4376                   lpgm->gmCellIncX, lpgm->gmCellIncY);
4377             LeaveCriticalSection( &freetype_cs );
4378             return 1; /* FIXME */
4379         }
4380     }
4381
4382     if (!font->gm[original_index / GM_BLOCK_SIZE])
4383         font->gm[original_index / GM_BLOCK_SIZE] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
4384
4385     /* Scaling factor */
4386     if (font->aveWidth)
4387     {
4388         TEXTMETRICW tm;
4389
4390         WineEngGetTextMetrics(font, &tm);
4391
4392         widthRatio = (double)font->aveWidth;
4393         widthRatio /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
4394     }
4395     else
4396         widthRatio = font->scale_y;
4397
4398     /* Scaling transform */
4399     if (widthRatio != 1.0 || font->scale_y != 1.0)
4400     {
4401         FT_Matrix scaleMat;
4402         scaleMat.xx = FT_FixedFromFloat(widthRatio);
4403         scaleMat.xy = 0;
4404         scaleMat.yx = 0;
4405         scaleMat.yy = FT_FixedFromFloat(font->scale_y);
4406
4407         pFT_Matrix_Multiply(&scaleMat, &transMat);
4408         needsTransform = TRUE;
4409     }
4410
4411     /* Slant transform */
4412     if (font->fake_italic) {
4413         FT_Matrix slantMat;
4414
4415         slantMat.xx = (1 << 16);
4416         slantMat.xy = ((1 << 16) >> 2);
4417         slantMat.yx = 0;
4418         slantMat.yy = (1 << 16);
4419         pFT_Matrix_Multiply(&slantMat, &transMat);
4420         needsTransform = TRUE;
4421     }
4422
4423     /* Rotation transform */
4424     transMatUnrotated = transMat;
4425     if(font->orientation && !tategaki) {
4426         FT_Matrix rotationMat;
4427         FT_Vector vecAngle;
4428         angle = FT_FixedFromFloat((double)font->orientation / 10.0);
4429         pFT_Vector_Unit(&vecAngle, angle);
4430         rotationMat.xx = vecAngle.x;
4431         rotationMat.xy = -vecAngle.y;
4432         rotationMat.yx = -rotationMat.xy;
4433         rotationMat.yy = rotationMat.xx;
4434
4435         pFT_Matrix_Multiply(&rotationMat, &transMat);
4436         needsTransform = TRUE;
4437     }
4438
4439     /* World transform */
4440     if (!is_identity_FMAT2(&font->font_desc.matrix))
4441     {
4442         FT_Matrix worldMat;
4443         worldMat.xx = FT_FixedFromFloat(font->font_desc.matrix.eM11);
4444         worldMat.xy = FT_FixedFromFloat(font->font_desc.matrix.eM21);
4445         worldMat.yx = FT_FixedFromFloat(font->font_desc.matrix.eM12);
4446         worldMat.yy = FT_FixedFromFloat(font->font_desc.matrix.eM22);
4447         pFT_Matrix_Multiply(&worldMat, &transMat);
4448         pFT_Matrix_Multiply(&worldMat, &transMatUnrotated);
4449         needsTransform = TRUE;
4450     }
4451
4452     /* Extra transformation specified by caller */
4453     if (lpmat && !is_identity_MAT2(lpmat))
4454     {
4455         FT_Matrix extraMat;
4456         extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
4457         extraMat.xy = FT_FixedFromFIXED(lpmat->eM21);
4458         extraMat.yx = FT_FixedFromFIXED(lpmat->eM12);
4459         extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
4460         pFT_Matrix_Multiply(&extraMat, &transMat);
4461         pFT_Matrix_Multiply(&extraMat, &transMatUnrotated);
4462         needsTransform = TRUE;
4463     }
4464
4465     if (needsTransform || (format != GGO_METRICS && format != GGO_BITMAP && format != WINE_GGO_GRAY16_BITMAP))
4466         load_flags |= FT_LOAD_NO_BITMAP;
4467
4468     err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
4469
4470     if(err) {
4471         WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
4472         LeaveCriticalSection( &freetype_cs );
4473         return GDI_ERROR;
4474     }
4475
4476     left = (INT)(ft_face->glyph->metrics.horiBearingX) & -64;
4477     right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) + 63) & -64;
4478
4479     adv = (INT)((ft_face->glyph->metrics.horiAdvance) + 63) >> 6;
4480     lsb = left >> 6;
4481     bbx = (right - left) >> 6;
4482
4483     if(!needsTransform) {
4484         top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
4485         bottom = (ft_face->glyph->metrics.horiBearingY -
4486                   ft_face->glyph->metrics.height) & -64;
4487         lpgm->gmCellIncX = adv;
4488         lpgm->gmCellIncY = 0;
4489     } else {
4490         INT xc, yc;
4491         FT_Vector vec;
4492         for(xc = 0; xc < 2; xc++) {
4493             for(yc = 0; yc < 2; yc++) {
4494                 vec.x = (ft_face->glyph->metrics.horiBearingX +
4495                   xc * ft_face->glyph->metrics.width);
4496                 vec.y = ft_face->glyph->metrics.horiBearingY -
4497                   yc * ft_face->glyph->metrics.height;
4498                 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
4499                 pFT_Vector_Transform(&vec, &transMat);
4500                 if(xc == 0 && yc == 0) {
4501                     left = right = vec.x;
4502                     top = bottom = vec.y;
4503                 } else {
4504                     if(vec.x < left) left = vec.x;
4505                     else if(vec.x > right) right = vec.x;
4506                     if(vec.y < bottom) bottom = vec.y;
4507                     else if(vec.y > top) top = vec.y;
4508                 }
4509             }
4510         }
4511         left = left & -64;
4512         right = (right + 63) & -64;
4513         bottom = bottom & -64;
4514         top = (top + 63) & -64;
4515
4516         TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
4517         vec.x = ft_face->glyph->metrics.horiAdvance;
4518         vec.y = 0;
4519         pFT_Vector_Transform(&vec, &transMat);
4520         lpgm->gmCellIncX = (vec.x+63) >> 6;
4521         lpgm->gmCellIncY = -((vec.y+63) >> 6);
4522
4523         vec.x = ft_face->glyph->metrics.horiAdvance;
4524         vec.y = 0;
4525         pFT_Vector_Transform(&vec, &transMatUnrotated);
4526         adv = (vec.x+63) >> 6;
4527     }
4528     lpgm->gmBlackBoxX = (right - left) >> 6;
4529     lpgm->gmBlackBoxY = (top - bottom) >> 6;
4530     lpgm->gmptGlyphOrigin.x = left >> 6;
4531     lpgm->gmptGlyphOrigin.y = top >> 6;
4532
4533     TRACE("%u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
4534           wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
4535           lpgm->gmCellIncX, lpgm->gmCellIncY);
4536
4537     if ((format == GGO_METRICS || format == GGO_BITMAP || format ==  WINE_GGO_GRAY16_BITMAP) &&
4538         (!lpmat || is_identity_MAT2(lpmat))) /* don't cache custom transforms */
4539     {
4540         FONT_GM(font,original_index)->gm = *lpgm;
4541         FONT_GM(font,original_index)->adv = adv;
4542         FONT_GM(font,original_index)->lsb = lsb;
4543         FONT_GM(font,original_index)->bbx = bbx;
4544         FONT_GM(font,original_index)->init = TRUE;
4545     }
4546
4547     if(format == GGO_METRICS)
4548     {
4549         LeaveCriticalSection( &freetype_cs );
4550         return 1; /* FIXME */
4551     }
4552
4553     if(ft_face->glyph->format != ft_glyph_format_outline && format != GGO_BITMAP && format != WINE_GGO_GRAY16_BITMAP) {
4554         TRACE("loaded a bitmap\n");
4555         LeaveCriticalSection( &freetype_cs );
4556         return GDI_ERROR;
4557     }
4558
4559     switch(format) {
4560     case GGO_BITMAP:
4561         width = lpgm->gmBlackBoxX;
4562         height = lpgm->gmBlackBoxY;
4563         pitch = ((width + 31) >> 5) << 2;
4564         needed = pitch * height;
4565
4566         if(!buf || !buflen) break;
4567
4568         switch(ft_face->glyph->format) {
4569         case ft_glyph_format_bitmap:
4570           {
4571             BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
4572             INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
4573             INT h = ft_face->glyph->bitmap.rows;
4574             while(h--) {
4575                 memcpy(dst, src, w);
4576                 src += ft_face->glyph->bitmap.pitch;
4577                 dst += pitch;
4578             }
4579             break;
4580           }
4581
4582         case ft_glyph_format_outline:
4583             ft_bitmap.width = width;
4584             ft_bitmap.rows = height;
4585             ft_bitmap.pitch = pitch;
4586             ft_bitmap.pixel_mode = ft_pixel_mode_mono;
4587             ft_bitmap.buffer = buf;
4588
4589                 if(needsTransform) {
4590                         pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
4591             }
4592
4593             pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
4594
4595             /* Note: FreeType will only set 'black' bits for us. */
4596             memset(buf, 0, needed);
4597             pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
4598             break;
4599
4600         default:
4601             FIXME("loaded glyph format %x\n", ft_face->glyph->format);
4602             LeaveCriticalSection( &freetype_cs );
4603             return GDI_ERROR;
4604         }
4605         break;
4606
4607     case GGO_GRAY2_BITMAP:
4608     case GGO_GRAY4_BITMAP:
4609     case GGO_GRAY8_BITMAP:
4610     case WINE_GGO_GRAY16_BITMAP:
4611       {
4612         unsigned int mult, row, col;
4613         BYTE *start, *ptr;
4614
4615         width = lpgm->gmBlackBoxX;
4616         height = lpgm->gmBlackBoxY;
4617         pitch = (width + 3) / 4 * 4;
4618         needed = pitch * height;
4619
4620         if(!buf || !buflen) break;
4621
4622         switch(ft_face->glyph->format) {
4623         case ft_glyph_format_bitmap:
4624           {
4625             BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
4626             INT h = ft_face->glyph->bitmap.rows;
4627             INT x;
4628             while(h--) {
4629                 for(x = 0; x < pitch; x++)
4630                 {
4631                     if(x < ft_face->glyph->bitmap.width)
4632                         dst[x] = (src[x / 8] & (1 << ( (7 - (x % 8))))) ? 0xff : 0;
4633                     else
4634                         dst[x] = 0;
4635                 }
4636                 src += ft_face->glyph->bitmap.pitch;
4637                 dst += pitch;
4638             }
4639             LeaveCriticalSection( &freetype_cs );
4640             return needed;
4641           }
4642         case ft_glyph_format_outline:
4643           {
4644             ft_bitmap.width = width;
4645             ft_bitmap.rows = height;
4646             ft_bitmap.pitch = pitch;
4647             ft_bitmap.pixel_mode = ft_pixel_mode_grays;
4648             ft_bitmap.buffer = buf;
4649
4650             if(needsTransform)
4651                 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
4652
4653             pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
4654
4655             memset(ft_bitmap.buffer, 0, buflen);
4656
4657             pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
4658
4659             if(format == GGO_GRAY2_BITMAP)
4660                 mult = 4;
4661             else if(format == GGO_GRAY4_BITMAP)
4662                 mult = 16;
4663             else if(format == GGO_GRAY8_BITMAP)
4664                 mult = 64;
4665             else /* format == WINE_GGO_GRAY16_BITMAP */
4666             {
4667                 LeaveCriticalSection( &freetype_cs );
4668                 return needed;
4669             }
4670             break;
4671           }
4672         default:
4673             FIXME("loaded glyph format %x\n", ft_face->glyph->format);
4674             LeaveCriticalSection( &freetype_cs );
4675             return GDI_ERROR;
4676         }
4677
4678         start = buf;
4679         for(row = 0; row < height; row++) {
4680             ptr = start;
4681             for(col = 0; col < width; col++, ptr++) {
4682                 *ptr = (((int)*ptr) * mult + 128) / 256;
4683             }
4684             start += pitch;
4685         }
4686         break;
4687       }
4688
4689     case GGO_NATIVE:
4690       {
4691         int contour, point = 0, first_pt;
4692         FT_Outline *outline = &ft_face->glyph->outline;
4693         TTPOLYGONHEADER *pph;
4694         TTPOLYCURVE *ppc;
4695         DWORD pph_start, cpfx, type;
4696
4697         if(buflen == 0) buf = NULL;
4698
4699         if (needsTransform && buf) {
4700                 pFT_Outline_Transform(outline, &transMat);
4701         }
4702
4703         for(contour = 0; contour < outline->n_contours; contour++) {
4704             pph_start = needed;
4705             pph = (TTPOLYGONHEADER *)((char *)buf + needed);
4706             first_pt = point;
4707             if(buf) {
4708                 pph->dwType = TT_POLYGON_TYPE;
4709                 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
4710             }
4711             needed += sizeof(*pph);
4712             point++;
4713             while(point <= outline->contours[contour]) {
4714                 ppc = (TTPOLYCURVE *)((char *)buf + needed);
4715                 type = (outline->tags[point] & FT_Curve_Tag_On) ?
4716                   TT_PRIM_LINE : TT_PRIM_QSPLINE;
4717                 cpfx = 0;
4718                 do {
4719                     if(buf)
4720                         FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4721                     cpfx++;
4722                     point++;
4723                 } while(point <= outline->contours[contour] &&
4724                         (outline->tags[point] & FT_Curve_Tag_On) ==
4725                         (outline->tags[point-1] & FT_Curve_Tag_On));
4726                 /* At the end of a contour Windows adds the start point, but
4727                    only for Beziers */
4728                 if(point > outline->contours[contour] &&
4729                    !(outline->tags[point-1] & FT_Curve_Tag_On)) {
4730                     if(buf)
4731                         FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
4732                     cpfx++;
4733                 } else if(point <= outline->contours[contour] &&
4734                           outline->tags[point] & FT_Curve_Tag_On) {
4735                   /* add closing pt for bezier */
4736                     if(buf)
4737                         FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4738                     cpfx++;
4739                     point++;
4740                 }
4741                 if(buf) {
4742                     ppc->wType = type;
4743                     ppc->cpfx = cpfx;
4744                 }
4745                 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
4746             }
4747             if(buf)
4748                 pph->cb = needed - pph_start;
4749         }
4750         break;
4751       }
4752     case GGO_BEZIER:
4753       {
4754         /* Convert the quadratic Beziers to cubic Beziers.
4755            The parametric eqn for a cubic Bezier is, from PLRM:
4756            r(t) = at^3 + bt^2 + ct + r0
4757            with the control points:
4758            r1 = r0 + c/3
4759            r2 = r1 + (c + b)/3
4760            r3 = r0 + c + b + a
4761
4762            A quadratic Beizer has the form:
4763            p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
4764
4765            So equating powers of t leads to:
4766            r1 = 2/3 p1 + 1/3 p0
4767            r2 = 2/3 p1 + 1/3 p2
4768            and of course r0 = p0, r3 = p2
4769         */
4770
4771         int contour, point = 0, first_pt;
4772         FT_Outline *outline = &ft_face->glyph->outline;
4773         TTPOLYGONHEADER *pph;
4774         TTPOLYCURVE *ppc;
4775         DWORD pph_start, cpfx, type;
4776         FT_Vector cubic_control[4];
4777         if(buflen == 0) buf = NULL;
4778
4779         if (needsTransform && buf) {
4780                 pFT_Outline_Transform(outline, &transMat);
4781         }
4782
4783         for(contour = 0; contour < outline->n_contours; contour++) {
4784             pph_start = needed;
4785             pph = (TTPOLYGONHEADER *)((char *)buf + needed);
4786             first_pt = point;
4787             if(buf) {
4788                 pph->dwType = TT_POLYGON_TYPE;
4789                 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
4790             }
4791             needed += sizeof(*pph);
4792             point++;
4793             while(point <= outline->contours[contour]) {
4794                 ppc = (TTPOLYCURVE *)((char *)buf + needed);
4795                 type = (outline->tags[point] & FT_Curve_Tag_On) ?
4796                   TT_PRIM_LINE : TT_PRIM_CSPLINE;
4797                 cpfx = 0;
4798                 do {
4799                     if(type == TT_PRIM_LINE) {
4800                         if(buf)
4801                             FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4802                         cpfx++;
4803                         point++;
4804                     } else {
4805                       /* Unlike QSPLINEs, CSPLINEs always have their endpoint
4806                          so cpfx = 3n */
4807
4808                       /* FIXME: Possible optimization in endpoint calculation
4809                          if there are two consecutive curves */
4810                         cubic_control[0] = outline->points[point-1];
4811                         if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
4812                             cubic_control[0].x += outline->points[point].x + 1;
4813                             cubic_control[0].y += outline->points[point].y + 1;
4814                             cubic_control[0].x >>= 1;
4815                             cubic_control[0].y >>= 1;
4816                         }
4817                         if(point+1 > outline->contours[contour])
4818                             cubic_control[3] = outline->points[first_pt];
4819                         else {
4820                             cubic_control[3] = outline->points[point+1];
4821                             if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
4822                                 cubic_control[3].x += outline->points[point].x + 1;
4823                                 cubic_control[3].y += outline->points[point].y + 1;
4824                                 cubic_control[3].x >>= 1;
4825                                 cubic_control[3].y >>= 1;
4826                             }
4827                         }
4828                         /* r1 = 1/3 p0 + 2/3 p1
4829                            r2 = 1/3 p2 + 2/3 p1 */
4830                         cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
4831                         cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
4832                         cubic_control[2] = cubic_control[1];
4833                         cubic_control[1].x += (cubic_control[0].x + 1) / 3;
4834                         cubic_control[1].y += (cubic_control[0].y + 1) / 3;
4835                         cubic_control[2].x += (cubic_control[3].x + 1) / 3;
4836                         cubic_control[2].y += (cubic_control[3].y + 1) / 3;
4837                         if(buf) {
4838                             FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
4839                             FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
4840                             FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
4841                         }
4842                         cpfx += 3;
4843                         point++;
4844                     }
4845                 } while(point <= outline->contours[contour] &&
4846                         (outline->tags[point] & FT_Curve_Tag_On) ==
4847                         (outline->tags[point-1] & FT_Curve_Tag_On));
4848                 /* At the end of a contour Windows adds the start point,
4849                    but only for Beziers and we've already done that.
4850                 */
4851                 if(point <= outline->contours[contour] &&
4852                    outline->tags[point] & FT_Curve_Tag_On) {
4853                   /* This is the closing pt of a bezier, but we've already
4854                      added it, so just inc point and carry on */
4855                     point++;
4856                 }
4857                 if(buf) {
4858                     ppc->wType = type;
4859                     ppc->cpfx = cpfx;
4860                 }
4861                 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
4862             }
4863             if(buf)
4864                 pph->cb = needed - pph_start;
4865         }
4866         break;
4867       }
4868
4869     default:
4870         FIXME("Unsupported format %d\n", format);
4871         LeaveCriticalSection( &freetype_cs );
4872         return GDI_ERROR;
4873     }
4874     LeaveCriticalSection( &freetype_cs );
4875     return needed;
4876 }
4877
4878 static BOOL get_bitmap_text_metrics(GdiFont *font)
4879 {
4880     FT_Face ft_face = font->ft_face;
4881 #ifdef HAVE_FREETYPE_FTWINFNT_H
4882     FT_WinFNT_HeaderRec winfnt_header;
4883 #endif
4884     const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
4885     font->potm = HeapAlloc(GetProcessHeap(), 0, size);
4886     font->potm->otmSize = size;
4887
4888 #define TM font->potm->otmTextMetrics
4889 #ifdef HAVE_FREETYPE_FTWINFNT_H
4890     if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
4891     {
4892         TM.tmHeight = winfnt_header.pixel_height;
4893         TM.tmAscent = winfnt_header.ascent;
4894         TM.tmDescent = TM.tmHeight - TM.tmAscent;
4895         TM.tmInternalLeading = winfnt_header.internal_leading;
4896         TM.tmExternalLeading = winfnt_header.external_leading;
4897         TM.tmAveCharWidth = winfnt_header.avg_width;
4898         TM.tmMaxCharWidth = winfnt_header.max_width;
4899         TM.tmWeight = winfnt_header.weight;
4900         TM.tmOverhang = 0;
4901         TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
4902         TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
4903         TM.tmFirstChar = winfnt_header.first_char;
4904         TM.tmLastChar = winfnt_header.last_char;
4905         TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
4906         TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
4907         TM.tmItalic = winfnt_header.italic;
4908         TM.tmUnderlined = font->underline;
4909         TM.tmStruckOut = font->strikeout;
4910         TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
4911         TM.tmCharSet = winfnt_header.charset;
4912     }
4913     else
4914 #endif
4915     {
4916         TM.tmAscent = ft_face->size->metrics.ascender >> 6;
4917         TM.tmDescent = -ft_face->size->metrics.descender >> 6;
4918         TM.tmHeight = TM.tmAscent + TM.tmDescent;
4919         TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
4920         TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
4921         TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
4922         TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
4923         TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
4924         TM.tmOverhang = 0;
4925         TM.tmDigitizedAspectX = 96; /* FIXME */
4926         TM.tmDigitizedAspectY = 96; /* FIXME */
4927         TM.tmFirstChar = 1;
4928         TM.tmLastChar = 255;
4929         TM.tmDefaultChar = 32;
4930         TM.tmBreakChar = 32;
4931         TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
4932         TM.tmUnderlined = font->underline;
4933         TM.tmStruckOut = font->strikeout;
4934         /* NB inverted meaning of TMPF_FIXED_PITCH */
4935         TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
4936         TM.tmCharSet = font->charset;
4937     }
4938 #undef TM
4939
4940     return TRUE;
4941 }
4942
4943
4944 static void scale_font_metrics(const GdiFont *font, LPTEXTMETRICW ptm)
4945 {
4946     double scale_x, scale_y;
4947
4948     if (font->aveWidth)
4949     {
4950         scale_x = (double)font->aveWidth;
4951         scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
4952     }
4953     else
4954         scale_x = font->scale_y;
4955
4956     scale_x *= fabs(font->font_desc.matrix.eM11);
4957     scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
4958
4959 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
4960 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
4961
4962     SCALE_Y(ptm->tmHeight);
4963     SCALE_Y(ptm->tmAscent);
4964     SCALE_Y(ptm->tmDescent);
4965     SCALE_Y(ptm->tmInternalLeading);
4966     SCALE_Y(ptm->tmExternalLeading);
4967     SCALE_Y(ptm->tmOverhang);
4968
4969     SCALE_X(ptm->tmAveCharWidth);
4970     SCALE_X(ptm->tmMaxCharWidth);
4971
4972 #undef SCALE_X
4973 #undef SCALE_Y
4974 }
4975
4976 static void scale_outline_font_metrics(const GdiFont *font, OUTLINETEXTMETRICW *potm)
4977 {
4978     double scale_x, scale_y;
4979
4980     if (font->aveWidth)
4981     {
4982         scale_x = (double)font->aveWidth;
4983         scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
4984     }
4985     else
4986         scale_x = font->scale_y;
4987
4988     scale_x *= fabs(font->font_desc.matrix.eM11);
4989     scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
4990
4991     scale_font_metrics(font, &potm->otmTextMetrics);
4992
4993 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
4994 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
4995
4996     SCALE_Y(potm->otmAscent);
4997     SCALE_Y(potm->otmDescent);
4998     SCALE_Y(potm->otmLineGap);
4999     SCALE_Y(potm->otmsCapEmHeight);
5000     SCALE_Y(potm->otmsXHeight);
5001     SCALE_Y(potm->otmrcFontBox.top);
5002     SCALE_Y(potm->otmrcFontBox.bottom);
5003     SCALE_X(potm->otmrcFontBox.left);
5004     SCALE_X(potm->otmrcFontBox.right);
5005     SCALE_Y(potm->otmMacAscent);
5006     SCALE_Y(potm->otmMacDescent);
5007     SCALE_Y(potm->otmMacLineGap);
5008     SCALE_X(potm->otmptSubscriptSize.x);
5009     SCALE_Y(potm->otmptSubscriptSize.y);
5010     SCALE_X(potm->otmptSubscriptOffset.x);
5011     SCALE_Y(potm->otmptSubscriptOffset.y);
5012     SCALE_X(potm->otmptSuperscriptSize.x);
5013     SCALE_Y(potm->otmptSuperscriptSize.y);
5014     SCALE_X(potm->otmptSuperscriptOffset.x);
5015     SCALE_Y(potm->otmptSuperscriptOffset.y);
5016     SCALE_Y(potm->otmsStrikeoutSize);
5017     SCALE_Y(potm->otmsStrikeoutPosition);
5018     SCALE_Y(potm->otmsUnderscoreSize);
5019     SCALE_Y(potm->otmsUnderscorePosition);
5020
5021 #undef SCALE_X
5022 #undef SCALE_Y
5023 }
5024
5025 /*************************************************************
5026  * WineEngGetTextMetrics
5027  *
5028  */
5029 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
5030 {
5031     EnterCriticalSection( &freetype_cs );
5032     if(!font->potm) {
5033         if(!WineEngGetOutlineTextMetrics(font, 0, NULL))
5034             if(!get_bitmap_text_metrics(font))
5035             {
5036                 LeaveCriticalSection( &freetype_cs );
5037                 return FALSE;
5038             }
5039     }
5040     if(!font->potm)
5041     {
5042         LeaveCriticalSection( &freetype_cs );
5043         return FALSE;
5044     }
5045     *ptm = font->potm->otmTextMetrics;
5046     scale_font_metrics(font, ptm);
5047     LeaveCriticalSection( &freetype_cs );
5048     return TRUE;
5049 }
5050
5051
5052 /*************************************************************
5053  * WineEngGetOutlineTextMetrics
5054  *
5055  */
5056 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
5057                                   OUTLINETEXTMETRICW *potm)
5058 {
5059     FT_Face ft_face = font->ft_face;
5060     UINT needed, lenfam, lensty, ret;
5061     TT_OS2 *pOS2;
5062     TT_HoriHeader *pHori;
5063     TT_Postscript *pPost;
5064     FT_Fixed x_scale, y_scale;
5065     WCHAR *family_nameW, *style_nameW;
5066     static const WCHAR spaceW[] = {' ', '\0'};
5067     char *cp;
5068     INT ascent, descent;
5069
5070     TRACE("font=%p\n", font);
5071
5072     if(!FT_IS_SCALABLE(ft_face))
5073         return 0;
5074
5075     EnterCriticalSection( &freetype_cs );
5076
5077     if(font->potm) {
5078         if(cbSize >= font->potm->otmSize)
5079         {
5080             memcpy(potm, font->potm, font->potm->otmSize);
5081             scale_outline_font_metrics(font, potm);
5082         }
5083         LeaveCriticalSection( &freetype_cs );
5084         return font->potm->otmSize;
5085     }
5086
5087
5088     needed = sizeof(*potm);
5089
5090     lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
5091     family_nameW = strdupW(font->name);
5092
5093     lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
5094       * sizeof(WCHAR);
5095     style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
5096     MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
5097                         style_nameW, lensty/sizeof(WCHAR));
5098
5099     /* These names should be read from the TT name table */
5100
5101     /* length of otmpFamilyName */
5102     needed += lenfam;
5103
5104     /* length of otmpFaceName */
5105     if ((ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) == 0) {
5106       needed += lenfam; /* just the family name */
5107     } else {
5108       needed += lenfam + lensty; /* family + " " + style */
5109     }
5110
5111     /* length of otmpStyleName */
5112     needed += lensty;
5113
5114     /* length of otmpFullName */
5115     needed += lenfam + lensty;
5116
5117
5118     x_scale = ft_face->size->metrics.x_scale;
5119     y_scale = ft_face->size->metrics.y_scale;
5120
5121     pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
5122     if(!pOS2) {
5123         FIXME("Can't find OS/2 table - not TT font?\n");
5124         ret = 0;
5125         goto end;
5126     }
5127
5128     pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
5129     if(!pHori) {
5130         FIXME("Can't find HHEA table - not TT font?\n");
5131         ret = 0;
5132         goto end;
5133     }
5134
5135     pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
5136
5137     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",
5138           pOS2->usWinAscent, pOS2->usWinDescent,
5139           pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
5140           ft_face->ascender, ft_face->descender, ft_face->height,
5141           pHori->Ascender, pHori->Descender, pHori->Line_Gap,
5142           ft_face->bbox.yMax, ft_face->bbox.yMin);
5143
5144     font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
5145     font->potm->otmSize = needed;
5146
5147 #define TM font->potm->otmTextMetrics
5148
5149     if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
5150         ascent = pHori->Ascender;
5151         descent = -pHori->Descender;
5152     } else {
5153         ascent = pOS2->usWinAscent;
5154         descent = pOS2->usWinDescent;
5155     }
5156
5157     if(font->yMax) {
5158         TM.tmAscent = font->yMax;
5159         TM.tmDescent = -font->yMin;
5160         TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
5161     } else {
5162         TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
5163         TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
5164         TM.tmInternalLeading = (pFT_MulFix(ascent + descent
5165                                             - ft_face->units_per_EM, y_scale) + 32) >> 6;
5166     }
5167
5168     TM.tmHeight = TM.tmAscent + TM.tmDescent;
5169
5170     /* MSDN says:
5171      el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
5172     */
5173     TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
5174                  ((ascent + descent) -
5175                   (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
5176
5177     TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
5178     if (TM.tmAveCharWidth == 0) {
5179         TM.tmAveCharWidth = 1;
5180     }
5181     TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
5182     TM.tmWeight = (font->fake_bold || (ft_face->style_flags & FT_STYLE_FLAG_BOLD)) ? FW_BOLD : FW_REGULAR;
5183     TM.tmOverhang = 0;
5184     TM.tmDigitizedAspectX = 300;
5185     TM.tmDigitizedAspectY = 300;
5186     /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
5187      * symbol range to 0 - f0ff
5188      */
5189     if (font->charset == SYMBOL_CHARSET)
5190     {
5191         TM.tmFirstChar = 0;
5192         TM.tmDefaultChar = pOS2->usDefaultChar ? pOS2->usDefaultChar : 0x1f;
5193     }
5194     else
5195     {
5196         TM.tmFirstChar = pOS2->usFirstCharIndex;
5197         TM.tmDefaultChar = pOS2->usDefaultChar ? pOS2->usDefaultChar : 0xffff;
5198     }
5199     TM.tmLastChar = pOS2->usLastCharIndex;
5200     TM.tmBreakChar = pOS2->usBreakChar ? pOS2->usBreakChar : ' ';
5201     TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
5202     TM.tmUnderlined = font->underline;
5203     TM.tmStruckOut = font->strikeout;
5204
5205     /* Yes TPMF_FIXED_PITCH is correct; braindead api */
5206     if(!FT_IS_FIXED_WIDTH(ft_face) &&
5207        (pOS2->version == 0xFFFFU ||
5208         pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
5209         TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
5210     else
5211         TM.tmPitchAndFamily = 0;
5212
5213     switch(pOS2->panose[PAN_FAMILYTYPE_INDEX]) {
5214     case PAN_FAMILY_SCRIPT:
5215         TM.tmPitchAndFamily |= FF_SCRIPT;
5216         break;
5217     case PAN_FAMILY_DECORATIVE:
5218     case PAN_FAMILY_PICTORIAL:
5219         TM.tmPitchAndFamily |= FF_DECORATIVE;
5220         break;
5221     case PAN_FAMILY_TEXT_DISPLAY:
5222         if(TM.tmPitchAndFamily == 0) /* fixed */
5223             TM.tmPitchAndFamily = FF_MODERN;
5224         else {
5225             switch(pOS2->panose[PAN_SERIFSTYLE_INDEX]) {
5226             case PAN_SERIF_NORMAL_SANS:
5227             case PAN_SERIF_OBTUSE_SANS:
5228             case PAN_SERIF_PERP_SANS:
5229                 TM.tmPitchAndFamily |= FF_SWISS;
5230                 break;
5231             default:
5232                 TM.tmPitchAndFamily |= FF_ROMAN;
5233             }
5234         }
5235         break;
5236     default:
5237         TM.tmPitchAndFamily |= FF_DONTCARE;
5238     }
5239
5240     if(FT_IS_SCALABLE(ft_face))
5241         TM.tmPitchAndFamily |= TMPF_VECTOR;
5242
5243     if(FT_IS_SFNT(ft_face))
5244     {
5245         if (font->ntmFlags & NTM_PS_OPENTYPE)
5246             TM.tmPitchAndFamily |= TMPF_DEVICE;
5247         else
5248             TM.tmPitchAndFamily |= TMPF_TRUETYPE;
5249     }
5250
5251     TM.tmCharSet = font->charset;
5252
5253     font->potm->otmFiller = 0;
5254     memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
5255     font->potm->otmfsSelection = pOS2->fsSelection;
5256     font->potm->otmfsType = pOS2->fsType;
5257     font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
5258     font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
5259     font->potm->otmItalicAngle = 0; /* POST table */
5260     font->potm->otmEMSquare = ft_face->units_per_EM;
5261     font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
5262     font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
5263     font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
5264     font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
5265     font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
5266     font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
5267     font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
5268     font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
5269     font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
5270     font->potm->otmMacAscent = TM.tmAscent;
5271     font->potm->otmMacDescent = -TM.tmDescent;
5272     font->potm->otmMacLineGap = font->potm->otmLineGap;
5273     font->potm->otmusMinimumPPEM = 0; /* TT Header */
5274     font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
5275     font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
5276     font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
5277     font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
5278     font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
5279     font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
5280     font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
5281     font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
5282     font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
5283     font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
5284     if(!pPost) {
5285         font->potm->otmsUnderscoreSize = 0;
5286         font->potm->otmsUnderscorePosition = 0;
5287     } else {
5288         font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
5289         font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
5290     }
5291 #undef TM
5292
5293     /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
5294     cp = (char*)font->potm + sizeof(*font->potm);
5295     font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
5296     strcpyW((WCHAR*)cp, family_nameW);
5297     cp += lenfam;
5298     font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
5299     strcpyW((WCHAR*)cp, style_nameW);
5300     cp += lensty;
5301     font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
5302     strcpyW((WCHAR*)cp, family_nameW);
5303     if (ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) {
5304         strcatW((WCHAR*)cp, spaceW);
5305         strcatW((WCHAR*)cp, style_nameW);
5306         cp += lenfam + lensty;
5307     } else
5308         cp += lenfam;
5309     font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
5310     strcpyW((WCHAR*)cp, family_nameW);
5311     strcatW((WCHAR*)cp, spaceW);
5312     strcatW((WCHAR*)cp, style_nameW);
5313     ret = needed;
5314
5315     if(potm && needed <= cbSize)
5316     {
5317         memcpy(potm, font->potm, font->potm->otmSize);
5318         scale_outline_font_metrics(font, potm);
5319     }
5320
5321 end:
5322     HeapFree(GetProcessHeap(), 0, style_nameW);
5323     HeapFree(GetProcessHeap(), 0, family_nameW);
5324
5325     LeaveCriticalSection( &freetype_cs );
5326     return ret;
5327 }
5328
5329 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
5330 {
5331     HFONTLIST *hfontlist;
5332     child->font = alloc_font();
5333     child->font->ft_face = OpenFontFace(child->font, child->face, 0, -font->ppem);
5334     if(!child->font->ft_face)
5335     {
5336         free_font(child->font);
5337         child->font = NULL;
5338         return FALSE;
5339     }
5340
5341     child->font->ntmFlags = child->face->ntmFlags;
5342     child->font->orientation = font->orientation;
5343     child->font->scale_y = font->scale_y;
5344     hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
5345     hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
5346     list_add_head(&child->font->hfontlist, &hfontlist->entry);
5347     child->font->base_font = font;
5348     list_add_head(&child_font_list, &child->font->entry);
5349     TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
5350     return TRUE;
5351 }
5352
5353 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
5354 {
5355     FT_UInt g;
5356     CHILD_FONT *child_font;
5357
5358     if(font->base_font)
5359         font = font->base_font;
5360
5361     *linked_font = font;
5362
5363     if((*glyph = get_glyph_index(font, c)))
5364         return TRUE;
5365
5366     LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
5367     {
5368         if(!child_font->font)
5369             if(!load_child_font(font, child_font))
5370                 continue;
5371
5372         if(!child_font->font->ft_face)
5373             continue;
5374         g = get_glyph_index(child_font->font, c);
5375         if(g)
5376         {
5377             *glyph = g;
5378             *linked_font = child_font->font;
5379             return TRUE;
5380         }
5381     }
5382     return FALSE;
5383 }
5384
5385 /*************************************************************
5386  * WineEngGetCharWidth
5387  *
5388  */
5389 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
5390                          LPINT buffer)
5391 {
5392     UINT c;
5393     GLYPHMETRICS gm;
5394     FT_UInt glyph_index;
5395     GdiFont *linked_font;
5396
5397     TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
5398
5399     EnterCriticalSection( &freetype_cs );
5400     for(c = firstChar; c <= lastChar; c++) {
5401         get_glyph_index_linked(font, c, &linked_font, &glyph_index);
5402         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5403                                &gm, 0, NULL, NULL);
5404         buffer[c - firstChar] = FONT_GM(linked_font,glyph_index)->adv;
5405     }
5406     LeaveCriticalSection( &freetype_cs );
5407     return TRUE;
5408 }
5409
5410 /*************************************************************
5411  * WineEngGetCharABCWidths
5412  *
5413  */
5414 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
5415                              LPABC buffer)
5416 {
5417     UINT c;
5418     GLYPHMETRICS gm;
5419     FT_UInt glyph_index;
5420     GdiFont *linked_font;
5421
5422     TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
5423
5424     if(!FT_IS_SCALABLE(font->ft_face))
5425         return FALSE;
5426
5427     EnterCriticalSection( &freetype_cs );
5428
5429     for(c = firstChar; c <= lastChar; c++) {
5430         get_glyph_index_linked(font, c, &linked_font, &glyph_index);
5431         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5432                                &gm, 0, NULL, NULL);
5433         buffer[c - firstChar].abcA = FONT_GM(linked_font,glyph_index)->lsb;
5434         buffer[c - firstChar].abcB = FONT_GM(linked_font,glyph_index)->bbx;
5435         buffer[c - firstChar].abcC = FONT_GM(linked_font,glyph_index)->adv - FONT_GM(linked_font,glyph_index)->lsb -
5436             FONT_GM(linked_font,glyph_index)->bbx;
5437     }
5438     LeaveCriticalSection( &freetype_cs );
5439     return TRUE;
5440 }
5441
5442 /*************************************************************
5443  * WineEngGetCharABCWidthsI
5444  *
5445  */
5446 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
5447                               LPABC buffer)
5448 {
5449     UINT c;
5450     GLYPHMETRICS gm;
5451     FT_UInt glyph_index;
5452     GdiFont *linked_font;
5453
5454     if(!FT_HAS_HORIZONTAL(font->ft_face))
5455         return FALSE;
5456
5457     EnterCriticalSection( &freetype_cs );
5458
5459     get_glyph_index_linked(font, 'a', &linked_font, &glyph_index);
5460     if (!pgi)
5461         for(c = firstChar; c < firstChar+count; c++) {
5462             WineEngGetGlyphOutline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
5463                                    &gm, 0, NULL, NULL);
5464             buffer[c - firstChar].abcA = FONT_GM(linked_font,c)->lsb;
5465             buffer[c - firstChar].abcB = FONT_GM(linked_font,c)->bbx;
5466             buffer[c - firstChar].abcC = FONT_GM(linked_font,c)->adv - FONT_GM(linked_font,c)->lsb
5467                 - FONT_GM(linked_font,c)->bbx;
5468         }
5469     else
5470         for(c = 0; c < count; c++) {
5471             WineEngGetGlyphOutline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
5472                                    &gm, 0, NULL, NULL);
5473             buffer[c].abcA = FONT_GM(linked_font,pgi[c])->lsb;
5474             buffer[c].abcB = FONT_GM(linked_font,pgi[c])->bbx;
5475             buffer[c].abcC = FONT_GM(linked_font,pgi[c])->adv
5476                 - FONT_GM(linked_font,pgi[c])->lsb - FONT_GM(linked_font,pgi[c])->bbx;
5477         }
5478
5479     LeaveCriticalSection( &freetype_cs );
5480     return TRUE;
5481 }
5482
5483 /*************************************************************
5484  * WineEngGetTextExtentExPoint
5485  *
5486  */
5487 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
5488                                  INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
5489 {
5490     INT idx;
5491     INT nfit = 0, ext;
5492     GLYPHMETRICS gm;
5493     TEXTMETRICW tm;
5494     FT_UInt glyph_index;
5495     GdiFont *linked_font;
5496
5497     TRACE("%p, %s, %d, %d, %p\n", font, debugstr_wn(wstr, count), count,
5498           max_ext, size);
5499
5500     EnterCriticalSection( &freetype_cs );
5501
5502     size->cx = 0;
5503     WineEngGetTextMetrics(font, &tm);
5504     size->cy = tm.tmHeight;
5505
5506     for(idx = 0; idx < count; idx++) {
5507         get_glyph_index_linked(font, wstr[idx], &linked_font, &glyph_index);
5508         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5509                                &gm, 0, NULL, NULL);
5510         size->cx += FONT_GM(linked_font,glyph_index)->adv;
5511         ext = size->cx;
5512         if (! pnfit || ext <= max_ext) {
5513             ++nfit;
5514             if (dxs)
5515                 dxs[idx] = ext;
5516         }
5517     }
5518
5519     if (pnfit)
5520         *pnfit = nfit;
5521
5522     LeaveCriticalSection( &freetype_cs );
5523     TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
5524     return TRUE;
5525 }
5526
5527 /*************************************************************
5528  * WineEngGetTextExtentExPointI
5529  *
5530  */
5531 BOOL WineEngGetTextExtentExPointI(GdiFont *font, const WORD *indices, INT count,
5532                                   INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
5533 {
5534     INT idx;
5535     INT nfit = 0, ext;
5536     GLYPHMETRICS gm;
5537     TEXTMETRICW tm;
5538
5539     TRACE("%p, %p, %d, %d, %p\n", font, indices, count, max_ext, size);
5540
5541     EnterCriticalSection( &freetype_cs );
5542
5543     size->cx = 0;
5544     WineEngGetTextMetrics(font, &tm);
5545     size->cy = tm.tmHeight;
5546
5547     for(idx = 0; idx < count; idx++) {
5548         WineEngGetGlyphOutline(font, indices[idx],
5549                                GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL,
5550                                NULL);
5551         size->cx += FONT_GM(font,indices[idx])->adv;
5552         ext = size->cx;
5553         if (! pnfit || ext <= max_ext) {
5554             ++nfit;
5555             if (dxs)
5556                 dxs[idx] = ext;
5557         }
5558     }
5559
5560     if (pnfit)
5561         *pnfit = nfit;
5562
5563     LeaveCriticalSection( &freetype_cs );
5564     TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
5565     return TRUE;
5566 }
5567
5568 /*************************************************************
5569  * WineEngGetFontData
5570  *
5571  */
5572 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
5573                          DWORD cbData)
5574 {
5575     FT_Face ft_face = font->ft_face;
5576     FT_ULong len;
5577     FT_Error err;
5578
5579     TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
5580         font, LOBYTE(LOWORD(table)), HIBYTE(LOWORD(table)),
5581         LOBYTE(HIWORD(table)), HIBYTE(HIWORD(table)), offset, buf, cbData);
5582
5583     if(!FT_IS_SFNT(ft_face))
5584         return GDI_ERROR;
5585
5586     if(!buf || !cbData)
5587         len = 0;
5588     else
5589         len = cbData;
5590
5591     if(table) { /* MS tags differ in endianness from FT ones */
5592         table = table >> 24 | table << 24 |
5593           (table >> 8 & 0xff00) | (table << 8 & 0xff0000);
5594     }
5595
5596     /* make sure value of len is the value freetype says it needs */
5597     if(buf && len)
5598     {
5599         FT_ULong needed = 0;
5600         err = load_sfnt_table(ft_face, table, offset, NULL, &needed);
5601         if( !err && needed < len) len = needed;
5602     }
5603     err = load_sfnt_table(ft_face, table, offset, buf, &len);
5604
5605     if(err) {
5606         TRACE("Can't find table %c%c%c%c\n",
5607               /* bytes were reversed */
5608               HIBYTE(HIWORD(table)), LOBYTE(HIWORD(table)),
5609               HIBYTE(LOWORD(table)), LOBYTE(LOWORD(table)));
5610         return GDI_ERROR;
5611     }
5612     return len;
5613 }
5614
5615 /*************************************************************
5616  * WineEngGetTextFace
5617  *
5618  */
5619 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
5620 {
5621     INT n = strlenW(font->name) + 1;
5622     if(str) {
5623         lstrcpynW(str, font->name, count);
5624         return min(count, n);
5625     } else
5626         return n;
5627 }
5628
5629 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
5630 {
5631     if (fs) *fs = font->fs;
5632     return font->charset;
5633 }
5634
5635 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
5636 {
5637     GdiFont *font = dc->gdiFont, *linked_font;
5638     struct list *first_hfont;
5639     BOOL ret;
5640
5641     EnterCriticalSection( &freetype_cs );
5642     ret = get_glyph_index_linked(font, c, &linked_font, glyph);
5643     TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
5644     if(font == linked_font)
5645         *new_hfont = dc->hFont;
5646     else
5647     {
5648         first_hfont = list_head(&linked_font->hfontlist);
5649         *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
5650     }
5651     LeaveCriticalSection( &freetype_cs );
5652     return ret;
5653 }
5654
5655 /* Retrieve a list of supported Unicode ranges for a given font.
5656  * Can be called with NULL gs to calculate the buffer size. Returns
5657  * the number of ranges found.
5658  */
5659 static DWORD get_font_unicode_ranges(FT_Face face, GLYPHSET *gs)
5660 {
5661     DWORD num_ranges = 0;
5662
5663     if (face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
5664     {
5665         FT_UInt glyph_code;
5666         FT_ULong char_code, char_code_prev;
5667
5668         glyph_code = 0;
5669         char_code_prev = char_code = pFT_Get_First_Char(face, &glyph_code);
5670
5671         TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
5672                face->num_glyphs, glyph_code, char_code);
5673
5674         if (!glyph_code) return 0;
5675
5676         if (gs)
5677         {
5678             gs->ranges[0].wcLow = (USHORT)char_code;
5679             gs->ranges[0].cGlyphs = 0;
5680             gs->cGlyphsSupported = 0;
5681         }
5682
5683         num_ranges = 1;
5684         while (glyph_code)
5685         {
5686             if (char_code < char_code_prev)
5687             {
5688                 ERR("expected increasing char code from FT_Get_Next_Char\n");
5689                 return 0;
5690             }
5691             if (char_code - char_code_prev > 1)
5692             {
5693                 num_ranges++;
5694                 if (gs)
5695                 {
5696                     gs->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
5697                     gs->ranges[num_ranges - 1].cGlyphs = 1;
5698                     gs->cGlyphsSupported++;
5699                 }
5700             }
5701             else if (gs)
5702             {
5703                 gs->ranges[num_ranges - 1].cGlyphs++;
5704                 gs->cGlyphsSupported++;
5705             }
5706             char_code_prev = char_code;
5707             char_code = pFT_Get_Next_Char(face, char_code, &glyph_code);
5708         }
5709     }
5710     else
5711         FIXME("encoding %u not supported\n", face->charmap->encoding);
5712
5713     return num_ranges;
5714 }
5715
5716 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
5717 {
5718     DWORD size = 0;
5719     DWORD num_ranges = get_font_unicode_ranges(font->ft_face, glyphset);
5720
5721     size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
5722     if (glyphset)
5723     {
5724         glyphset->cbThis = size;
5725         glyphset->cRanges = num_ranges;
5726     }
5727     return size;
5728 }
5729
5730 /*************************************************************
5731  *     FontIsLinked
5732  */
5733 BOOL WineEngFontIsLinked(GdiFont *font)
5734 {
5735     BOOL ret;
5736     EnterCriticalSection( &freetype_cs );
5737     ret = !list_empty(&font->child_fonts);
5738     LeaveCriticalSection( &freetype_cs );
5739     return ret;
5740 }
5741
5742 static BOOL is_hinting_enabled(void)
5743 {
5744     /* Use the >= 2.2.0 function if available */
5745     if(pFT_Get_TrueType_Engine_Type)
5746     {
5747         FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
5748         return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
5749     }
5750 #ifdef FT_DRIVER_HAS_HINTER
5751     else
5752     {
5753         FT_Module mod;
5754
5755         /* otherwise if we've been compiled with < 2.2.0 headers
5756            use the internal macro */
5757         mod = pFT_Get_Module(library, "truetype");
5758         if(mod && FT_DRIVER_HAS_HINTER(mod))
5759             return TRUE;
5760     }
5761 #endif
5762
5763     return FALSE;
5764 }
5765
5766 /*************************************************************************
5767  *             GetRasterizerCaps   (GDI32.@)
5768  */
5769 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
5770 {
5771     static int hinting = -1;
5772
5773     if(hinting == -1)
5774     {
5775         hinting = is_hinting_enabled();
5776         TRACE("hinting is %senabled\n", hinting ? "" : "NOT ");
5777     }
5778
5779     lprs->nSize = sizeof(RASTERIZER_STATUS);
5780     lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
5781     lprs->nLanguageID = 0;
5782     return TRUE;
5783 }
5784
5785 /*************************************************************
5786  *     WineEngRealizationInfo
5787  */
5788 BOOL WineEngRealizationInfo(GdiFont *font, realization_info_t *info)
5789 {
5790     FIXME("(%p, %p): stub!\n", font, info);
5791
5792     info->flags = 1;
5793     if(FT_IS_SCALABLE(font->ft_face))
5794         info->flags |= 2;
5795
5796     info->cache_num = font->cache_num;
5797     info->unknown2 = -1;
5798     return TRUE;
5799 }
5800
5801 /*************************************************************************
5802  * Kerning support for TrueType fonts
5803  */
5804 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
5805
5806 struct TT_kern_table
5807 {
5808     USHORT version;
5809     USHORT nTables;
5810 };
5811
5812 struct TT_kern_subtable
5813 {
5814     USHORT version;
5815     USHORT length;
5816     union
5817     {
5818         USHORT word;
5819         struct
5820         {
5821             USHORT horizontal : 1;
5822             USHORT minimum : 1;
5823             USHORT cross_stream: 1;
5824             USHORT override : 1;
5825             USHORT reserved1 : 4;
5826             USHORT format : 8;
5827         } bits;
5828     } coverage;
5829 };
5830
5831 struct TT_format0_kern_subtable
5832 {
5833     USHORT nPairs;
5834     USHORT searchRange;
5835     USHORT entrySelector;
5836     USHORT rangeShift;
5837 };
5838
5839 struct TT_kern_pair
5840 {
5841     USHORT left;
5842     USHORT right;
5843     short  value;
5844 };
5845
5846 static DWORD parse_format0_kern_subtable(GdiFont *font,
5847                                          const struct TT_format0_kern_subtable *tt_f0_ks,
5848                                          const USHORT *glyph_to_char,
5849                                          KERNINGPAIR *kern_pair, DWORD cPairs)
5850 {
5851     USHORT i, nPairs;
5852     const struct TT_kern_pair *tt_kern_pair;
5853
5854     TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
5855
5856     nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
5857
5858     TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
5859            nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
5860            GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
5861
5862     if (!kern_pair || !cPairs)
5863         return nPairs;
5864
5865     tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
5866
5867     nPairs = min(nPairs, cPairs);
5868
5869     for (i = 0; i < nPairs; i++)
5870     {
5871         kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
5872         kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
5873         /* this algorithm appears to better match what Windows does */
5874         kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
5875         if (kern_pair->iKernAmount < 0)
5876         {
5877             kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
5878             kern_pair->iKernAmount -= font->ppem;
5879         }
5880         else if (kern_pair->iKernAmount > 0)
5881         {
5882             kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
5883             kern_pair->iKernAmount += font->ppem;
5884         }
5885         kern_pair->iKernAmount /= font->ft_face->units_per_EM;
5886
5887         TRACE("left %u right %u value %d\n",
5888                kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
5889
5890         kern_pair++;
5891     }
5892     TRACE("copied %u entries\n", nPairs);
5893     return nPairs;
5894 }
5895
5896 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
5897 {
5898     DWORD length;
5899     void *buf;
5900     const struct TT_kern_table *tt_kern_table;
5901     const struct TT_kern_subtable *tt_kern_subtable;
5902     USHORT i, nTables;
5903     USHORT *glyph_to_char;
5904
5905     EnterCriticalSection( &freetype_cs );
5906     if (font->total_kern_pairs != (DWORD)-1)
5907     {
5908         if (cPairs && kern_pair)
5909         {
5910             cPairs = min(cPairs, font->total_kern_pairs);
5911             memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
5912             LeaveCriticalSection( &freetype_cs );
5913             return cPairs;
5914         }
5915         LeaveCriticalSection( &freetype_cs );
5916         return font->total_kern_pairs;
5917     }
5918
5919     font->total_kern_pairs = 0;
5920
5921     length = WineEngGetFontData(font, MS_KERN_TAG, 0, NULL, 0);
5922
5923     if (length == GDI_ERROR)
5924     {
5925         TRACE("no kerning data in the font\n");
5926         LeaveCriticalSection( &freetype_cs );
5927         return 0;
5928     }
5929
5930     buf = HeapAlloc(GetProcessHeap(), 0, length);
5931     if (!buf)
5932     {
5933         WARN("Out of memory\n");
5934         LeaveCriticalSection( &freetype_cs );
5935         return 0;
5936     }
5937
5938     WineEngGetFontData(font, MS_KERN_TAG, 0, buf, length);
5939
5940     /* build a glyph index to char code map */
5941     glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
5942     if (!glyph_to_char)
5943     {
5944         WARN("Out of memory allocating a glyph index to char code map\n");
5945         HeapFree(GetProcessHeap(), 0, buf);
5946         LeaveCriticalSection( &freetype_cs );
5947         return 0;
5948     }
5949
5950     if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
5951     {
5952         FT_UInt glyph_code;
5953         FT_ULong char_code;
5954
5955         glyph_code = 0;
5956         char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
5957
5958         TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
5959                font->ft_face->num_glyphs, glyph_code, char_code);
5960
5961         while (glyph_code)
5962         {
5963             /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? "  !" : "" );*/
5964
5965             /* FIXME: This doesn't match what Windows does: it does some fancy
5966              * things with duplicate glyph index to char code mappings, while
5967              * we just avoid overriding existing entries.
5968              */
5969             if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
5970                 glyph_to_char[glyph_code] = (USHORT)char_code;
5971
5972             char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
5973         }
5974     }
5975     else
5976     {
5977         ULONG n;
5978
5979         FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
5980         for (n = 0; n <= 65535; n++)
5981             glyph_to_char[n] = (USHORT)n;
5982     }
5983
5984     tt_kern_table = buf;
5985     nTables = GET_BE_WORD(tt_kern_table->nTables);
5986     TRACE("version %u, nTables %u\n",
5987            GET_BE_WORD(tt_kern_table->version), nTables);
5988
5989     tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
5990
5991     for (i = 0; i < nTables; i++)
5992     {
5993         struct TT_kern_subtable tt_kern_subtable_copy;
5994
5995         tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
5996         tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
5997         tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
5998
5999         TRACE("version %u, length %u, coverage %u, subtable format %u\n",
6000                tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
6001                tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
6002
6003         /* According to the TrueType specification this is the only format
6004          * that will be properly interpreted by Windows and OS/2
6005          */
6006         if (tt_kern_subtable_copy.coverage.bits.format == 0)
6007         {
6008             DWORD new_chunk, old_total = font->total_kern_pairs;
6009
6010             new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
6011                                                     glyph_to_char, NULL, 0);
6012             font->total_kern_pairs += new_chunk;
6013
6014             if (!font->kern_pairs)
6015                 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
6016                                              font->total_kern_pairs * sizeof(*font->kern_pairs));
6017             else
6018                 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
6019                                                font->total_kern_pairs * sizeof(*font->kern_pairs));
6020
6021             parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
6022                         glyph_to_char, font->kern_pairs + old_total, new_chunk);
6023         }
6024         else
6025             TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
6026
6027         tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
6028     }
6029
6030     HeapFree(GetProcessHeap(), 0, glyph_to_char);
6031     HeapFree(GetProcessHeap(), 0, buf);
6032
6033     if (cPairs && kern_pair)
6034     {
6035         cPairs = min(cPairs, font->total_kern_pairs);
6036         memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
6037         LeaveCriticalSection( &freetype_cs );
6038         return cPairs;
6039     }
6040     LeaveCriticalSection( &freetype_cs );
6041     return font->total_kern_pairs;
6042 }
6043
6044 #else /* HAVE_FREETYPE */
6045
6046 /*************************************************************************/
6047
6048 BOOL WineEngInit(void)
6049 {
6050     return FALSE;
6051 }
6052 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
6053 {
6054     return NULL;
6055 }
6056 BOOL WineEngDestroyFontInstance(HFONT hfont)
6057 {
6058     return FALSE;
6059 }
6060
6061 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
6062 {
6063     return 1;
6064 }
6065
6066 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
6067                                 LPWORD pgi, DWORD flags)
6068 {
6069     return GDI_ERROR;
6070 }
6071
6072 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
6073                              LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
6074                              const MAT2* lpmat)
6075 {
6076     ERR("called but we don't have FreeType\n");
6077     return GDI_ERROR;
6078 }
6079
6080 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
6081 {
6082     ERR("called but we don't have FreeType\n");
6083     return FALSE;
6084 }
6085
6086 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
6087                                   OUTLINETEXTMETRICW *potm)
6088 {
6089     ERR("called but we don't have FreeType\n");
6090     return 0;
6091 }
6092
6093 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
6094                          LPINT buffer)
6095 {
6096     ERR("called but we don't have FreeType\n");
6097     return FALSE;
6098 }
6099
6100 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
6101                              LPABC buffer)
6102 {
6103     ERR("called but we don't have FreeType\n");
6104     return FALSE;
6105 }
6106
6107 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
6108                               LPABC buffer)
6109 {
6110     ERR("called but we don't have FreeType\n");
6111     return FALSE;
6112 }
6113
6114 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
6115                                  INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
6116 {
6117     ERR("called but we don't have FreeType\n");
6118     return FALSE;
6119 }
6120
6121 BOOL WineEngGetTextExtentExPointI(GdiFont *font, const WORD *indices, INT count,
6122                                   INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
6123 {
6124     ERR("called but we don't have FreeType\n");
6125     return FALSE;
6126 }
6127
6128 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
6129                          DWORD cbData)
6130 {
6131     ERR("called but we don't have FreeType\n");
6132     return GDI_ERROR;
6133 }
6134
6135 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
6136 {
6137     ERR("called but we don't have FreeType\n");
6138     return 0;
6139 }
6140
6141 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
6142 {
6143     FIXME(":stub\n");
6144     return 1;
6145 }
6146
6147 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
6148 {
6149     FIXME(":stub\n");
6150     return TRUE;
6151 }
6152
6153 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
6154 {
6155     FIXME(":stub\n");
6156     return NULL;
6157 }
6158
6159 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
6160 {
6161     FIXME(":stub\n");
6162     return DEFAULT_CHARSET;
6163 }
6164
6165 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
6166 {
6167     return FALSE;
6168 }
6169
6170 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
6171 {
6172     FIXME("(%p, %p): stub\n", font, glyphset);
6173     return 0;
6174 }
6175
6176 BOOL WineEngFontIsLinked(GdiFont *font)
6177 {
6178     return FALSE;
6179 }
6180
6181 /*************************************************************************
6182  *             GetRasterizerCaps   (GDI32.@)
6183  */
6184 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
6185 {
6186     lprs->nSize = sizeof(RASTERIZER_STATUS);
6187     lprs->wFlags = 0;
6188     lprs->nLanguageID = 0;
6189     return TRUE;
6190 }
6191
6192 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
6193 {
6194     ERR("called but we don't have FreeType\n");
6195     return 0;
6196 }
6197
6198 BOOL WineEngRealizationInfo(GdiFont *font, realization_info_t *info)
6199 {
6200     ERR("called but we don't have FreeType\n");
6201     return FALSE;
6202 }
6203
6204 #endif /* HAVE_FREETYPE */