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         int 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     int 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     EnterCriticalSection( &freetype_cs );
3290
3291     LIST_FOR_EACH_ENTRY(ret, &child_font_list, struct tagGdiFont, entry)
3292     {
3293         struct list *first_hfont = list_head(&ret->hfontlist);
3294         hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
3295         if(hflist->hfont == hfont)
3296         {
3297             LeaveCriticalSection( &freetype_cs );
3298             return ret;
3299         }
3300     }
3301
3302     if (!GetObjectW( hfont, sizeof(lf), &lf ))
3303     {
3304         LeaveCriticalSection( &freetype_cs );
3305         return NULL;
3306     }
3307     lf.lfWidth = abs(lf.lfWidth);
3308
3309     can_use_bitmap = GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_RA_ABLE;
3310
3311     TRACE("%s, h=%d, it=%d, weight=%d, PandF=%02x, charset=%d orient %d escapement %d\n",
3312           debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
3313           lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
3314           lf.lfEscapement);
3315
3316     if(dc->GraphicsMode == GM_ADVANCED)
3317         memcpy(&dcmat, &dc->xformWorld2Vport, sizeof(FMAT2));
3318     else
3319     {
3320         /* Windows 3.1 compatibility mode GM_COMPATIBLE has only limited
3321            font scaling abilities. */
3322         dcmat.eM11 = dcmat.eM22 = fabs(dc->xformWorld2Vport.eM22);
3323         dcmat.eM21 = dcmat.eM12 = 0;
3324     }
3325
3326     TRACE("DC transform %f %f %f %f\n", dcmat.eM11, dcmat.eM12,
3327                                         dcmat.eM21, dcmat.eM22);
3328
3329     /* check the cache first */
3330     if((ret = find_in_cache(hfont, &lf, &dcmat, can_use_bitmap)) != NULL) {
3331         TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
3332         LeaveCriticalSection( &freetype_cs );
3333         return ret;
3334     }
3335
3336     TRACE("not in cache\n");
3337     if(list_empty(&font_list)) /* No fonts installed */
3338     {
3339         TRACE("No fonts installed\n");
3340         LeaveCriticalSection( &freetype_cs );
3341         return NULL;
3342     }
3343     if(!have_installed_roman_font)
3344     {
3345         TRACE("No roman font installed\n");
3346         LeaveCriticalSection( &freetype_cs );
3347         return NULL;
3348     }
3349
3350     ret = alloc_font();
3351
3352     ret->font_desc.matrix = dcmat;
3353     ret->font_desc.lf = lf;
3354     ret->font_desc.can_use_bitmap = can_use_bitmap;
3355     calc_hash(&ret->font_desc);
3356     hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
3357     hflist->hfont = hfont;
3358     list_add_head(&ret->hfontlist, &hflist->entry);
3359
3360     /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
3361        SYMBOL_CHARSET so that Symbol gets picked irrespective of the
3362        original value lfCharSet.  Note this is a special case for
3363        Symbol and doesn't happen at least for "Wingdings*" */
3364
3365     if(!strcmpiW(lf.lfFaceName, SymbolW))
3366         lf.lfCharSet = SYMBOL_CHARSET;
3367
3368     if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
3369         switch(lf.lfCharSet) {
3370         case DEFAULT_CHARSET:
3371             csi.fs.fsCsb[0] = 0;
3372             break;
3373         default:
3374             FIXME("Untranslated charset %d\n", lf.lfCharSet);
3375             csi.fs.fsCsb[0] = 0;
3376             break;
3377         }
3378     }
3379
3380     family = NULL;
3381     if(lf.lfFaceName[0] != '\0') {
3382         SYSTEM_LINKS *font_link;
3383         CHILD_FONT *font_link_entry;
3384         LPWSTR FaceName = lf.lfFaceName;
3385
3386         /*
3387          * Check for a leading '@' this signals that the font is being
3388          * requested in tategaki mode (vertical writing substitution) but
3389          * does not affect the fontface that is to be selected.
3390          */
3391         if (lf.lfFaceName[0]=='@')
3392             FaceName = &lf.lfFaceName[1];
3393
3394         psub = get_font_subst(&font_subst_list, FaceName, lf.lfCharSet);
3395
3396         if(psub) {
3397             TRACE("substituting %s,%d -> %s,%d\n", debugstr_w(FaceName), lf.lfCharSet,
3398                   debugstr_w(psub->to.name), (psub->to.charset != -1) ? psub->to.charset : lf.lfCharSet);
3399             if (psub->to.charset != -1)
3400                 lf.lfCharSet = psub->to.charset;
3401         }
3402
3403         /* We want a match on name and charset or just name if
3404            charset was DEFAULT_CHARSET.  If the latter then
3405            we fixup the returned charset later in get_nearest_charset
3406            where we'll either use the charset of the current ansi codepage
3407            or if that's unavailable the first charset that the font supports.
3408         */
3409         LIST_FOR_EACH(family_elem_ptr, &font_list) {
3410             family = LIST_ENTRY(family_elem_ptr, Family, entry);
3411             if (!strcmpiW(family->FamilyName, FaceName) ||
3412                 (psub && !strcmpiW(family->FamilyName, psub->to.name)))
3413             {
3414                 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3415                     face = LIST_ENTRY(face_elem_ptr, Face, entry);
3416                     if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
3417                         if(face->scalable || can_use_bitmap)
3418                             goto found;
3419                 }
3420             }
3421         }
3422
3423         /*
3424          * Try check the SystemLink list first for a replacement font.
3425          * We may find good replacements there.
3426          */
3427         LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
3428         {
3429             if(!strcmpiW(font_link->font_name, FaceName))
3430             {
3431                 TRACE("found entry in system list\n");
3432                 LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
3433                 {
3434                     face = font_link_entry->face;
3435                     family = face->family;
3436                     if(csi.fs.fsCsb[0] &
3437                         (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]) || !csi.fs.fsCsb[0])
3438                     {
3439                         if(face->scalable || can_use_bitmap)
3440                             goto found;
3441                     }
3442                 }
3443             }
3444         }
3445     }
3446
3447     psub = NULL; /* substitution is no more relevant */
3448
3449     /* If requested charset was DEFAULT_CHARSET then try using charset
3450        corresponding to the current ansi codepage */
3451     if (!csi.fs.fsCsb[0] || lf.lfWeight == FW_DONTCARE)
3452     {
3453         INT acp = GetACP();
3454         if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
3455             FIXME("TCI failed on codepage %d\n", acp);
3456             csi.fs.fsCsb[0] = 0;
3457         } else
3458             lf.lfCharSet = csi.ciCharset;
3459     }
3460
3461     /* Face families are in the top 4 bits of lfPitchAndFamily,
3462        so mask with 0xF0 before testing */
3463
3464     if((lf.lfPitchAndFamily & FIXED_PITCH) ||
3465        (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
3466         strcpyW(lf.lfFaceName, defFixed);
3467     else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
3468         strcpyW(lf.lfFaceName, defSerif);
3469     else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
3470         strcpyW(lf.lfFaceName, defSans);
3471     else
3472         strcpyW(lf.lfFaceName, defSans);
3473     LIST_FOR_EACH(family_elem_ptr, &font_list) {
3474         family = LIST_ENTRY(family_elem_ptr, Family, entry);
3475         if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
3476             LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3477                 face = LIST_ENTRY(face_elem_ptr, Face, entry);
3478                 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
3479                     if(face->scalable || can_use_bitmap)
3480                         goto found;
3481             }
3482         }
3483     }
3484
3485     last_resort_family = NULL;
3486     LIST_FOR_EACH(family_elem_ptr, &font_list) {
3487         family = LIST_ENTRY(family_elem_ptr, Family, entry);
3488         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3489             face = LIST_ENTRY(face_elem_ptr, Face, entry);
3490             if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) {
3491                 if(face->scalable)
3492                     goto found;
3493                 if(can_use_bitmap && !last_resort_family)
3494                     last_resort_family = family;
3495             }
3496         }
3497     }
3498
3499     if(last_resort_family) {
3500         family = last_resort_family;
3501         csi.fs.fsCsb[0] = 0;
3502         goto found;
3503     }
3504
3505     LIST_FOR_EACH(family_elem_ptr, &font_list) {
3506         family = LIST_ENTRY(family_elem_ptr, Family, entry);
3507         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3508             face = LIST_ENTRY(face_elem_ptr, Face, entry);
3509             if(face->scalable) {
3510                 csi.fs.fsCsb[0] = 0;
3511                 WARN("just using first face for now\n");
3512                 goto found;
3513             }
3514             if(can_use_bitmap && !last_resort_family)
3515                 last_resort_family = family;
3516         }
3517     }
3518     if(!last_resort_family) {
3519         FIXME("can't find a single appropriate font - bailing\n");
3520         free_font(ret);
3521         LeaveCriticalSection( &freetype_cs );
3522         return NULL;
3523     }
3524
3525     WARN("could only find a bitmap font - this will probably look awful!\n");
3526     family = last_resort_family;
3527     csi.fs.fsCsb[0] = 0;
3528
3529 found:
3530     it = lf.lfItalic ? 1 : 0;
3531     bd = lf.lfWeight > 550 ? 1 : 0;
3532
3533     height = lf.lfHeight;
3534
3535     face = best = best_bitmap = NULL;
3536     LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
3537     {
3538         if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
3539         {
3540             BOOL italic, bold;
3541
3542             italic = (face->ntmFlags & NTM_ITALIC) ? 1 : 0;
3543             bold = (face->ntmFlags & NTM_BOLD) ? 1 : 0;
3544             new_score = (italic ^ it) + (bold ^ bd);
3545             if(!best || new_score <= score)
3546             {
3547                 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
3548                       italic, bold, it, bd);
3549                 score = new_score;
3550                 best = face;
3551                 if(best->scalable  && score == 0) break;
3552                 if(!best->scalable)
3553                 {
3554                     if(height > 0)
3555                         newdiff = height - (signed int)(best->size.height);
3556                     else
3557                         newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
3558                     if(!best_bitmap || new_score < score ||
3559                        (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
3560                     {
3561                         TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
3562                         diff = newdiff;
3563                         best_bitmap = best;
3564                         if(score == 0 && diff == 0) break;
3565                     }
3566                 }
3567             }
3568         }
3569     }
3570     if(best)
3571         face = best->scalable ? best : best_bitmap;
3572     ret->fake_italic = (it && !(face->ntmFlags & NTM_ITALIC));
3573     ret->fake_bold = (bd && !(face->ntmFlags & NTM_BOLD));
3574
3575     ret->fs = face->fs;
3576
3577     if(csi.fs.fsCsb[0]) {
3578         ret->charset = lf.lfCharSet;
3579         ret->codepage = csi.ciACP;
3580     }
3581     else
3582         ret->charset = get_nearest_charset(face, &ret->codepage);
3583
3584     TRACE("Chosen: %s %s (%s/%p:%ld)\n", debugstr_w(family->FamilyName),
3585           debugstr_w(face->StyleName), face->file, face->font_data_ptr, face->face_index);
3586
3587     ret->aveWidth = height ? lf.lfWidth : 0;
3588
3589     if(!face->scalable) {
3590         /* Windows uses integer scaling factors for bitmap fonts */
3591         INT scale, scaled_height;
3592
3593         /* FIXME: rotation of bitmap fonts is ignored */
3594         height = abs(GDI_ROUND( (double)height * ret->font_desc.matrix.eM22 ));
3595         if (ret->aveWidth)
3596             ret->aveWidth = (double)ret->aveWidth * ret->font_desc.matrix.eM11;
3597         ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
3598
3599         if (height != 0) height = diff;
3600         height += face->size.height;
3601
3602         scale = (height + face->size.height - 1) / face->size.height;
3603         scaled_height = scale * face->size.height;
3604         /* XP allows not more than 10% deviation */
3605         if (scale > 1 && scaled_height - height > scaled_height / 10) scale--;
3606         ret->scale_y = scale;
3607
3608         width = face->size.x_ppem >> 6;
3609         height = face->size.y_ppem >> 6;
3610     }
3611     else
3612         ret->scale_y = 1.0;
3613     TRACE("font scale y: %f\n", ret->scale_y);
3614
3615     ret->ft_face = OpenFontFace(ret, face, width, height);
3616
3617     if (!ret->ft_face)
3618     {
3619         free_font( ret );
3620         LeaveCriticalSection( &freetype_cs );
3621         return 0;
3622     }
3623
3624     ret->ntmFlags = face->ntmFlags;
3625
3626     if (ret->charset == SYMBOL_CHARSET &&
3627         select_charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
3628         /* No ops */
3629     }
3630     else if (select_charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
3631         /* No ops */
3632     }
3633     else {
3634         select_charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
3635     }
3636
3637     ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
3638     ret->name = psub ? strdupW(psub->from.name) : strdupW(family->FamilyName);
3639     ret->underline = lf.lfUnderline ? 0xff : 0;
3640     ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
3641     create_child_font_list(ret);
3642
3643     if (lf.lfFaceName[0]=='@') /* We need to try to load the GSUB table */
3644     {
3645         int length = WineEngGetFontData (ret, GSUB_TAG , 0, NULL, 0);
3646         if (length != GDI_ERROR)
3647         {
3648             ret->GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
3649             WineEngGetFontData(ret, GSUB_TAG , 0, ret->GSUB_Table, length);
3650             TRACE("Loaded GSUB table of %i bytes\n",length);
3651         }
3652     }
3653
3654     TRACE("caching: gdiFont=%p  hfont=%p\n", ret, hfont);
3655
3656     add_to_cache(ret);
3657     LeaveCriticalSection( &freetype_cs );
3658     return ret;
3659 }
3660
3661 static void dump_gdi_font_list(void)
3662 {
3663     GdiFont *gdiFont;
3664     struct list *elem_ptr;
3665
3666     TRACE("---------- gdiFont Cache ----------\n");
3667     LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
3668         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
3669         TRACE("gdiFont=%p %s %d\n",
3670               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
3671     }
3672
3673     TRACE("---------- Unused gdiFont Cache ----------\n");
3674     LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
3675         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
3676         TRACE("gdiFont=%p %s %d\n",
3677               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
3678     }
3679 }
3680
3681 /*************************************************************
3682  * WineEngDestroyFontInstance
3683  *
3684  * free the gdiFont associated with this handle
3685  *
3686  */
3687 BOOL WineEngDestroyFontInstance(HFONT handle)
3688 {
3689     GdiFont *gdiFont;
3690     HFONTLIST *hflist;
3691     BOOL ret = FALSE;
3692     struct list *font_elem_ptr, *hfontlist_elem_ptr;
3693     int i = 0;
3694
3695     EnterCriticalSection( &freetype_cs );
3696
3697     LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
3698     {
3699         struct list *first_hfont = list_head(&gdiFont->hfontlist);
3700         hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
3701         if(hflist->hfont == handle)
3702         {
3703             TRACE("removing child font %p from child list\n", gdiFont);
3704             list_remove(&gdiFont->entry);
3705             LeaveCriticalSection( &freetype_cs );
3706             return TRUE;
3707         }
3708     }
3709
3710     TRACE("destroying hfont=%p\n", handle);
3711     if(TRACE_ON(font))
3712         dump_gdi_font_list();
3713
3714     font_elem_ptr = list_head(&gdi_font_list);
3715     while(font_elem_ptr) {
3716         gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3717         font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
3718
3719         hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
3720         while(hfontlist_elem_ptr) {
3721             hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
3722             hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
3723             if(hflist->hfont == handle) {
3724                 list_remove(&hflist->entry);
3725                 HeapFree(GetProcessHeap(), 0, hflist);
3726                 ret = TRUE;
3727             }
3728         }
3729         if(list_empty(&gdiFont->hfontlist)) {
3730             TRACE("Moving to Unused list\n");
3731             list_remove(&gdiFont->entry);
3732             list_add_head(&unused_gdi_font_list, &gdiFont->entry);
3733         }
3734     }
3735
3736
3737     font_elem_ptr = list_head(&unused_gdi_font_list);
3738     while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
3739         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3740     while(font_elem_ptr) {
3741         gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
3742         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
3743         TRACE("freeing %p\n", gdiFont);
3744         list_remove(&gdiFont->entry);
3745         free_font(gdiFont);
3746     }
3747     LeaveCriticalSection( &freetype_cs );
3748     return ret;
3749 }
3750
3751 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
3752                            NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
3753 {
3754     GdiFont *font;
3755     LONG width, height;
3756
3757     if (face->cached_enum_data)
3758     {
3759         TRACE("Cached\n");
3760         *pelf = face->cached_enum_data->elf;
3761         *pntm = face->cached_enum_data->ntm;
3762         *ptype = face->cached_enum_data->type;
3763         return;
3764     }
3765
3766     font = alloc_font();
3767
3768     if(face->scalable) {
3769         height = -2048; /* 2048 is the most common em size */
3770         width = 0;
3771     } else {
3772         height = face->size.y_ppem >> 6;
3773         width = face->size.x_ppem >> 6;
3774     }
3775     font->scale_y = 1.0;
3776
3777     if (!(font->ft_face = OpenFontFace(font, face, width, height)))
3778     {
3779         free_font(font);
3780         return;
3781     }
3782
3783     font->name = strdupW(face->family->FamilyName);
3784     font->ntmFlags = face->ntmFlags;
3785
3786     if (WineEngGetOutlineTextMetrics(font, 0, NULL))
3787     {
3788         memcpy(&pntm->ntmTm, &font->potm->otmTextMetrics, sizeof(TEXTMETRICW));
3789
3790         pntm->ntmTm.ntmSizeEM = font->potm->otmEMSquare;
3791
3792         lstrcpynW(pelf->elfLogFont.lfFaceName,
3793                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFamilyName),
3794                  LF_FACESIZE);
3795         lstrcpynW(pelf->elfFullName,
3796                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpFaceName),
3797                  LF_FULLFACESIZE);
3798         lstrcpynW(pelf->elfStyle,
3799                  (WCHAR*)((char*)font->potm + (ULONG_PTR)font->potm->otmpStyleName),
3800                  LF_FACESIZE);
3801     }
3802     else
3803     {
3804         WineEngGetTextMetrics(font, (TEXTMETRICW *)&pntm->ntmTm);
3805
3806         pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
3807
3808         lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
3809         lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FULLFACESIZE);
3810         lstrcpynW(pelf->elfStyle, face->StyleName, LF_FACESIZE);
3811     }
3812
3813     pntm->ntmTm.ntmFlags = face->ntmFlags;
3814     pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
3815     pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
3816     pntm->ntmFontSig = face->fs;
3817
3818     pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
3819
3820     pelf->elfLogFont.lfEscapement = 0;
3821     pelf->elfLogFont.lfOrientation = 0;
3822     pelf->elfLogFont.lfHeight = pntm->ntmTm.tmHeight;
3823     pelf->elfLogFont.lfWidth = pntm->ntmTm.tmAveCharWidth;
3824     pelf->elfLogFont.lfWeight = pntm->ntmTm.tmWeight;
3825     pelf->elfLogFont.lfItalic = pntm->ntmTm.tmItalic;
3826     pelf->elfLogFont.lfUnderline = pntm->ntmTm.tmUnderlined;
3827     pelf->elfLogFont.lfStrikeOut = pntm->ntmTm.tmStruckOut;
3828     pelf->elfLogFont.lfCharSet = pntm->ntmTm.tmCharSet;
3829     pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
3830     pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
3831     pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
3832     pelf->elfLogFont.lfPitchAndFamily = (pntm->ntmTm.tmPitchAndFamily & 0xf1) + 1;
3833
3834     *ptype = 0;
3835     if (pntm->ntmTm.tmPitchAndFamily & TMPF_TRUETYPE)
3836         *ptype |= TRUETYPE_FONTTYPE;
3837     if (pntm->ntmTm.tmPitchAndFamily & TMPF_DEVICE)
3838         *ptype |= DEVICE_FONTTYPE;
3839     if(!(pntm->ntmTm.tmPitchAndFamily & TMPF_VECTOR))
3840         *ptype |= RASTER_FONTTYPE;
3841
3842     face->cached_enum_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*face->cached_enum_data));
3843     if (face->cached_enum_data)
3844     {
3845         face->cached_enum_data->elf = *pelf;
3846         face->cached_enum_data->ntm = *pntm;
3847         face->cached_enum_data->type = *ptype;
3848     }
3849
3850     free_font(font);
3851 }
3852
3853 /*************************************************************
3854  * WineEngEnumFonts
3855  *
3856  */
3857 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
3858 {
3859     Family *family;
3860     Face *face;
3861     struct list *family_elem_ptr, *face_elem_ptr;
3862     ENUMLOGFONTEXW elf;
3863     NEWTEXTMETRICEXW ntm;
3864     DWORD type;
3865     FONTSIGNATURE fs;
3866     CHARSETINFO csi;
3867     LOGFONTW lf;
3868     int i;
3869
3870     if (!plf)
3871     {
3872         lf.lfCharSet = DEFAULT_CHARSET;
3873         lf.lfPitchAndFamily = 0;
3874         lf.lfFaceName[0] = 0;
3875         plf = &lf;
3876     }
3877
3878     TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
3879
3880     EnterCriticalSection( &freetype_cs );
3881     if(plf->lfFaceName[0]) {
3882         FontSubst *psub;
3883         psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
3884
3885         if(psub) {
3886             TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
3887                   debugstr_w(psub->to.name));
3888             lf = *plf;
3889             strcpyW(lf.lfFaceName, psub->to.name);
3890             plf = &lf;
3891         }
3892
3893         LIST_FOR_EACH(family_elem_ptr, &font_list) {
3894             family = LIST_ENTRY(family_elem_ptr, Family, entry);
3895             if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
3896                 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
3897                     face = LIST_ENTRY(face_elem_ptr, Face, entry);
3898                     GetEnumStructs(face, &elf, &ntm, &type);
3899                     for(i = 0; i < 32; i++) {
3900                         if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3901                             elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3902                             strcpyW(elf.elfScript, OEM_DOSW);
3903                             i = 32; /* break out of loop */
3904                         } else if(!(face->fs.fsCsb[0] & (1L << i)))
3905                             continue;
3906                         else {
3907                             fs.fsCsb[0] = 1L << i;
3908                             fs.fsCsb[1] = 0;
3909                             if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3910                                                      TCI_SRCFONTSIG))
3911                                 csi.ciCharset = DEFAULT_CHARSET;
3912                             if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3913                             if(csi.ciCharset != DEFAULT_CHARSET) {
3914                                 elf.elfLogFont.lfCharSet =
3915                                     ntm.ntmTm.tmCharSet = csi.ciCharset;
3916                                 if(ElfScriptsW[i])
3917                                     strcpyW(elf.elfScript, ElfScriptsW[i]);
3918                                 else
3919                                     FIXME("Unknown elfscript for bit %d\n", i);
3920                             }
3921                         }
3922                         TRACE("enuming face %s full %s style %s charset %d type %d script %s it %d weight %d ntmflags %08x\n",
3923                               debugstr_w(elf.elfLogFont.lfFaceName),
3924                               debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3925                               csi.ciCharset, type, debugstr_w(elf.elfScript),
3926                               elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3927                               ntm.ntmTm.ntmFlags);
3928                         /* release section before callback (FIXME) */
3929                         LeaveCriticalSection( &freetype_cs );
3930                         if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return 0;
3931                         EnterCriticalSection( &freetype_cs );
3932                     }
3933                 }
3934             }
3935         }
3936     } else {
3937         LIST_FOR_EACH(family_elem_ptr, &font_list) {
3938             family = LIST_ENTRY(family_elem_ptr, Family, entry);
3939             face_elem_ptr = list_head(&family->faces);
3940             face = LIST_ENTRY(face_elem_ptr, Face, entry);
3941             GetEnumStructs(face, &elf, &ntm, &type);
3942             for(i = 0; i < 32; i++) {
3943                 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
3944                     elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
3945                     strcpyW(elf.elfScript, OEM_DOSW);
3946                     i = 32; /* break out of loop */
3947                 } else if(!(face->fs.fsCsb[0] & (1L << i)))
3948                     continue;
3949                 else {
3950                     fs.fsCsb[0] = 1L << i;
3951                     fs.fsCsb[1] = 0;
3952                     if(!TranslateCharsetInfo(fs.fsCsb, &csi,
3953                                              TCI_SRCFONTSIG))
3954                         csi.ciCharset = DEFAULT_CHARSET;
3955                     if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
3956                     if(csi.ciCharset != DEFAULT_CHARSET) {
3957                         elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet =
3958                           csi.ciCharset;
3959                           if(ElfScriptsW[i])
3960                               strcpyW(elf.elfScript, ElfScriptsW[i]);
3961                           else
3962                               FIXME("Unknown elfscript for bit %d\n", i);
3963                     }
3964                 }
3965                 TRACE("enuming face %s full %s style %s charset = %d type %d script %s it %d weight %d ntmflags %08x\n",
3966                       debugstr_w(elf.elfLogFont.lfFaceName),
3967                       debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
3968                       csi.ciCharset, type, debugstr_w(elf.elfScript),
3969                       elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
3970                       ntm.ntmTm.ntmFlags);
3971                 /* release section before callback (FIXME) */
3972                 LeaveCriticalSection( &freetype_cs );
3973                 if (!proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam)) return 0;
3974                 EnterCriticalSection( &freetype_cs );
3975             }
3976         }
3977     }
3978     LeaveCriticalSection( &freetype_cs );
3979     return 1;
3980 }
3981
3982 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
3983 {
3984     pt->x.value = vec->x >> 6;
3985     pt->x.fract = (vec->x & 0x3f) << 10;
3986     pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
3987     pt->y.value = vec->y >> 6;
3988     pt->y.fract = (vec->y & 0x3f) << 10;
3989     pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
3990     return;
3991 }
3992
3993 /***************************************************
3994  * According to the MSDN documentation on WideCharToMultiByte,
3995  * certain codepages cannot set the default_used parameter.
3996  * This returns TRUE if the codepage can set that parameter, false else
3997  * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
3998  */
3999 static BOOL codepage_sets_default_used(UINT codepage)
4000 {
4001    switch (codepage)
4002    {
4003        case CP_UTF7:
4004        case CP_UTF8:
4005        case CP_SYMBOL:
4006            return FALSE;
4007        default:
4008            return TRUE;
4009    }
4010 }
4011
4012 /*
4013  * GSUB Table handling functions
4014  */
4015
4016 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
4017 {
4018     const GSUB_CoverageFormat1* cf1;
4019
4020     cf1 = (GSUB_CoverageFormat1*)table;
4021
4022     if (GET_BE_WORD(cf1->CoverageFormat) == 1)
4023     {
4024         int count = GET_BE_WORD(cf1->GlyphCount);
4025         int i;
4026         TRACE("Coverage Format 1, %i glyphs\n",count);
4027         for (i = 0; i < count; i++)
4028             if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
4029                 return i;
4030         return -1;
4031     }
4032     else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
4033     {
4034         const GSUB_CoverageFormat2* cf2;
4035         int i;
4036         int count;
4037         cf2 = (GSUB_CoverageFormat2*)cf1;
4038
4039         count = GET_BE_WORD(cf2->RangeCount);
4040         TRACE("Coverage Format 2, %i ranges\n",count);
4041         for (i = 0; i < count; i++)
4042         {
4043             if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
4044                 return -1;
4045             if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
4046                 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
4047             {
4048                 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
4049                     glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
4050             }
4051         }
4052         return -1;
4053     }
4054     else
4055         ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
4056
4057     return -1;
4058 }
4059
4060 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
4061 {
4062     const GSUB_ScriptList *script;
4063     const GSUB_Script *deflt = NULL;
4064     int i;
4065     script = (GSUB_ScriptList*)((LPBYTE)header + GET_BE_WORD(header->ScriptList));
4066
4067     TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
4068     for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
4069     {
4070         const GSUB_Script *scr;
4071         int offset;
4072
4073         offset = GET_BE_WORD(script->ScriptRecord[i].Script);
4074         scr = (GSUB_Script*)((LPBYTE)script + offset);
4075
4076         if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
4077             return scr;
4078         if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
4079             deflt = scr;
4080     }
4081     return deflt;
4082 }
4083
4084 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
4085 {
4086     int i;
4087     int offset;
4088     const GSUB_LangSys *Lang;
4089
4090     TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
4091
4092     for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
4093     {
4094         offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
4095         Lang = (GSUB_LangSys*)((LPBYTE)script + offset);
4096
4097         if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
4098             return Lang;
4099     }
4100     offset = GET_BE_WORD(script->DefaultLangSys);
4101     if (offset)
4102     {
4103         Lang = (GSUB_LangSys*)((LPBYTE)script + offset);
4104         return Lang;
4105     }
4106     return NULL;
4107 }
4108
4109 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
4110 {
4111     int i;
4112     const GSUB_FeatureList *feature;
4113     feature = (GSUB_FeatureList*)((LPBYTE)header + GET_BE_WORD(header->FeatureList));
4114
4115     TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
4116     for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
4117     {
4118         int index = GET_BE_WORD(lang->FeatureIndex[i]);
4119         if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
4120         {
4121             const GSUB_Feature *feat;
4122             feat = (GSUB_Feature*)((LPBYTE)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
4123             return feat;
4124         }
4125     }
4126     return NULL;
4127 }
4128
4129 static FT_UInt GSUB_apply_feature(const GSUB_Header * header, const GSUB_Feature* feature, UINT glyph)
4130 {
4131     int i;
4132     int offset;
4133     const GSUB_LookupList *lookup;
4134     lookup = (GSUB_LookupList*)((LPBYTE)header + GET_BE_WORD(header->LookupList));
4135
4136     TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
4137     for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
4138     {
4139         const GSUB_LookupTable *look;
4140         offset = GET_BE_WORD(lookup->Lookup[GET_BE_WORD(feature->LookupListIndex[i])]);
4141         look = (GSUB_LookupTable*)((LPBYTE)lookup + offset);
4142         TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
4143         if (GET_BE_WORD(look->LookupType) != 1)
4144             FIXME("We only handle SubType 1\n");
4145         else
4146         {
4147             int j;
4148
4149             for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
4150             {
4151                 const GSUB_SingleSubstFormat1 *ssf1;
4152                 offset = GET_BE_WORD(look->SubTable[j]);
4153                 ssf1 = (GSUB_SingleSubstFormat1*)((LPBYTE)look+offset);
4154                 if (GET_BE_WORD(ssf1->SubstFormat) == 1)
4155                 {
4156                     int offset = GET_BE_WORD(ssf1->Coverage);
4157                     TRACE("  subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
4158                     if (GSUB_is_glyph_covered((LPBYTE)ssf1+offset, glyph) != -1)
4159                     {
4160                         TRACE("  Glyph 0x%x ->",glyph);
4161                         glyph += GET_BE_WORD(ssf1->DeltaGlyphID);
4162                         TRACE(" 0x%x\n",glyph);
4163                     }
4164                 }
4165                 else
4166                 {
4167                     const GSUB_SingleSubstFormat2 *ssf2;
4168                     INT index;
4169                     INT offset;
4170
4171                     ssf2 = (GSUB_SingleSubstFormat2 *)ssf1;
4172                     offset = GET_BE_WORD(ssf1->Coverage);
4173                     TRACE("  subtype 2,  glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
4174                     index = GSUB_is_glyph_covered((LPBYTE)ssf2+offset, glyph);
4175                     TRACE("  Coverage index %i\n",index);
4176                     if (index != -1)
4177                     {
4178                         TRACE("    Glyph is 0x%x ->",glyph);
4179                         glyph = GET_BE_WORD(ssf2->Substitute[index]);
4180                         TRACE("0x%x\n",glyph);
4181                     }
4182                 }
4183             }
4184         }
4185     }
4186     return glyph;
4187 }
4188
4189 static const char* get_opentype_script(const GdiFont *font)
4190 {
4191     /*
4192      * I am not sure if this is the correct way to generate our script tag
4193      */
4194
4195     switch (font->charset)
4196     {
4197         case ANSI_CHARSET: return "latn";
4198         case BALTIC_CHARSET: return "latn"; /* ?? */
4199         case CHINESEBIG5_CHARSET: return "hani";
4200         case EASTEUROPE_CHARSET: return "latn"; /* ?? */
4201         case GB2312_CHARSET: return "hani";
4202         case GREEK_CHARSET: return "grek";
4203         case HANGUL_CHARSET: return "hang";
4204         case RUSSIAN_CHARSET: return "cyrl";
4205         case SHIFTJIS_CHARSET: return "kana";
4206         case TURKISH_CHARSET: return "latn"; /* ?? */
4207         case VIETNAMESE_CHARSET: return "latn";
4208         case JOHAB_CHARSET: return "latn"; /* ?? */
4209         case ARABIC_CHARSET: return "arab";
4210         case HEBREW_CHARSET: return "hebr";
4211         case THAI_CHARSET: return "thai";
4212         default: return "latn";
4213     }
4214 }
4215
4216 static FT_UInt get_GSUB_vert_glyph(const GdiFont *font, UINT glyph)
4217 {
4218     const GSUB_Header *header;
4219     const GSUB_Script *script;
4220     const GSUB_LangSys *language;
4221     const GSUB_Feature *feature;
4222
4223     if (!font->GSUB_Table)
4224         return glyph;
4225
4226     header = font->GSUB_Table;
4227
4228     script = GSUB_get_script_table(header, get_opentype_script(font));
4229     if (!script)
4230     {
4231         TRACE("Script not found\n");
4232         return glyph;
4233     }
4234     language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
4235     if (!language)
4236     {
4237         TRACE("Language not found\n");
4238         return glyph;
4239     }
4240     feature  =  GSUB_get_feature(header, language, "vrt2");
4241     if (!feature)
4242         feature  =  GSUB_get_feature(header, language, "vert");
4243     if (!feature)
4244     {
4245         TRACE("vrt2/vert feature not found\n");
4246         return glyph;
4247     }
4248     return GSUB_apply_feature(header, feature, glyph);
4249 }
4250
4251 static FT_UInt get_glyph_index(const GdiFont *font, UINT glyph)
4252 {
4253     FT_UInt glyphId;
4254
4255     if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
4256         WCHAR wc = (WCHAR)glyph;
4257         BOOL default_used;
4258         BOOL *default_used_pointer;
4259         FT_UInt ret;
4260         char buf;
4261         default_used_pointer = NULL;
4262         default_used = FALSE;
4263         if (codepage_sets_default_used(font->codepage))
4264             default_used_pointer = &default_used;
4265         if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
4266             ret = 0;
4267         else
4268             ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
4269         TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
4270         return get_GSUB_vert_glyph(font,ret);
4271     }
4272
4273     if(font->ft_face->charmap->encoding == FT_ENCODING_MS_SYMBOL && glyph < 0x100)
4274         glyph = glyph + 0xf000;
4275     glyphId = pFT_Get_Char_Index(font->ft_face, glyph);
4276     return get_GSUB_vert_glyph(font,glyphId);
4277 }
4278
4279 /*************************************************************
4280  * WineEngGetGlyphIndices
4281  *
4282  */
4283 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
4284                                 LPWORD pgi, DWORD flags)
4285 {
4286     int i;
4287     int default_char = -1;
4288
4289     if  (flags & GGI_MARK_NONEXISTING_GLYPHS) default_char = 0xffff;  /* XP would use 0x1f for bitmap fonts */
4290
4291     for(i = 0; i < count; i++)
4292     {
4293         pgi[i] = get_glyph_index(font, lpstr[i]);
4294         if  (pgi[i] == 0)
4295         {
4296             if (default_char == -1)
4297             {
4298                 if (FT_IS_SFNT(font->ft_face))
4299                 {
4300                     TT_OS2 *pOS2 = pFT_Get_Sfnt_Table(font->ft_face, ft_sfnt_os2);
4301                     default_char = (pOS2->usDefaultChar ? get_glyph_index(font, pOS2->usDefaultChar) : 0);
4302                 }
4303                 else
4304                 {
4305                     TEXTMETRICW textm;
4306                     WineEngGetTextMetrics(font, &textm);
4307                     default_char = textm.tmDefaultChar;
4308                 }
4309             }
4310             pgi[i] = default_char;
4311         }
4312     }
4313     return count;
4314 }
4315
4316 static inline BOOL is_identity_FMAT2(const FMAT2 *matrix)
4317 {
4318     static const FMAT2 identity = { 1.0, 0.0, 0.0, 1.0 };
4319     return !memcmp(matrix, &identity, sizeof(FMAT2));
4320 }
4321
4322 static inline BOOL is_identity_MAT2(const MAT2 *matrix)
4323 {
4324     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
4325     return !memcmp(matrix, &identity, sizeof(MAT2));
4326 }
4327
4328 /*************************************************************
4329  * WineEngGetGlyphOutline
4330  *
4331  * Behaves in exactly the same way as the win32 api GetGlyphOutline
4332  * except that the first parameter is the HWINEENGFONT of the font in
4333  * question rather than an HDC.
4334  *
4335  */
4336 DWORD WineEngGetGlyphOutline(GdiFont *incoming_font, UINT glyph, UINT format,
4337                              LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
4338                              const MAT2* lpmat)
4339 {
4340     static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
4341     FT_Face ft_face = incoming_font->ft_face;
4342     GdiFont *font = incoming_font;
4343     FT_UInt glyph_index;
4344     DWORD width, height, pitch, needed = 0;
4345     FT_Bitmap ft_bitmap;
4346     FT_Error err;
4347     INT left, right, top = 0, bottom = 0, adv, lsb, bbx;
4348     FT_Angle angle = 0;
4349     FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
4350     double widthRatio = 1.0;
4351     FT_Matrix transMat = identityMat;
4352     FT_Matrix transMatUnrotated;
4353     BOOL needsTransform = FALSE;
4354     BOOL tategaki = (font->GSUB_Table != NULL);
4355     UINT original_index;
4356
4357     TRACE("%p, %04x, %08x, %p, %08x, %p, %p\n", font, glyph, format, lpgm,
4358           buflen, buf, lpmat);
4359
4360     TRACE("font transform %f %f %f %f\n",
4361           font->font_desc.matrix.eM11, font->font_desc.matrix.eM12,
4362           font->font_desc.matrix.eM21, font->font_desc.matrix.eM22);
4363
4364     EnterCriticalSection( &freetype_cs );
4365
4366     if(format & GGO_GLYPH_INDEX) {
4367         glyph_index = get_GSUB_vert_glyph(incoming_font,glyph);
4368         original_index = glyph;
4369         format &= ~GGO_GLYPH_INDEX;
4370     } else {
4371         get_glyph_index_linked(incoming_font, glyph, &font, &glyph_index);
4372         ft_face = font->ft_face;
4373         original_index = glyph_index;
4374     }
4375
4376     /* tategaki never appears to happen to lower glyph index */
4377     if (glyph_index < TATEGAKI_LOWER_BOUND )
4378         tategaki = FALSE;
4379
4380     if(original_index >= font->gmsize * GM_BLOCK_SIZE) {
4381         font->gmsize = (original_index / GM_BLOCK_SIZE + 1);
4382         font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
4383                                font->gmsize * sizeof(GM*));
4384     } else {
4385         if (format == GGO_METRICS && font->gm[original_index / GM_BLOCK_SIZE] != NULL &&
4386             FONT_GM(font,original_index)->init && (!lpmat || is_identity_MAT2(lpmat)))
4387         {
4388             *lpgm = FONT_GM(font,original_index)->gm;
4389             TRACE("cached: %u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
4390                   wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
4391                   lpgm->gmCellIncX, lpgm->gmCellIncY);
4392             LeaveCriticalSection( &freetype_cs );
4393             return 1; /* FIXME */
4394         }
4395     }
4396
4397     if (!font->gm[original_index / GM_BLOCK_SIZE])
4398         font->gm[original_index / GM_BLOCK_SIZE] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(GM) * GM_BLOCK_SIZE);
4399
4400     /* Scaling factor */
4401     if (font->aveWidth)
4402     {
4403         TEXTMETRICW tm;
4404
4405         WineEngGetTextMetrics(font, &tm);
4406
4407         widthRatio = (double)font->aveWidth;
4408         widthRatio /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
4409     }
4410     else
4411         widthRatio = font->scale_y;
4412
4413     /* Scaling transform */
4414     if (widthRatio != 1.0 || font->scale_y != 1.0)
4415     {
4416         FT_Matrix scaleMat;
4417         scaleMat.xx = FT_FixedFromFloat(widthRatio);
4418         scaleMat.xy = 0;
4419         scaleMat.yx = 0;
4420         scaleMat.yy = FT_FixedFromFloat(font->scale_y);
4421
4422         pFT_Matrix_Multiply(&scaleMat, &transMat);
4423         needsTransform = TRUE;
4424     }
4425
4426     /* Slant transform */
4427     if (font->fake_italic) {
4428         FT_Matrix slantMat;
4429
4430         slantMat.xx = (1 << 16);
4431         slantMat.xy = ((1 << 16) >> 2);
4432         slantMat.yx = 0;
4433         slantMat.yy = (1 << 16);
4434         pFT_Matrix_Multiply(&slantMat, &transMat);
4435         needsTransform = TRUE;
4436     }
4437
4438     /* Rotation transform */
4439     transMatUnrotated = transMat;
4440     if(font->orientation && !tategaki) {
4441         FT_Matrix rotationMat;
4442         FT_Vector vecAngle;
4443         angle = FT_FixedFromFloat((double)font->orientation / 10.0);
4444         pFT_Vector_Unit(&vecAngle, angle);
4445         rotationMat.xx = vecAngle.x;
4446         rotationMat.xy = -vecAngle.y;
4447         rotationMat.yx = -rotationMat.xy;
4448         rotationMat.yy = rotationMat.xx;
4449
4450         pFT_Matrix_Multiply(&rotationMat, &transMat);
4451         needsTransform = TRUE;
4452     }
4453
4454     /* World transform */
4455     if (!is_identity_FMAT2(&font->font_desc.matrix))
4456     {
4457         FT_Matrix worldMat;
4458         worldMat.xx = FT_FixedFromFloat(font->font_desc.matrix.eM11);
4459         worldMat.xy = FT_FixedFromFloat(font->font_desc.matrix.eM21);
4460         worldMat.yx = FT_FixedFromFloat(font->font_desc.matrix.eM12);
4461         worldMat.yy = FT_FixedFromFloat(font->font_desc.matrix.eM22);
4462         pFT_Matrix_Multiply(&worldMat, &transMat);
4463         pFT_Matrix_Multiply(&worldMat, &transMatUnrotated);
4464         needsTransform = TRUE;
4465     }
4466
4467     /* Extra transformation specified by caller */
4468     if (lpmat && !is_identity_MAT2(lpmat))
4469     {
4470         FT_Matrix extraMat;
4471         extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
4472         extraMat.xy = FT_FixedFromFIXED(lpmat->eM21);
4473         extraMat.yx = FT_FixedFromFIXED(lpmat->eM12);
4474         extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
4475         pFT_Matrix_Multiply(&extraMat, &transMat);
4476         pFT_Matrix_Multiply(&extraMat, &transMatUnrotated);
4477         needsTransform = TRUE;
4478     }
4479
4480     if (needsTransform || (format != GGO_METRICS && format != GGO_BITMAP && format != WINE_GGO_GRAY16_BITMAP))
4481         load_flags |= FT_LOAD_NO_BITMAP;
4482
4483     err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
4484
4485     if(err) {
4486         WARN("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
4487         LeaveCriticalSection( &freetype_cs );
4488         return GDI_ERROR;
4489     }
4490
4491     left = (INT)(ft_face->glyph->metrics.horiBearingX) & -64;
4492     right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) + 63) & -64;
4493
4494     adv = (INT)((ft_face->glyph->metrics.horiAdvance) + 63) >> 6;
4495     lsb = left >> 6;
4496     bbx = (right - left) >> 6;
4497
4498     if(!needsTransform) {
4499         top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
4500         bottom = (ft_face->glyph->metrics.horiBearingY -
4501                   ft_face->glyph->metrics.height) & -64;
4502         lpgm->gmCellIncX = adv;
4503         lpgm->gmCellIncY = 0;
4504     } else {
4505         INT xc, yc;
4506         FT_Vector vec;
4507         for(xc = 0; xc < 2; xc++) {
4508             for(yc = 0; yc < 2; yc++) {
4509                 vec.x = (ft_face->glyph->metrics.horiBearingX +
4510                   xc * ft_face->glyph->metrics.width);
4511                 vec.y = ft_face->glyph->metrics.horiBearingY -
4512                   yc * ft_face->glyph->metrics.height;
4513                 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
4514                 pFT_Vector_Transform(&vec, &transMat);
4515                 if(xc == 0 && yc == 0) {
4516                     left = right = vec.x;
4517                     top = bottom = vec.y;
4518                 } else {
4519                     if(vec.x < left) left = vec.x;
4520                     else if(vec.x > right) right = vec.x;
4521                     if(vec.y < bottom) bottom = vec.y;
4522                     else if(vec.y > top) top = vec.y;
4523                 }
4524             }
4525         }
4526         left = left & -64;
4527         right = (right + 63) & -64;
4528         bottom = bottom & -64;
4529         top = (top + 63) & -64;
4530
4531         TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
4532         vec.x = ft_face->glyph->metrics.horiAdvance;
4533         vec.y = 0;
4534         pFT_Vector_Transform(&vec, &transMat);
4535         lpgm->gmCellIncX = (vec.x+63) >> 6;
4536         lpgm->gmCellIncY = -((vec.y+63) >> 6);
4537
4538         vec.x = ft_face->glyph->metrics.horiAdvance;
4539         vec.y = 0;
4540         pFT_Vector_Transform(&vec, &transMatUnrotated);
4541         adv = (vec.x+63) >> 6;
4542     }
4543     lpgm->gmBlackBoxX = (right - left) >> 6;
4544     lpgm->gmBlackBoxY = (top - bottom) >> 6;
4545     lpgm->gmptGlyphOrigin.x = left >> 6;
4546     lpgm->gmptGlyphOrigin.y = top >> 6;
4547
4548     TRACE("%u,%u,%s,%d,%d\n", lpgm->gmBlackBoxX, lpgm->gmBlackBoxY,
4549           wine_dbgstr_point(&lpgm->gmptGlyphOrigin),
4550           lpgm->gmCellIncX, lpgm->gmCellIncY);
4551
4552     if ((format == GGO_METRICS || format == GGO_BITMAP || format ==  WINE_GGO_GRAY16_BITMAP) &&
4553         (!lpmat || is_identity_MAT2(lpmat))) /* don't cache custom transforms */
4554     {
4555         FONT_GM(font,original_index)->gm = *lpgm;
4556         FONT_GM(font,original_index)->adv = adv;
4557         FONT_GM(font,original_index)->lsb = lsb;
4558         FONT_GM(font,original_index)->bbx = bbx;
4559         FONT_GM(font,original_index)->init = TRUE;
4560     }
4561
4562     if(format == GGO_METRICS)
4563     {
4564         LeaveCriticalSection( &freetype_cs );
4565         return 1; /* FIXME */
4566     }
4567
4568     if(ft_face->glyph->format != ft_glyph_format_outline && format != GGO_BITMAP && format != WINE_GGO_GRAY16_BITMAP) {
4569         TRACE("loaded a bitmap\n");
4570         LeaveCriticalSection( &freetype_cs );
4571         return GDI_ERROR;
4572     }
4573
4574     switch(format) {
4575     case GGO_BITMAP:
4576         width = lpgm->gmBlackBoxX;
4577         height = lpgm->gmBlackBoxY;
4578         pitch = ((width + 31) >> 5) << 2;
4579         needed = pitch * height;
4580
4581         if(!buf || !buflen) break;
4582
4583         switch(ft_face->glyph->format) {
4584         case ft_glyph_format_bitmap:
4585           {
4586             BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
4587             INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
4588             INT h = ft_face->glyph->bitmap.rows;
4589             while(h--) {
4590                 memcpy(dst, src, w);
4591                 src += ft_face->glyph->bitmap.pitch;
4592                 dst += pitch;
4593             }
4594             break;
4595           }
4596
4597         case ft_glyph_format_outline:
4598             ft_bitmap.width = width;
4599             ft_bitmap.rows = height;
4600             ft_bitmap.pitch = pitch;
4601             ft_bitmap.pixel_mode = ft_pixel_mode_mono;
4602             ft_bitmap.buffer = buf;
4603
4604                 if(needsTransform) {
4605                         pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
4606             }
4607
4608             pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
4609
4610             /* Note: FreeType will only set 'black' bits for us. */
4611             memset(buf, 0, needed);
4612             pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
4613             break;
4614
4615         default:
4616             FIXME("loaded glyph format %x\n", ft_face->glyph->format);
4617             LeaveCriticalSection( &freetype_cs );
4618             return GDI_ERROR;
4619         }
4620         break;
4621
4622     case GGO_GRAY2_BITMAP:
4623     case GGO_GRAY4_BITMAP:
4624     case GGO_GRAY8_BITMAP:
4625     case WINE_GGO_GRAY16_BITMAP:
4626       {
4627         unsigned int mult, row, col;
4628         BYTE *start, *ptr;
4629
4630         width = lpgm->gmBlackBoxX;
4631         height = lpgm->gmBlackBoxY;
4632         pitch = (width + 3) / 4 * 4;
4633         needed = pitch * height;
4634
4635         if(!buf || !buflen) break;
4636
4637         switch(ft_face->glyph->format) {
4638         case ft_glyph_format_bitmap:
4639           {
4640             BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
4641             INT h = ft_face->glyph->bitmap.rows;
4642             INT x;
4643             while(h--) {
4644                 for(x = 0; x < pitch; x++)
4645                 {
4646                     if(x < ft_face->glyph->bitmap.width)
4647                         dst[x] = (src[x / 8] & (1 << ( (7 - (x % 8))))) ? 0xff : 0;
4648                     else
4649                         dst[x] = 0;
4650                 }
4651                 src += ft_face->glyph->bitmap.pitch;
4652                 dst += pitch;
4653             }
4654             LeaveCriticalSection( &freetype_cs );
4655             return needed;
4656           }
4657         case ft_glyph_format_outline:
4658           {
4659             ft_bitmap.width = width;
4660             ft_bitmap.rows = height;
4661             ft_bitmap.pitch = pitch;
4662             ft_bitmap.pixel_mode = ft_pixel_mode_grays;
4663             ft_bitmap.buffer = buf;
4664
4665             if(needsTransform)
4666                 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
4667
4668             pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
4669
4670             memset(ft_bitmap.buffer, 0, buflen);
4671
4672             pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
4673
4674             if(format == GGO_GRAY2_BITMAP)
4675                 mult = 4;
4676             else if(format == GGO_GRAY4_BITMAP)
4677                 mult = 16;
4678             else if(format == GGO_GRAY8_BITMAP)
4679                 mult = 64;
4680             else /* format == WINE_GGO_GRAY16_BITMAP */
4681             {
4682                 LeaveCriticalSection( &freetype_cs );
4683                 return needed;
4684             }
4685             break;
4686           }
4687         default:
4688             FIXME("loaded glyph format %x\n", ft_face->glyph->format);
4689             LeaveCriticalSection( &freetype_cs );
4690             return GDI_ERROR;
4691         }
4692
4693         start = buf;
4694         for(row = 0; row < height; row++) {
4695             ptr = start;
4696             for(col = 0; col < width; col++, ptr++) {
4697                 *ptr = (((int)*ptr) * mult + 128) / 256;
4698             }
4699             start += pitch;
4700         }
4701         break;
4702       }
4703
4704     case GGO_NATIVE:
4705       {
4706         int contour, point = 0, first_pt;
4707         FT_Outline *outline = &ft_face->glyph->outline;
4708         TTPOLYGONHEADER *pph;
4709         TTPOLYCURVE *ppc;
4710         DWORD pph_start, cpfx, type;
4711
4712         if(buflen == 0) buf = NULL;
4713
4714         if (needsTransform && buf) {
4715                 pFT_Outline_Transform(outline, &transMat);
4716         }
4717
4718         for(contour = 0; contour < outline->n_contours; contour++) {
4719             pph_start = needed;
4720             pph = (TTPOLYGONHEADER *)((char *)buf + needed);
4721             first_pt = point;
4722             if(buf) {
4723                 pph->dwType = TT_POLYGON_TYPE;
4724                 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
4725             }
4726             needed += sizeof(*pph);
4727             point++;
4728             while(point <= outline->contours[contour]) {
4729                 ppc = (TTPOLYCURVE *)((char *)buf + needed);
4730                 type = (outline->tags[point] & FT_Curve_Tag_On) ?
4731                   TT_PRIM_LINE : TT_PRIM_QSPLINE;
4732                 cpfx = 0;
4733                 do {
4734                     if(buf)
4735                         FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4736                     cpfx++;
4737                     point++;
4738                 } while(point <= outline->contours[contour] &&
4739                         (outline->tags[point] & FT_Curve_Tag_On) ==
4740                         (outline->tags[point-1] & FT_Curve_Tag_On));
4741                 /* At the end of a contour Windows adds the start point, but
4742                    only for Beziers */
4743                 if(point > outline->contours[contour] &&
4744                    !(outline->tags[point-1] & FT_Curve_Tag_On)) {
4745                     if(buf)
4746                         FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
4747                     cpfx++;
4748                 } else if(point <= outline->contours[contour] &&
4749                           outline->tags[point] & FT_Curve_Tag_On) {
4750                   /* add closing pt for bezier */
4751                     if(buf)
4752                         FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4753                     cpfx++;
4754                     point++;
4755                 }
4756                 if(buf) {
4757                     ppc->wType = type;
4758                     ppc->cpfx = cpfx;
4759                 }
4760                 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
4761             }
4762             if(buf)
4763                 pph->cb = needed - pph_start;
4764         }
4765         break;
4766       }
4767     case GGO_BEZIER:
4768       {
4769         /* Convert the quadratic Beziers to cubic Beziers.
4770            The parametric eqn for a cubic Bezier is, from PLRM:
4771            r(t) = at^3 + bt^2 + ct + r0
4772            with the control points:
4773            r1 = r0 + c/3
4774            r2 = r1 + (c + b)/3
4775            r3 = r0 + c + b + a
4776
4777            A quadratic Beizer has the form:
4778            p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
4779
4780            So equating powers of t leads to:
4781            r1 = 2/3 p1 + 1/3 p0
4782            r2 = 2/3 p1 + 1/3 p2
4783            and of course r0 = p0, r3 = p2
4784         */
4785
4786         int contour, point = 0, first_pt;
4787         FT_Outline *outline = &ft_face->glyph->outline;
4788         TTPOLYGONHEADER *pph;
4789         TTPOLYCURVE *ppc;
4790         DWORD pph_start, cpfx, type;
4791         FT_Vector cubic_control[4];
4792         if(buflen == 0) buf = NULL;
4793
4794         if (needsTransform && buf) {
4795                 pFT_Outline_Transform(outline, &transMat);
4796         }
4797
4798         for(contour = 0; contour < outline->n_contours; contour++) {
4799             pph_start = needed;
4800             pph = (TTPOLYGONHEADER *)((char *)buf + needed);
4801             first_pt = point;
4802             if(buf) {
4803                 pph->dwType = TT_POLYGON_TYPE;
4804                 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
4805             }
4806             needed += sizeof(*pph);
4807             point++;
4808             while(point <= outline->contours[contour]) {
4809                 ppc = (TTPOLYCURVE *)((char *)buf + needed);
4810                 type = (outline->tags[point] & FT_Curve_Tag_On) ?
4811                   TT_PRIM_LINE : TT_PRIM_CSPLINE;
4812                 cpfx = 0;
4813                 do {
4814                     if(type == TT_PRIM_LINE) {
4815                         if(buf)
4816                             FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
4817                         cpfx++;
4818                         point++;
4819                     } else {
4820                       /* Unlike QSPLINEs, CSPLINEs always have their endpoint
4821                          so cpfx = 3n */
4822
4823                       /* FIXME: Possible optimization in endpoint calculation
4824                          if there are two consecutive curves */
4825                         cubic_control[0] = outline->points[point-1];
4826                         if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
4827                             cubic_control[0].x += outline->points[point].x + 1;
4828                             cubic_control[0].y += outline->points[point].y + 1;
4829                             cubic_control[0].x >>= 1;
4830                             cubic_control[0].y >>= 1;
4831                         }
4832                         if(point+1 > outline->contours[contour])
4833                             cubic_control[3] = outline->points[first_pt];
4834                         else {
4835                             cubic_control[3] = outline->points[point+1];
4836                             if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
4837                                 cubic_control[3].x += outline->points[point].x + 1;
4838                                 cubic_control[3].y += outline->points[point].y + 1;
4839                                 cubic_control[3].x >>= 1;
4840                                 cubic_control[3].y >>= 1;
4841                             }
4842                         }
4843                         /* r1 = 1/3 p0 + 2/3 p1
4844                            r2 = 1/3 p2 + 2/3 p1 */
4845                         cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
4846                         cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
4847                         cubic_control[2] = cubic_control[1];
4848                         cubic_control[1].x += (cubic_control[0].x + 1) / 3;
4849                         cubic_control[1].y += (cubic_control[0].y + 1) / 3;
4850                         cubic_control[2].x += (cubic_control[3].x + 1) / 3;
4851                         cubic_control[2].y += (cubic_control[3].y + 1) / 3;
4852                         if(buf) {
4853                             FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
4854                             FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
4855                             FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
4856                         }
4857                         cpfx += 3;
4858                         point++;
4859                     }
4860                 } while(point <= outline->contours[contour] &&
4861                         (outline->tags[point] & FT_Curve_Tag_On) ==
4862                         (outline->tags[point-1] & FT_Curve_Tag_On));
4863                 /* At the end of a contour Windows adds the start point,
4864                    but only for Beziers and we've already done that.
4865                 */
4866                 if(point <= outline->contours[contour] &&
4867                    outline->tags[point] & FT_Curve_Tag_On) {
4868                   /* This is the closing pt of a bezier, but we've already
4869                      added it, so just inc point and carry on */
4870                     point++;
4871                 }
4872                 if(buf) {
4873                     ppc->wType = type;
4874                     ppc->cpfx = cpfx;
4875                 }
4876                 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
4877             }
4878             if(buf)
4879                 pph->cb = needed - pph_start;
4880         }
4881         break;
4882       }
4883
4884     default:
4885         FIXME("Unsupported format %d\n", format);
4886         LeaveCriticalSection( &freetype_cs );
4887         return GDI_ERROR;
4888     }
4889     LeaveCriticalSection( &freetype_cs );
4890     return needed;
4891 }
4892
4893 static BOOL get_bitmap_text_metrics(GdiFont *font)
4894 {
4895     FT_Face ft_face = font->ft_face;
4896 #ifdef HAVE_FREETYPE_FTWINFNT_H
4897     FT_WinFNT_HeaderRec winfnt_header;
4898 #endif
4899     const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
4900     font->potm = HeapAlloc(GetProcessHeap(), 0, size);
4901     font->potm->otmSize = size;
4902
4903 #define TM font->potm->otmTextMetrics
4904 #ifdef HAVE_FREETYPE_FTWINFNT_H
4905     if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
4906     {
4907         TM.tmHeight = winfnt_header.pixel_height;
4908         TM.tmAscent = winfnt_header.ascent;
4909         TM.tmDescent = TM.tmHeight - TM.tmAscent;
4910         TM.tmInternalLeading = winfnt_header.internal_leading;
4911         TM.tmExternalLeading = winfnt_header.external_leading;
4912         TM.tmAveCharWidth = winfnt_header.avg_width;
4913         TM.tmMaxCharWidth = winfnt_header.max_width;
4914         TM.tmWeight = winfnt_header.weight;
4915         TM.tmOverhang = 0;
4916         TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
4917         TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
4918         TM.tmFirstChar = winfnt_header.first_char;
4919         TM.tmLastChar = winfnt_header.last_char;
4920         TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
4921         TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
4922         TM.tmItalic = winfnt_header.italic;
4923         TM.tmUnderlined = font->underline;
4924         TM.tmStruckOut = font->strikeout;
4925         TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
4926         TM.tmCharSet = winfnt_header.charset;
4927     }
4928     else
4929 #endif
4930     {
4931         TM.tmAscent = ft_face->size->metrics.ascender >> 6;
4932         TM.tmDescent = -ft_face->size->metrics.descender >> 6;
4933         TM.tmHeight = TM.tmAscent + TM.tmDescent;
4934         TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
4935         TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
4936         TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
4937         TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
4938         TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
4939         TM.tmOverhang = 0;
4940         TM.tmDigitizedAspectX = 96; /* FIXME */
4941         TM.tmDigitizedAspectY = 96; /* FIXME */
4942         TM.tmFirstChar = 1;
4943         TM.tmLastChar = 255;
4944         TM.tmDefaultChar = 32;
4945         TM.tmBreakChar = 32;
4946         TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
4947         TM.tmUnderlined = font->underline;
4948         TM.tmStruckOut = font->strikeout;
4949         /* NB inverted meaning of TMPF_FIXED_PITCH */
4950         TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
4951         TM.tmCharSet = font->charset;
4952     }
4953 #undef TM
4954
4955     return TRUE;
4956 }
4957
4958
4959 static void scale_font_metrics(const GdiFont *font, LPTEXTMETRICW ptm)
4960 {
4961     double scale_x, scale_y;
4962
4963     if (font->aveWidth)
4964     {
4965         scale_x = (double)font->aveWidth;
4966         scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
4967     }
4968     else
4969         scale_x = font->scale_y;
4970
4971     scale_x *= fabs(font->font_desc.matrix.eM11);
4972     scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
4973
4974 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
4975 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
4976
4977     SCALE_Y(ptm->tmHeight);
4978     SCALE_Y(ptm->tmAscent);
4979     SCALE_Y(ptm->tmDescent);
4980     SCALE_Y(ptm->tmInternalLeading);
4981     SCALE_Y(ptm->tmExternalLeading);
4982     SCALE_Y(ptm->tmOverhang);
4983
4984     SCALE_X(ptm->tmAveCharWidth);
4985     SCALE_X(ptm->tmMaxCharWidth);
4986
4987 #undef SCALE_X
4988 #undef SCALE_Y
4989 }
4990
4991 static void scale_outline_font_metrics(const GdiFont *font, OUTLINETEXTMETRICW *potm)
4992 {
4993     double scale_x, scale_y;
4994
4995     if (font->aveWidth)
4996     {
4997         scale_x = (double)font->aveWidth;
4998         scale_x /= (double)font->potm->otmTextMetrics.tmAveCharWidth;
4999     }
5000     else
5001         scale_x = font->scale_y;
5002
5003     scale_x *= fabs(font->font_desc.matrix.eM11);
5004     scale_y = font->scale_y * fabs(font->font_desc.matrix.eM22);
5005
5006     scale_font_metrics(font, &potm->otmTextMetrics);
5007
5008 #define SCALE_X(x) (x) = GDI_ROUND((double)(x) * (scale_x))
5009 #define SCALE_Y(y) (y) = GDI_ROUND((double)(y) * (scale_y))
5010
5011     SCALE_Y(potm->otmAscent);
5012     SCALE_Y(potm->otmDescent);
5013     SCALE_Y(potm->otmLineGap);
5014     SCALE_Y(potm->otmsCapEmHeight);
5015     SCALE_Y(potm->otmsXHeight);
5016     SCALE_Y(potm->otmrcFontBox.top);
5017     SCALE_Y(potm->otmrcFontBox.bottom);
5018     SCALE_X(potm->otmrcFontBox.left);
5019     SCALE_X(potm->otmrcFontBox.right);
5020     SCALE_Y(potm->otmMacAscent);
5021     SCALE_Y(potm->otmMacDescent);
5022     SCALE_Y(potm->otmMacLineGap);
5023     SCALE_X(potm->otmptSubscriptSize.x);
5024     SCALE_Y(potm->otmptSubscriptSize.y);
5025     SCALE_X(potm->otmptSubscriptOffset.x);
5026     SCALE_Y(potm->otmptSubscriptOffset.y);
5027     SCALE_X(potm->otmptSuperscriptSize.x);
5028     SCALE_Y(potm->otmptSuperscriptSize.y);
5029     SCALE_X(potm->otmptSuperscriptOffset.x);
5030     SCALE_Y(potm->otmptSuperscriptOffset.y);
5031     SCALE_Y(potm->otmsStrikeoutSize);
5032     SCALE_Y(potm->otmsStrikeoutPosition);
5033     SCALE_Y(potm->otmsUnderscoreSize);
5034     SCALE_Y(potm->otmsUnderscorePosition);
5035
5036 #undef SCALE_X
5037 #undef SCALE_Y
5038 }
5039
5040 /*************************************************************
5041  * WineEngGetTextMetrics
5042  *
5043  */
5044 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
5045 {
5046     EnterCriticalSection( &freetype_cs );
5047     if(!font->potm) {
5048         if(!WineEngGetOutlineTextMetrics(font, 0, NULL))
5049             if(!get_bitmap_text_metrics(font))
5050             {
5051                 LeaveCriticalSection( &freetype_cs );
5052                 return FALSE;
5053             }
5054     }
5055     if(!font->potm)
5056     {
5057         LeaveCriticalSection( &freetype_cs );
5058         return FALSE;
5059     }
5060     *ptm = font->potm->otmTextMetrics;
5061     scale_font_metrics(font, ptm);
5062     LeaveCriticalSection( &freetype_cs );
5063     return TRUE;
5064 }
5065
5066
5067 /*************************************************************
5068  * WineEngGetOutlineTextMetrics
5069  *
5070  */
5071 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
5072                                   OUTLINETEXTMETRICW *potm)
5073 {
5074     FT_Face ft_face = font->ft_face;
5075     UINT needed, lenfam, lensty, ret;
5076     TT_OS2 *pOS2;
5077     TT_HoriHeader *pHori;
5078     TT_Postscript *pPost;
5079     FT_Fixed x_scale, y_scale;
5080     WCHAR *family_nameW, *style_nameW;
5081     static const WCHAR spaceW[] = {' ', '\0'};
5082     char *cp;
5083     INT ascent, descent;
5084
5085     TRACE("font=%p\n", font);
5086
5087     if(!FT_IS_SCALABLE(ft_face))
5088         return 0;
5089
5090     EnterCriticalSection( &freetype_cs );
5091
5092     if(font->potm) {
5093         if(cbSize >= font->potm->otmSize)
5094         {
5095             memcpy(potm, font->potm, font->potm->otmSize);
5096             scale_outline_font_metrics(font, potm);
5097         }
5098         LeaveCriticalSection( &freetype_cs );
5099         return font->potm->otmSize;
5100     }
5101
5102
5103     needed = sizeof(*potm);
5104
5105     lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
5106     family_nameW = strdupW(font->name);
5107
5108     lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
5109       * sizeof(WCHAR);
5110     style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
5111     MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
5112                         style_nameW, lensty/sizeof(WCHAR));
5113
5114     /* These names should be read from the TT name table */
5115
5116     /* length of otmpFamilyName */
5117     needed += lenfam;
5118
5119     /* length of otmpFaceName */
5120     if ((ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) == 0) {
5121       needed += lenfam; /* just the family name */
5122     } else {
5123       needed += lenfam + lensty; /* family + " " + style */
5124     }
5125
5126     /* length of otmpStyleName */
5127     needed += lensty;
5128
5129     /* length of otmpFullName */
5130     needed += lenfam + lensty;
5131
5132
5133     x_scale = ft_face->size->metrics.x_scale;
5134     y_scale = ft_face->size->metrics.y_scale;
5135
5136     pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
5137     if(!pOS2) {
5138         FIXME("Can't find OS/2 table - not TT font?\n");
5139         ret = 0;
5140         goto end;
5141     }
5142
5143     pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
5144     if(!pHori) {
5145         FIXME("Can't find HHEA table - not TT font?\n");
5146         ret = 0;
5147         goto end;
5148     }
5149
5150     pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
5151
5152     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",
5153           pOS2->usWinAscent, pOS2->usWinDescent,
5154           pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
5155           ft_face->ascender, ft_face->descender, ft_face->height,
5156           pHori->Ascender, pHori->Descender, pHori->Line_Gap,
5157           ft_face->bbox.yMax, ft_face->bbox.yMin);
5158
5159     font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
5160     font->potm->otmSize = needed;
5161
5162 #define TM font->potm->otmTextMetrics
5163
5164     if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
5165         ascent = pHori->Ascender;
5166         descent = -pHori->Descender;
5167     } else {
5168         ascent = pOS2->usWinAscent;
5169         descent = pOS2->usWinDescent;
5170     }
5171
5172     if(font->yMax) {
5173         TM.tmAscent = font->yMax;
5174         TM.tmDescent = -font->yMin;
5175         TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
5176     } else {
5177         TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
5178         TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
5179         TM.tmInternalLeading = (pFT_MulFix(ascent + descent
5180                                             - ft_face->units_per_EM, y_scale) + 32) >> 6;
5181     }
5182
5183     TM.tmHeight = TM.tmAscent + TM.tmDescent;
5184
5185     /* MSDN says:
5186      el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
5187     */
5188     TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
5189                  ((ascent + descent) -
5190                   (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
5191
5192     TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
5193     if (TM.tmAveCharWidth == 0) {
5194         TM.tmAveCharWidth = 1;
5195     }
5196     TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
5197     TM.tmWeight = (font->fake_bold || (ft_face->style_flags & FT_STYLE_FLAG_BOLD)) ? FW_BOLD : FW_REGULAR;
5198     TM.tmOverhang = 0;
5199     TM.tmDigitizedAspectX = 300;
5200     TM.tmDigitizedAspectY = 300;
5201     /* It appears that for fonts with SYMBOL_CHARSET Windows always sets
5202      * symbol range to 0 - f0ff
5203      */
5204     if (font->charset == SYMBOL_CHARSET)
5205     {
5206         TM.tmFirstChar = 0;
5207         TM.tmDefaultChar = pOS2->usDefaultChar ? pOS2->usDefaultChar : 0x1f;
5208     }
5209     else
5210     {
5211         TM.tmFirstChar = pOS2->usFirstCharIndex;
5212         TM.tmDefaultChar = pOS2->usDefaultChar ? pOS2->usDefaultChar : 0xffff;
5213     }
5214     TM.tmLastChar = pOS2->usLastCharIndex;
5215     TM.tmBreakChar = pOS2->usBreakChar ? pOS2->usBreakChar : ' ';
5216     TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
5217     TM.tmUnderlined = font->underline;
5218     TM.tmStruckOut = font->strikeout;
5219
5220     /* Yes TPMF_FIXED_PITCH is correct; braindead api */
5221     if(!FT_IS_FIXED_WIDTH(ft_face) &&
5222        (pOS2->version == 0xFFFFU ||
5223         pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
5224         TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
5225     else
5226         TM.tmPitchAndFamily = 0;
5227
5228     switch(pOS2->panose[PAN_FAMILYTYPE_INDEX]) {
5229     case PAN_FAMILY_SCRIPT:
5230         TM.tmPitchAndFamily |= FF_SCRIPT;
5231         break;
5232     case PAN_FAMILY_DECORATIVE:
5233     case PAN_FAMILY_PICTORIAL:
5234         TM.tmPitchAndFamily |= FF_DECORATIVE;
5235         break;
5236     case PAN_FAMILY_TEXT_DISPLAY:
5237         if(TM.tmPitchAndFamily == 0) /* fixed */
5238             TM.tmPitchAndFamily = FF_MODERN;
5239         else {
5240             switch(pOS2->panose[PAN_SERIFSTYLE_INDEX]) {
5241             case PAN_SERIF_NORMAL_SANS:
5242             case PAN_SERIF_OBTUSE_SANS:
5243             case PAN_SERIF_PERP_SANS:
5244                 TM.tmPitchAndFamily |= FF_SWISS;
5245                 break;
5246             default:
5247                 TM.tmPitchAndFamily |= FF_ROMAN;
5248             }
5249         }
5250         break;
5251     default:
5252         TM.tmPitchAndFamily |= FF_DONTCARE;
5253     }
5254
5255     if(FT_IS_SCALABLE(ft_face))
5256         TM.tmPitchAndFamily |= TMPF_VECTOR;
5257
5258     if(FT_IS_SFNT(ft_face))
5259     {
5260         if (font->ntmFlags & NTM_PS_OPENTYPE)
5261             TM.tmPitchAndFamily |= TMPF_DEVICE;
5262         else
5263             TM.tmPitchAndFamily |= TMPF_TRUETYPE;
5264     }
5265
5266     TM.tmCharSet = font->charset;
5267
5268     font->potm->otmFiller = 0;
5269     memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
5270     font->potm->otmfsSelection = pOS2->fsSelection;
5271     font->potm->otmfsType = pOS2->fsType;
5272     font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
5273     font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
5274     font->potm->otmItalicAngle = 0; /* POST table */
5275     font->potm->otmEMSquare = ft_face->units_per_EM;
5276     font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
5277     font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
5278     font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
5279     font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
5280     font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
5281     font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
5282     font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
5283     font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
5284     font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
5285     font->potm->otmMacAscent = TM.tmAscent;
5286     font->potm->otmMacDescent = -TM.tmDescent;
5287     font->potm->otmMacLineGap = font->potm->otmLineGap;
5288     font->potm->otmusMinimumPPEM = 0; /* TT Header */
5289     font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
5290     font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
5291     font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
5292     font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
5293     font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
5294     font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
5295     font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
5296     font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
5297     font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
5298     font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
5299     if(!pPost) {
5300         font->potm->otmsUnderscoreSize = 0;
5301         font->potm->otmsUnderscorePosition = 0;
5302     } else {
5303         font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
5304         font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
5305     }
5306 #undef TM
5307
5308     /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
5309     cp = (char*)font->potm + sizeof(*font->potm);
5310     font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
5311     strcpyW((WCHAR*)cp, family_nameW);
5312     cp += lenfam;
5313     font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
5314     strcpyW((WCHAR*)cp, style_nameW);
5315     cp += lensty;
5316     font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
5317     strcpyW((WCHAR*)cp, family_nameW);
5318     if (ft_face->style_flags & (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) {
5319         strcatW((WCHAR*)cp, spaceW);
5320         strcatW((WCHAR*)cp, style_nameW);
5321         cp += lenfam + lensty;
5322     } else
5323         cp += lenfam;
5324     font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
5325     strcpyW((WCHAR*)cp, family_nameW);
5326     strcatW((WCHAR*)cp, spaceW);
5327     strcatW((WCHAR*)cp, style_nameW);
5328     ret = needed;
5329
5330     if(potm && needed <= cbSize)
5331     {
5332         memcpy(potm, font->potm, font->potm->otmSize);
5333         scale_outline_font_metrics(font, potm);
5334     }
5335
5336 end:
5337     HeapFree(GetProcessHeap(), 0, style_nameW);
5338     HeapFree(GetProcessHeap(), 0, family_nameW);
5339
5340     LeaveCriticalSection( &freetype_cs );
5341     return ret;
5342 }
5343
5344 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
5345 {
5346     HFONTLIST *hfontlist;
5347     child->font = alloc_font();
5348     child->font->ft_face = OpenFontFace(child->font, child->face, 0, -font->ppem);
5349     if(!child->font->ft_face)
5350     {
5351         free_font(child->font);
5352         child->font = NULL;
5353         return FALSE;
5354     }
5355
5356     child->font->ntmFlags = child->face->ntmFlags;
5357     child->font->orientation = font->orientation;
5358     child->font->scale_y = font->scale_y;
5359     hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
5360     hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
5361     list_add_head(&child->font->hfontlist, &hfontlist->entry);
5362     child->font->base_font = font;
5363     list_add_head(&child_font_list, &child->font->entry);
5364     TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
5365     return TRUE;
5366 }
5367
5368 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
5369 {
5370     FT_UInt g;
5371     CHILD_FONT *child_font;
5372
5373     if(font->base_font)
5374         font = font->base_font;
5375
5376     *linked_font = font;
5377
5378     if((*glyph = get_glyph_index(font, c)))
5379         return TRUE;
5380
5381     LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
5382     {
5383         if(!child_font->font)
5384             if(!load_child_font(font, child_font))
5385                 continue;
5386
5387         if(!child_font->font->ft_face)
5388             continue;
5389         g = get_glyph_index(child_font->font, c);
5390         if(g)
5391         {
5392             *glyph = g;
5393             *linked_font = child_font->font;
5394             return TRUE;
5395         }
5396     }
5397     return FALSE;
5398 }
5399
5400 /*************************************************************
5401  * WineEngGetCharWidth
5402  *
5403  */
5404 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
5405                          LPINT buffer)
5406 {
5407     UINT c;
5408     GLYPHMETRICS gm;
5409     FT_UInt glyph_index;
5410     GdiFont *linked_font;
5411
5412     TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
5413
5414     EnterCriticalSection( &freetype_cs );
5415     for(c = firstChar; c <= lastChar; c++) {
5416         get_glyph_index_linked(font, c, &linked_font, &glyph_index);
5417         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5418                                &gm, 0, NULL, NULL);
5419         buffer[c - firstChar] = FONT_GM(linked_font,glyph_index)->adv;
5420     }
5421     LeaveCriticalSection( &freetype_cs );
5422     return TRUE;
5423 }
5424
5425 /*************************************************************
5426  * WineEngGetCharABCWidths
5427  *
5428  */
5429 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
5430                              LPABC buffer)
5431 {
5432     UINT c;
5433     GLYPHMETRICS gm;
5434     FT_UInt glyph_index;
5435     GdiFont *linked_font;
5436
5437     TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
5438
5439     if(!FT_IS_SCALABLE(font->ft_face))
5440         return FALSE;
5441
5442     EnterCriticalSection( &freetype_cs );
5443
5444     for(c = firstChar; c <= lastChar; c++) {
5445         get_glyph_index_linked(font, c, &linked_font, &glyph_index);
5446         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5447                                &gm, 0, NULL, NULL);
5448         buffer[c - firstChar].abcA = FONT_GM(linked_font,glyph_index)->lsb;
5449         buffer[c - firstChar].abcB = FONT_GM(linked_font,glyph_index)->bbx;
5450         buffer[c - firstChar].abcC = FONT_GM(linked_font,glyph_index)->adv - FONT_GM(linked_font,glyph_index)->lsb -
5451             FONT_GM(linked_font,glyph_index)->bbx;
5452     }
5453     LeaveCriticalSection( &freetype_cs );
5454     return TRUE;
5455 }
5456
5457 /*************************************************************
5458  * WineEngGetCharABCWidthsI
5459  *
5460  */
5461 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
5462                               LPABC buffer)
5463 {
5464     UINT c;
5465     GLYPHMETRICS gm;
5466     FT_UInt glyph_index;
5467     GdiFont *linked_font;
5468
5469     if(!FT_HAS_HORIZONTAL(font->ft_face))
5470         return FALSE;
5471
5472     EnterCriticalSection( &freetype_cs );
5473
5474     get_glyph_index_linked(font, 'a', &linked_font, &glyph_index);
5475     if (!pgi)
5476         for(c = firstChar; c < firstChar+count; c++) {
5477             WineEngGetGlyphOutline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
5478                                    &gm, 0, NULL, NULL);
5479             buffer[c - firstChar].abcA = FONT_GM(linked_font,c)->lsb;
5480             buffer[c - firstChar].abcB = FONT_GM(linked_font,c)->bbx;
5481             buffer[c - firstChar].abcC = FONT_GM(linked_font,c)->adv - FONT_GM(linked_font,c)->lsb
5482                 - FONT_GM(linked_font,c)->bbx;
5483         }
5484     else
5485         for(c = 0; c < count; c++) {
5486             WineEngGetGlyphOutline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
5487                                    &gm, 0, NULL, NULL);
5488             buffer[c].abcA = FONT_GM(linked_font,pgi[c])->lsb;
5489             buffer[c].abcB = FONT_GM(linked_font,pgi[c])->bbx;
5490             buffer[c].abcC = FONT_GM(linked_font,pgi[c])->adv
5491                 - FONT_GM(linked_font,pgi[c])->lsb - FONT_GM(linked_font,pgi[c])->bbx;
5492         }
5493
5494     LeaveCriticalSection( &freetype_cs );
5495     return TRUE;
5496 }
5497
5498 /*************************************************************
5499  * WineEngGetTextExtentExPoint
5500  *
5501  */
5502 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
5503                                  INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
5504 {
5505     INT idx;
5506     INT nfit = 0, ext;
5507     GLYPHMETRICS gm;
5508     TEXTMETRICW tm;
5509     FT_UInt glyph_index;
5510     GdiFont *linked_font;
5511
5512     TRACE("%p, %s, %d, %d, %p\n", font, debugstr_wn(wstr, count), count,
5513           max_ext, size);
5514
5515     EnterCriticalSection( &freetype_cs );
5516
5517     size->cx = 0;
5518     WineEngGetTextMetrics(font, &tm);
5519     size->cy = tm.tmHeight;
5520
5521     for(idx = 0; idx < count; idx++) {
5522         get_glyph_index_linked(font, wstr[idx], &linked_font, &glyph_index);
5523         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
5524                                &gm, 0, NULL, NULL);
5525         size->cx += FONT_GM(linked_font,glyph_index)->adv;
5526         ext = size->cx;
5527         if (! pnfit || ext <= max_ext) {
5528             ++nfit;
5529             if (dxs)
5530                 dxs[idx] = ext;
5531         }
5532     }
5533
5534     if (pnfit)
5535         *pnfit = nfit;
5536
5537     LeaveCriticalSection( &freetype_cs );
5538     TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
5539     return TRUE;
5540 }
5541
5542 /*************************************************************
5543  * WineEngGetTextExtentExPointI
5544  *
5545  */
5546 BOOL WineEngGetTextExtentExPointI(GdiFont *font, const WORD *indices, INT count,
5547                                   INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
5548 {
5549     INT idx;
5550     INT nfit = 0, ext;
5551     GLYPHMETRICS gm;
5552     TEXTMETRICW tm;
5553
5554     TRACE("%p, %p, %d, %d, %p\n", font, indices, count, max_ext, size);
5555
5556     EnterCriticalSection( &freetype_cs );
5557
5558     size->cx = 0;
5559     WineEngGetTextMetrics(font, &tm);
5560     size->cy = tm.tmHeight;
5561
5562     for(idx = 0; idx < count; idx++) {
5563         WineEngGetGlyphOutline(font, indices[idx],
5564                                GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL,
5565                                NULL);
5566         size->cx += FONT_GM(font,indices[idx])->adv;
5567         ext = size->cx;
5568         if (! pnfit || ext <= max_ext) {
5569             ++nfit;
5570             if (dxs)
5571                 dxs[idx] = ext;
5572         }
5573     }
5574
5575     if (pnfit)
5576         *pnfit = nfit;
5577
5578     LeaveCriticalSection( &freetype_cs );
5579     TRACE("return %d, %d, %d\n", size->cx, size->cy, nfit);
5580     return TRUE;
5581 }
5582
5583 /*************************************************************
5584  * WineEngGetFontData
5585  *
5586  */
5587 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
5588                          DWORD cbData)
5589 {
5590     FT_Face ft_face = font->ft_face;
5591     FT_ULong len;
5592     FT_Error err;
5593
5594     TRACE("font=%p, table=%c%c%c%c, offset=0x%x, buf=%p, cbData=0x%x\n",
5595         font, LOBYTE(LOWORD(table)), HIBYTE(LOWORD(table)),
5596         LOBYTE(HIWORD(table)), HIBYTE(HIWORD(table)), offset, buf, cbData);
5597
5598     if(!FT_IS_SFNT(ft_face))
5599         return GDI_ERROR;
5600
5601     if(!buf || !cbData)
5602         len = 0;
5603     else
5604         len = cbData;
5605
5606     if(table) { /* MS tags differ in endianness from FT ones */
5607         table = table >> 24 | table << 24 |
5608           (table >> 8 & 0xff00) | (table << 8 & 0xff0000);
5609     }
5610
5611     /* make sure value of len is the value freetype says it needs */
5612     if(buf && len)
5613     {
5614         FT_ULong needed = 0;
5615         err = load_sfnt_table(ft_face, table, offset, NULL, &needed);
5616         if( !err && needed < len) len = needed;
5617     }
5618     err = load_sfnt_table(ft_face, table, offset, buf, &len);
5619
5620     if(err) {
5621         TRACE("Can't find table %c%c%c%c\n",
5622               /* bytes were reversed */
5623               HIBYTE(HIWORD(table)), LOBYTE(HIWORD(table)),
5624               HIBYTE(LOWORD(table)), LOBYTE(LOWORD(table)));
5625         return GDI_ERROR;
5626     }
5627     return len;
5628 }
5629
5630 /*************************************************************
5631  * WineEngGetTextFace
5632  *
5633  */
5634 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
5635 {
5636     INT n = strlenW(font->name) + 1;
5637     if(str) {
5638         lstrcpynW(str, font->name, count);
5639         return min(count, n);
5640     } else
5641         return n;
5642 }
5643
5644 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
5645 {
5646     if (fs) *fs = font->fs;
5647     return font->charset;
5648 }
5649
5650 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
5651 {
5652     GdiFont *font = dc->gdiFont, *linked_font;
5653     struct list *first_hfont;
5654     BOOL ret;
5655
5656     EnterCriticalSection( &freetype_cs );
5657     ret = get_glyph_index_linked(font, c, &linked_font, glyph);
5658     TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
5659     if(font == linked_font)
5660         *new_hfont = dc->hFont;
5661     else
5662     {
5663         first_hfont = list_head(&linked_font->hfontlist);
5664         *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
5665     }
5666     LeaveCriticalSection( &freetype_cs );
5667     return ret;
5668 }
5669
5670 /* Retrieve a list of supported Unicode ranges for a given font.
5671  * Can be called with NULL gs to calculate the buffer size. Returns
5672  * the number of ranges found.
5673  */
5674 static DWORD get_font_unicode_ranges(FT_Face face, GLYPHSET *gs)
5675 {
5676     DWORD num_ranges = 0;
5677
5678     if (face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
5679     {
5680         FT_UInt glyph_code;
5681         FT_ULong char_code, char_code_prev;
5682
5683         glyph_code = 0;
5684         char_code_prev = char_code = pFT_Get_First_Char(face, &glyph_code);
5685
5686         TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
5687                face->num_glyphs, glyph_code, char_code);
5688
5689         if (!glyph_code) return 0;
5690
5691         if (gs)
5692         {
5693             gs->ranges[0].wcLow = (USHORT)char_code;
5694             gs->ranges[0].cGlyphs = 0;
5695             gs->cGlyphsSupported = 0;
5696         }
5697
5698         num_ranges = 1;
5699         while (glyph_code)
5700         {
5701             if (char_code < char_code_prev)
5702             {
5703                 ERR("expected increasing char code from FT_Get_Next_Char\n");
5704                 return 0;
5705             }
5706             if (char_code - char_code_prev > 1)
5707             {
5708                 num_ranges++;
5709                 if (gs)
5710                 {
5711                     gs->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
5712                     gs->ranges[num_ranges - 1].cGlyphs = 1;
5713                     gs->cGlyphsSupported++;
5714                 }
5715             }
5716             else if (gs)
5717             {
5718                 gs->ranges[num_ranges - 1].cGlyphs++;
5719                 gs->cGlyphsSupported++;
5720             }
5721             char_code_prev = char_code;
5722             char_code = pFT_Get_Next_Char(face, char_code, &glyph_code);
5723         }
5724     }
5725     else
5726         FIXME("encoding %u not supported\n", face->charmap->encoding);
5727
5728     return num_ranges;
5729 }
5730
5731 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
5732 {
5733     DWORD size = 0;
5734     DWORD num_ranges = get_font_unicode_ranges(font->ft_face, glyphset);
5735
5736     size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
5737     if (glyphset)
5738     {
5739         glyphset->cbThis = size;
5740         glyphset->cRanges = num_ranges;
5741     }
5742     return size;
5743 }
5744
5745 /*************************************************************
5746  *     FontIsLinked
5747  */
5748 BOOL WineEngFontIsLinked(GdiFont *font)
5749 {
5750     BOOL ret;
5751     EnterCriticalSection( &freetype_cs );
5752     ret = !list_empty(&font->child_fonts);
5753     LeaveCriticalSection( &freetype_cs );
5754     return ret;
5755 }
5756
5757 static BOOL is_hinting_enabled(void)
5758 {
5759     /* Use the >= 2.2.0 function if available */
5760     if(pFT_Get_TrueType_Engine_Type)
5761     {
5762         FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
5763         return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
5764     }
5765 #ifdef FT_DRIVER_HAS_HINTER
5766     else
5767     {
5768         FT_Module mod;
5769
5770         /* otherwise if we've been compiled with < 2.2.0 headers
5771            use the internal macro */
5772         mod = pFT_Get_Module(library, "truetype");
5773         if(mod && FT_DRIVER_HAS_HINTER(mod))
5774             return TRUE;
5775     }
5776 #endif
5777
5778     return FALSE;
5779 }
5780
5781 /*************************************************************************
5782  *             GetRasterizerCaps   (GDI32.@)
5783  */
5784 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
5785 {
5786     static int hinting = -1;
5787
5788     if(hinting == -1)
5789     {
5790         hinting = is_hinting_enabled();
5791         TRACE("hinting is %senabled\n", hinting ? "" : "NOT ");
5792     }
5793
5794     lprs->nSize = sizeof(RASTERIZER_STATUS);
5795     lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
5796     lprs->nLanguageID = 0;
5797     return TRUE;
5798 }
5799
5800 /*************************************************************
5801  *     WineEngRealizationInfo
5802  */
5803 BOOL WineEngRealizationInfo(GdiFont *font, realization_info_t *info)
5804 {
5805     FIXME("(%p, %p): stub!\n", font, info);
5806
5807     info->flags = 1;
5808     if(FT_IS_SCALABLE(font->ft_face))
5809         info->flags |= 2;
5810
5811     info->cache_num = font->cache_num;
5812     info->unknown2 = -1;
5813     return TRUE;
5814 }
5815
5816 /*************************************************************************
5817  * Kerning support for TrueType fonts
5818  */
5819 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
5820
5821 struct TT_kern_table
5822 {
5823     USHORT version;
5824     USHORT nTables;
5825 };
5826
5827 struct TT_kern_subtable
5828 {
5829     USHORT version;
5830     USHORT length;
5831     union
5832     {
5833         USHORT word;
5834         struct
5835         {
5836             USHORT horizontal : 1;
5837             USHORT minimum : 1;
5838             USHORT cross_stream: 1;
5839             USHORT override : 1;
5840             USHORT reserved1 : 4;
5841             USHORT format : 8;
5842         } bits;
5843     } coverage;
5844 };
5845
5846 struct TT_format0_kern_subtable
5847 {
5848     USHORT nPairs;
5849     USHORT searchRange;
5850     USHORT entrySelector;
5851     USHORT rangeShift;
5852 };
5853
5854 struct TT_kern_pair
5855 {
5856     USHORT left;
5857     USHORT right;
5858     short  value;
5859 };
5860
5861 static DWORD parse_format0_kern_subtable(GdiFont *font,
5862                                          const struct TT_format0_kern_subtable *tt_f0_ks,
5863                                          const USHORT *glyph_to_char,
5864                                          KERNINGPAIR *kern_pair, DWORD cPairs)
5865 {
5866     USHORT i, nPairs;
5867     const struct TT_kern_pair *tt_kern_pair;
5868
5869     TRACE("font height %d, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
5870
5871     nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
5872
5873     TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
5874            nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
5875            GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
5876
5877     if (!kern_pair || !cPairs)
5878         return nPairs;
5879
5880     tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
5881
5882     nPairs = min(nPairs, cPairs);
5883
5884     for (i = 0; i < nPairs; i++)
5885     {
5886         kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
5887         kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
5888         /* this algorithm appears to better match what Windows does */
5889         kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
5890         if (kern_pair->iKernAmount < 0)
5891         {
5892             kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
5893             kern_pair->iKernAmount -= font->ppem;
5894         }
5895         else if (kern_pair->iKernAmount > 0)
5896         {
5897             kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
5898             kern_pair->iKernAmount += font->ppem;
5899         }
5900         kern_pair->iKernAmount /= font->ft_face->units_per_EM;
5901
5902         TRACE("left %u right %u value %d\n",
5903                kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
5904
5905         kern_pair++;
5906     }
5907     TRACE("copied %u entries\n", nPairs);
5908     return nPairs;
5909 }
5910
5911 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
5912 {
5913     DWORD length;
5914     void *buf;
5915     const struct TT_kern_table *tt_kern_table;
5916     const struct TT_kern_subtable *tt_kern_subtable;
5917     USHORT i, nTables;
5918     USHORT *glyph_to_char;
5919
5920     EnterCriticalSection( &freetype_cs );
5921     if (font->total_kern_pairs != (DWORD)-1)
5922     {
5923         if (cPairs && kern_pair)
5924         {
5925             cPairs = min(cPairs, font->total_kern_pairs);
5926             memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
5927             LeaveCriticalSection( &freetype_cs );
5928             return cPairs;
5929         }
5930         LeaveCriticalSection( &freetype_cs );
5931         return font->total_kern_pairs;
5932     }
5933
5934     font->total_kern_pairs = 0;
5935
5936     length = WineEngGetFontData(font, MS_KERN_TAG, 0, NULL, 0);
5937
5938     if (length == GDI_ERROR)
5939     {
5940         TRACE("no kerning data in the font\n");
5941         LeaveCriticalSection( &freetype_cs );
5942         return 0;
5943     }
5944
5945     buf = HeapAlloc(GetProcessHeap(), 0, length);
5946     if (!buf)
5947     {
5948         WARN("Out of memory\n");
5949         LeaveCriticalSection( &freetype_cs );
5950         return 0;
5951     }
5952
5953     WineEngGetFontData(font, MS_KERN_TAG, 0, buf, length);
5954
5955     /* build a glyph index to char code map */
5956     glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
5957     if (!glyph_to_char)
5958     {
5959         WARN("Out of memory allocating a glyph index to char code map\n");
5960         HeapFree(GetProcessHeap(), 0, buf);
5961         LeaveCriticalSection( &freetype_cs );
5962         return 0;
5963     }
5964
5965     if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
5966     {
5967         FT_UInt glyph_code;
5968         FT_ULong char_code;
5969
5970         glyph_code = 0;
5971         char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
5972
5973         TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
5974                font->ft_face->num_glyphs, glyph_code, char_code);
5975
5976         while (glyph_code)
5977         {
5978             /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? "  !" : "" );*/
5979
5980             /* FIXME: This doesn't match what Windows does: it does some fancy
5981              * things with duplicate glyph index to char code mappings, while
5982              * we just avoid overriding existing entries.
5983              */
5984             if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
5985                 glyph_to_char[glyph_code] = (USHORT)char_code;
5986
5987             char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
5988         }
5989     }
5990     else
5991     {
5992         ULONG n;
5993
5994         FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
5995         for (n = 0; n <= 65535; n++)
5996             glyph_to_char[n] = (USHORT)n;
5997     }
5998
5999     tt_kern_table = buf;
6000     nTables = GET_BE_WORD(tt_kern_table->nTables);
6001     TRACE("version %u, nTables %u\n",
6002            GET_BE_WORD(tt_kern_table->version), nTables);
6003
6004     tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
6005
6006     for (i = 0; i < nTables; i++)
6007     {
6008         struct TT_kern_subtable tt_kern_subtable_copy;
6009
6010         tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
6011         tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
6012         tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
6013
6014         TRACE("version %u, length %u, coverage %u, subtable format %u\n",
6015                tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
6016                tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
6017
6018         /* According to the TrueType specification this is the only format
6019          * that will be properly interpreted by Windows and OS/2
6020          */
6021         if (tt_kern_subtable_copy.coverage.bits.format == 0)
6022         {
6023             DWORD new_chunk, old_total = font->total_kern_pairs;
6024
6025             new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
6026                                                     glyph_to_char, NULL, 0);
6027             font->total_kern_pairs += new_chunk;
6028
6029             if (!font->kern_pairs)
6030                 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
6031                                              font->total_kern_pairs * sizeof(*font->kern_pairs));
6032             else
6033                 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
6034                                                font->total_kern_pairs * sizeof(*font->kern_pairs));
6035
6036             parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
6037                         glyph_to_char, font->kern_pairs + old_total, new_chunk);
6038         }
6039         else
6040             TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
6041
6042         tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
6043     }
6044
6045     HeapFree(GetProcessHeap(), 0, glyph_to_char);
6046     HeapFree(GetProcessHeap(), 0, buf);
6047
6048     if (cPairs && kern_pair)
6049     {
6050         cPairs = min(cPairs, font->total_kern_pairs);
6051         memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
6052         LeaveCriticalSection( &freetype_cs );
6053         return cPairs;
6054     }
6055     LeaveCriticalSection( &freetype_cs );
6056     return font->total_kern_pairs;
6057 }
6058
6059 #else /* HAVE_FREETYPE */
6060
6061 /*************************************************************************/
6062
6063 BOOL WineEngInit(void)
6064 {
6065     return FALSE;
6066 }
6067 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
6068 {
6069     return NULL;
6070 }
6071 BOOL WineEngDestroyFontInstance(HFONT hfont)
6072 {
6073     return FALSE;
6074 }
6075
6076 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
6077 {
6078     return 1;
6079 }
6080
6081 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
6082                                 LPWORD pgi, DWORD flags)
6083 {
6084     return GDI_ERROR;
6085 }
6086
6087 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
6088                              LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
6089                              const MAT2* lpmat)
6090 {
6091     ERR("called but we don't have FreeType\n");
6092     return GDI_ERROR;
6093 }
6094
6095 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
6096 {
6097     ERR("called but we don't have FreeType\n");
6098     return FALSE;
6099 }
6100
6101 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
6102                                   OUTLINETEXTMETRICW *potm)
6103 {
6104     ERR("called but we don't have FreeType\n");
6105     return 0;
6106 }
6107
6108 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
6109                          LPINT buffer)
6110 {
6111     ERR("called but we don't have FreeType\n");
6112     return FALSE;
6113 }
6114
6115 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
6116                              LPABC buffer)
6117 {
6118     ERR("called but we don't have FreeType\n");
6119     return FALSE;
6120 }
6121
6122 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
6123                               LPABC buffer)
6124 {
6125     ERR("called but we don't have FreeType\n");
6126     return FALSE;
6127 }
6128
6129 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
6130                                  INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
6131 {
6132     ERR("called but we don't have FreeType\n");
6133     return FALSE;
6134 }
6135
6136 BOOL WineEngGetTextExtentExPointI(GdiFont *font, const WORD *indices, INT count,
6137                                   INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
6138 {
6139     ERR("called but we don't have FreeType\n");
6140     return FALSE;
6141 }
6142
6143 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
6144                          DWORD cbData)
6145 {
6146     ERR("called but we don't have FreeType\n");
6147     return GDI_ERROR;
6148 }
6149
6150 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
6151 {
6152     ERR("called but we don't have FreeType\n");
6153     return 0;
6154 }
6155
6156 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
6157 {
6158     FIXME(":stub\n");
6159     return 1;
6160 }
6161
6162 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
6163 {
6164     FIXME(":stub\n");
6165     return TRUE;
6166 }
6167
6168 HANDLE WineEngAddFontMemResourceEx(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
6169 {
6170     FIXME(":stub\n");
6171     return NULL;
6172 }
6173
6174 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
6175 {
6176     FIXME(":stub\n");
6177     return DEFAULT_CHARSET;
6178 }
6179
6180 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
6181 {
6182     return FALSE;
6183 }
6184
6185 DWORD WineEngGetFontUnicodeRanges(GdiFont *font, LPGLYPHSET glyphset)
6186 {
6187     FIXME("(%p, %p): stub\n", font, glyphset);
6188     return 0;
6189 }
6190
6191 BOOL WineEngFontIsLinked(GdiFont *font)
6192 {
6193     return FALSE;
6194 }
6195
6196 /*************************************************************************
6197  *             GetRasterizerCaps   (GDI32.@)
6198  */
6199 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
6200 {
6201     lprs->nSize = sizeof(RASTERIZER_STATUS);
6202     lprs->wFlags = 0;
6203     lprs->nLanguageID = 0;
6204     return TRUE;
6205 }
6206
6207 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
6208 {
6209     ERR("called but we don't have FreeType\n");
6210     return 0;
6211 }
6212
6213 BOOL WineEngRealizationInfo(GdiFont *font, realization_info_t *info)
6214 {
6215     ERR("called but we don't have FreeType\n");
6216     return FALSE;
6217 }
6218
6219 #endif /* HAVE_FREETYPE */