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