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

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