git.oblomov.eu Git - wine/blob - dlls/gdi/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 #include <string.h>
  33 #include <dirent.h>
  34 #include <stdio.h>
  35 #include <assert.h>
  36
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winternl.h"
  40 #include "winerror.h"
  41 #include "winreg.h"
  42 #include "wingdi.h"
  43 #include "gdi.h"
  44 #include "gdi_private.h"
  45 #include "wine/unicode.h"
  46 #include "wine/debug.h"
  47 #include "wine/list.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(font);
  50
  51 #ifdef HAVE_FREETYPE
  52
  53 #ifdef HAVE_FT2BUILD_H
  54 #include <ft2build.h>
  55 #endif
  56 #ifdef HAVE_FREETYPE_FREETYPE_H
  57 #include <freetype/freetype.h>
  58 #endif
  59 #ifdef HAVE_FREETYPE_FTGLYPH_H
  60 #include <freetype/ftglyph.h>
  61 #endif
  62 #ifdef HAVE_FREETYPE_TTTABLES_H
  63 #include <freetype/tttables.h>
  64 #endif
  65 #ifdef HAVE_FREETYPE_FTSNAMES_H
  66 #include <freetype/ftsnames.h>
  67 #else
  68 # ifdef HAVE_FREETYPE_FTNAMES_H
  69 # include <freetype/ftnames.h>
  70 # endif
  71 #endif
  72 #ifdef HAVE_FREETYPE_TTNAMEID_H
  73 #include <freetype/ttnameid.h>
  74 #endif
  75 #ifdef HAVE_FREETYPE_FTOUTLN_H
  76 #include <freetype/ftoutln.h>
  77 #endif
  78 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
  79 #include <freetype/internal/sfnt.h>
  80 #endif
  81 #ifdef HAVE_FREETYPE_FTTRIGON_H
  82 #include <freetype/fttrigon.h>
  83 #endif
  84 #ifdef HAVE_FREETYPE_FTWINFNT_H
  85 #include <freetype/ftwinfnt.h>
  86 #endif
  87 #ifdef HAVE_FREETYPE_FTMODAPI_H
  88 #include <freetype/ftmodapi.h>
  89 #endif
  90
  91 #ifndef SONAME_LIBFREETYPE
  92 #define SONAME_LIBFREETYPE "libfreetype.so"
  93 #endif
  94
  95 #ifndef HAVE_FT_TRUETYPEENGINETYPE
  96 typedef enum
  97 {
  98     FT_TRUETYPE_ENGINE_TYPE_NONE = 0,
  99     FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,
 100     FT_TRUETYPE_ENGINE_TYPE_PATENTED
 101 } FT_TrueTypeEngineType;
 102 #endif
 103
 104 static FT_Library library = 0;
 105 typedef struct
 106 {
 107     FT_Int major;
 108     FT_Int minor;
 109     FT_Int patch;
 110 } FT_Version_t;
 111 static FT_Version_t FT_Version;
 112 static DWORD FT_SimpleVersion;
 113
 114 static void *ft_handle = NULL;
 115
 116 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
 117 MAKE_FUNCPTR(FT_Vector_Unit);
 118 MAKE_FUNCPTR(FT_Done_Face);
 119 MAKE_FUNCPTR(FT_Get_Char_Index);
 120 MAKE_FUNCPTR(FT_Get_Module);
 121 MAKE_FUNCPTR(FT_Get_Sfnt_Name);
 122 MAKE_FUNCPTR(FT_Get_Sfnt_Name_Count);
 123 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
 124 MAKE_FUNCPTR(FT_Init_FreeType);
 125 MAKE_FUNCPTR(FT_Load_Glyph);
 126 MAKE_FUNCPTR(FT_Matrix_Multiply);
 127 MAKE_FUNCPTR(FT_MulFix);
 128 MAKE_FUNCPTR(FT_New_Face);
 129 MAKE_FUNCPTR(FT_Outline_Get_Bitmap);
 130 MAKE_FUNCPTR(FT_Outline_Transform);
 131 MAKE_FUNCPTR(FT_Outline_Translate);
 132 MAKE_FUNCPTR(FT_Select_Charmap);
 133 MAKE_FUNCPTR(FT_Set_Pixel_Sizes);
 134 MAKE_FUNCPTR(FT_Vector_Transform);
 135 static void (*pFT_Library_Version)(FT_Library,FT_Int*,FT_Int*,FT_Int*);
 136 static FT_Error (*pFT_Load_Sfnt_Table)(FT_Face,FT_ULong,FT_Long,FT_Byte*,FT_ULong*);
 137 static FT_ULong (*pFT_Get_First_Char)(FT_Face,FT_UInt*);
 138 static FT_ULong (*pFT_Get_Next_Char)(FT_Face,FT_ULong,FT_UInt*);
 139 static FT_TrueTypeEngineType (*pFT_Get_TrueType_Engine_Type)(FT_Library);
 140 #ifdef HAVE_FREETYPE_FTWINFNT_H
 141 MAKE_FUNCPTR(FT_Get_WinFNT_Header);
 142 #endif
 143
 144 #ifdef HAVE_FONTCONFIG_FONTCONFIG_H
 145 #include <fontconfig/fontconfig.h>
 146 MAKE_FUNCPTR(FcConfigGetCurrent);
 147 MAKE_FUNCPTR(FcFontList);
 148 MAKE_FUNCPTR(FcFontSetDestroy);
 149 MAKE_FUNCPTR(FcInit);
 150 MAKE_FUNCPTR(FcObjectSetAdd);
 151 MAKE_FUNCPTR(FcObjectSetCreate);
 152 MAKE_FUNCPTR(FcObjectSetDestroy);
 153 MAKE_FUNCPTR(FcPatternCreate);
 154 MAKE_FUNCPTR(FcPatternDestroy);
 155 MAKE_FUNCPTR(FcPatternGetString);
 156 #ifndef SONAME_LIBFONTCONFIG
 157 #define SONAME_LIBFONTCONFIG "libfontconfig.so"
 158 #endif
 159 #endif
 160
 161 #undef MAKE_FUNCPTR
 162
 163 #ifndef ft_encoding_none
 164 #define FT_ENCODING_NONE ft_encoding_none
 165 #endif
 166 #ifndef ft_encoding_ms_symbol
 167 #define FT_ENCODING_MS_SYMBOL ft_encoding_symbol
 168 #endif
 169 #ifndef ft_encoding_unicode
 170 #define FT_ENCODING_UNICODE ft_encoding_unicode
 171 #endif
 172 #ifndef ft_encoding_apple_roman
 173 #define FT_ENCODING_APPLE_ROMAN ft_encoding_apple_roman
 174 #endif
 175
 176 #ifdef WORDS_BIGENDIAN
 177 #define GET_BE_WORD(x) (x)
 178 #else
 179 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
 180 #endif
 181
 182 /* This is bascially a copy of FT_Bitmap_Size with an extra element added */
 183 typedef struct {
 184     FT_Short height;
 185     FT_Short width;
 186     FT_Pos size;
 187     FT_Pos x_ppem;
 188     FT_Pos y_ppem;
 189     FT_Short internal_leading;
 190 } Bitmap_Size;
 191
 192 /* FT_Bitmap_Size gained 3 new elements between FreeType 2.1.4 and 2.1.5
 193    So to let this compile on older versions of FreeType we'll define the
 194    new structure here. */
 195 typedef struct {
 196     FT_Short height, width;
 197     FT_Pos size, x_ppem, y_ppem;
 198 } My_FT_Bitmap_Size;
 199
 200 typedef struct tagFace {
 201     struct list entry;
 202     WCHAR *StyleName;
 203     char *file;
 204     FT_Long face_index;
 205     BOOL Italic;
 206     BOOL Bold;
 207     FONTSIGNATURE fs;
 208     FONTSIGNATURE fs_links;
 209     FT_Fixed font_version;
 210     BOOL scalable;
 211     Bitmap_Size size;     /* set if face is a bitmap */
 212     BOOL external; /* TRUE if we should manually add this font to the registry */
 213     struct tagFamily *family;
 214 } Face;
 215
 216 typedef struct tagFamily {
 217     struct list entry;
 218     const WCHAR *FamilyName;
 219     struct list faces;
 220 } Family;
 221
 222 typedef struct {
 223     GLYPHMETRICS gm;
 224     INT adv; /* These three hold to widths of the unrotated chars */
 225     INT lsb;
 226     INT bbx;
 227     BOOL init;
 228 } GM;
 229
 230 typedef struct {
 231     FLOAT eM11, eM12;
 232     FLOAT eM21, eM22;
 233 } FMAT2;
 234
 235 typedef struct {
 236     DWORD hash;
 237     LOGFONTW lf;
 238     FMAT2 matrix;
 239     BOOL can_use_bitmap;
 240 } FONT_DESC;
 241
 242 typedef struct tagHFONTLIST {
 243     struct list entry;
 244     HFONT hfont;
 245 } HFONTLIST;
 246
 247 typedef struct {
 248     struct list entry;
 249     char *file_name;
 250     INT index;
 251     GdiFont *font;
 252 } CHILD_FONT;
 253
 254 struct tagGdiFont {
 255     struct list entry;
 256     FT_Face ft_face;
 257     LPWSTR name;
 258     int charset;
 259     int codepage;
 260     BOOL fake_italic;
 261     BOOL fake_bold;
 262     BYTE underline;
 263     BYTE strikeout;
 264     INT orientation;
 265     GM *gm;
 266     DWORD gmsize;
 267     struct list hfontlist;
 268     FONT_DESC font_desc;
 269     LONG aveWidth;
 270     SHORT yMax;
 271     SHORT yMin;
 272     OUTLINETEXTMETRICW *potm;
 273     DWORD total_kern_pairs;
 274     KERNINGPAIR *kern_pairs;
 275     FONTSIGNATURE fs;
 276     GdiFont *base_font;
 277     struct list child_fonts;
 278     LONG ppem;
 279 };
 280
 281 typedef struct {
 282     struct list entry;
 283     const WCHAR *font_name;
 284     struct list links;
 285 } SYSTEM_LINKS;
 286
 287 #define INIT_GM_SIZE 128
 288
 289 static struct list gdi_font_list = LIST_INIT(gdi_font_list);
 290 static struct list unused_gdi_font_list = LIST_INIT(unused_gdi_font_list);
 291 #define UNUSED_CACHE_SIZE 10
 292 static struct list child_font_list = LIST_INIT(child_font_list);
 293 static struct list system_links = LIST_INIT(system_links);
 294
 295 static struct list font_subst_list = LIST_INIT(font_subst_list);
 296
 297 static struct list font_list = LIST_INIT(font_list);
 298
 299 static const WCHAR defSerif[] = {'T','i','m','e','s',' ','N','e','w',' ',
 300                            'R','o','m','a','n','\0'};
 301 static const WCHAR defSans[] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
 302 static const WCHAR defFixed[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
 303
 304 static const WCHAR defSystem[] = {'S','y','s','t','e','m','\0'};
 305 static const WCHAR SystemW[] = {'S','y','s','t','e','m','\0'};
 306 static const WCHAR MSSansSerifW[] = {'M','S',' ','S','a','n','s',' ',
 307                                'S','e','r','i','f','\0'};
 308 static const WCHAR HelvW[] = {'H','e','l','v','\0'};
 309 static const WCHAR RegularW[] = {'R','e','g','u','l','a','r','\0'};
 310
 311 static const WCHAR fontsW[] = {'\\','F','o','n','t','s','\0'};
 312 static const WCHAR win9x_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 313                                            'W','i','n','d','o','w','s','\\',
 314                                            'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 315                                            'F','o','n','t','s','\0'};
 316
 317 static const WCHAR winnt_font_reg_key[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 318                                            'W','i','n','d','o','w','s',' ','N','T','\\',
 319                                            'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 320                                            'F','o','n','t','s','\0'};
 321
 322 static const WCHAR system_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s','\0'};
 323 static const WCHAR FixedSys_Value[] = {'F','I','X','E','D','F','O','N','.','F','O','N','\0'};
 324 static const WCHAR System_Value[] = {'F','O','N','T','S','.','F','O','N','\0'};
 325 static const WCHAR OEMFont_Value[] = {'O','E','M','F','O','N','T','.','F','O','N','\0'};
 326
 327 static const WCHAR * const SystemFontValues[4] = {
 328     System_Value,
 329     OEMFont_Value,
 330     FixedSys_Value,
 331     NULL
 332 };
 333
 334 static const WCHAR external_fonts_reg_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
 335                                                'F','o','n','t','s','\\','E','x','t','e','r','n','a','l',' ','F','o','n','t','s','\0'};
 336
 337 static const WCHAR ArabicW[] = {'A','r','a','b','i','c','\0'};
 338 static const WCHAR BalticW[] = {'B','a','l','t','i','c','\0'};
 339 static const WCHAR CHINESE_BIG5W[] = {'C','H','I','N','E','S','E','_','B','I','G','5','\0'};
 340 static const WCHAR CHINESE_GB2312W[] = {'C','H','I','N','E','S','E','_','G','B','2','3','1','2','\0'};
 341 static const WCHAR Central_EuropeanW[] = {'C','e','n','t','r','a','l',' ',
 342                                     'E','u','r','o','p','e','a','n','\0'};
 343 static const WCHAR CyrillicW[] = {'C','y','r','i','l','l','i','c','\0'};
 344 static const WCHAR GreekW[] = {'G','r','e','e','k','\0'};
 345 static const WCHAR HangulW[] = {'H','a','n','g','u','l','\0'};
 346 static const WCHAR Hangul_Johab_W[] = {'H','a','n','g','u','l','(','J','o','h','a','b',')','\0'};
 347 static const WCHAR HebrewW[] = {'H','e','b','r','e','w','\0'};
 348 static const WCHAR JapaneseW[] = {'J','a','p','a','n','e','s','e','\0'};
 349 static const WCHAR SymbolW[] = {'S','y','m','b','o','l','\0'};
 350 static const WCHAR ThaiW[] = {'T','h','a','i','\0'};
 351 static const WCHAR TurkishW[] = {'T','u','r','k','i','s','h','\0'};
 352 static const WCHAR VietnameseW[] = {'V','i','e','t','n','a','m','e','s','e','\0'};
 353 static const WCHAR WesternW[] = {'W','e','s','t','e','r','n','\0'};
 354 static const WCHAR OEM_DOSW[] = {'O','E','M','/','D','O','S','\0'};
 355
 356 static const WCHAR * const ElfScriptsW[32] = { /* these are in the order of the fsCsb[0] bits */
 357     WesternW, /*00*/
 358     Central_EuropeanW,
 359     CyrillicW,
 360     GreekW,
 361     TurkishW,
 362     HebrewW,
 363     ArabicW,
 364     BalticW,
 365     VietnameseW, /*08*/
 366     NULL, NULL, NULL, NULL, NULL, NULL, NULL, /*15*/
 367     ThaiW,
 368     JapaneseW,
 369     CHINESE_GB2312W,
 370     HangulW,
 371     CHINESE_BIG5W,
 372     Hangul_Johab_W,
 373     NULL, NULL, /*23*/
 374     NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 375     SymbolW /*31*/
 376 };
 377
 378 typedef struct {
 379     WCHAR *name;
 380     INT charset;
 381 } NameCs;
 382
 383 typedef struct tagFontSubst {
 384     struct list entry;
 385     NameCs from;
 386     NameCs to;
 387 } FontSubst;
 388
 389 static BOOL have_installed_roman_font = FALSE; /* CreateFontInstance will fail if this is still FALSE */
 390
 391 static const WCHAR font_mutex_nameW[] = {'_','_','W','I','N','E','_','F','O','N','T','_','M','U','T','E','X','_','_','\0'};
 392
 393
 394 /****************************************
 395  *   Notes on .fon files
 396  *
 397  * The fonts System, FixedSys and Terminal are special.  There are typically multiple
 398  * versions installed for different resolutions and codepages.  Windows stores which one to use
 399  * in HKEY_CURRENT_CONFIG\\Software\\Fonts.
 400  *    Key            Meaning
 401  *  FIXEDFON.FON    FixedSys
 402  *  FONTS.FON       System
 403  *  OEMFONT.FON     Terminal
 404  *  LogPixels       Current dpi set by the display control panel applet
 405  *                  (HKLM\\Software\\Microsft\\Windows NT\\CurrentVersion\\FontDPI
 406  *                  also has a LogPixels value that appears to mirror this)
 407  *
 408  * On my system these values have data: vgafix.fon, vgasys.fon, vga850.fon and 96 respectively
 409  * (vgaoem.fon would be your oemfont.fon if you have a US setup).
 410  * If the resolution is changed to be >= 109dpi then the fonts goto 8514fix, 8514sys and 8514oem
 411  * (not sure what's happening to the oem codepage here). 109 is nicely halfway between 96 and 120dpi,
 412  * so that makes sense.
 413  *
 414  * Additionally Windows also loads the fonts listed in the [386enh] section of system.ini (this doesn't appear
 415  * to be mapped into the registry on Windows 2000 at least).
 416  * I have
 417  * woafont=app850.fon
 418  * ega80woa.fon=ega80850.fon
 419  * ega40woa.fon=ega40850.fon
 420  * cga80woa.fon=cga80850.fon
 421  * cga40woa.fon=cga40850.fon
 422  */
 423
 424
 425 static inline BOOL is_win9x(void)
 426 {
 427     return GetVersion() & 0x80000000;
 428 }
 429 /*
 430    This function builds an FT_Fixed from a float. It puts the integer part
 431    in the highest 16 bits and the decimal part in the lowest 16 bits of the FT_Fixed.
 432    It fails if the integer part of the float number is greater than SHORT_MAX.
 433 */
 434 static inline FT_Fixed FT_FixedFromFloat(float f)
 435 {
 436         short value = f;
 437         unsigned short fract = (f - value) * 0xFFFF;
 438         return (FT_Fixed)((long)value << 16 | (unsigned long)fract);
 439 }
 440
 441 /*
 442    This function builds an FT_Fixed from a FIXED. It simply put f.value
 443    in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
 444 */
 445 static inline FT_Fixed FT_FixedFromFIXED(FIXED f)
 446 {
 447         return (FT_Fixed)((long)f.value << 16 | (unsigned long)f.fract);
 448 }
 449
 450
 451 static Face *find_face_from_filename(const WCHAR *file_name, const WCHAR *face_name)
 452 {
 453     Family *family;
 454     Face *face;
 455     const char *file;
 456     DWORD len = WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, NULL, 0, NULL, NULL);
 457     char *file_nameA = HeapAlloc(GetProcessHeap(), 0, len);
 458
 459     WideCharToMultiByte(CP_UNIXCP, 0, file_name, -1, file_nameA, len, NULL, NULL);
 460     TRACE("looking for file %s name %s\n", debugstr_a(file_nameA), debugstr_w(face_name));
 461
 462     LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
 463     {
 464         if(face_name && strcmpiW(face_name, family->FamilyName))
 465             continue;
 466         LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
 467         {
 468             file = strrchr(face->file, '/');
 469             if(!file)
 470                 file = face->file;
 471             else
 472                 file++;
 473             if(!strcasecmp(file, file_nameA))
 474             {
 475                 HeapFree(GetProcessHeap(), 0, file_nameA);
 476                 return face;
 477             }
 478         }
 479     }
 480     HeapFree(GetProcessHeap(), 0, file_nameA);
 481     return NULL;
 482 }
 483
 484 static Family *find_family_from_name(const WCHAR *name)
 485 {
 486     Family *family;
 487
 488     LIST_FOR_EACH_ENTRY(family, &font_list, Family, entry)
 489     {
 490         if(!strcmpiW(family->FamilyName, name))
 491             return family;
 492     }
 493
 494     return NULL;
 495 }
 496
 497 static void DumpSubstList(void)
 498 {
 499     FontSubst *psub;
 500
 501     LIST_FOR_EACH_ENTRY(psub, &font_subst_list, FontSubst, entry)
 502     {
 503         if(psub->from.charset != -1 || psub->to.charset != -1)
 504             TRACE("%s:%d -> %s:%d\n", debugstr_w(psub->from.name),
 505               psub->from.charset, debugstr_w(psub->to.name), psub->to.charset);
 506         else
 507             TRACE("%s -> %s\n", debugstr_w(psub->from.name),
 508                   debugstr_w(psub->to.name));
 509     }
 510     return;
 511 }
 512
 513 static LPWSTR strdupW(LPCWSTR p)
 514 {
 515     LPWSTR ret;
 516     DWORD len = (strlenW(p) + 1) * sizeof(WCHAR);
 517     ret = HeapAlloc(GetProcessHeap(), 0, len);
 518     memcpy(ret, p, len);
 519     return ret;
 520 }
 521
 522 static LPSTR strdupA(LPCSTR p)
 523 {
 524     LPSTR ret;
 525     DWORD len = (strlen(p) + 1);
 526     ret = HeapAlloc(GetProcessHeap(), 0, len);
 527     memcpy(ret, p, len);
 528     return ret;
 529 }
 530
 531 static FontSubst *get_font_subst(const struct list *subst_list, const WCHAR *from_name,
 532                                  INT from_charset)
 533 {
 534     FontSubst *element;
 535
 536     LIST_FOR_EACH_ENTRY(element, subst_list, FontSubst, entry)
 537     {
 538         if(!strcmpiW(element->from.name, from_name) &&
 539            (element->from.charset == from_charset ||
 540             element->from.charset == -1))
 541             return element;
 542     }
 543
 544     return NULL;
 545 }
 546
 547 #define ADD_FONT_SUBST_FORCE  1
 548
 549 static BOOL add_font_subst(struct list *subst_list, FontSubst *subst, INT flags)
 550 {
 551     FontSubst *from_exist, *to_exist;
 552
 553     from_exist = get_font_subst(subst_list, subst->from.name, subst->from.charset);
 554
 555     if(from_exist && (flags & ADD_FONT_SUBST_FORCE))
 556     {
 557         list_remove(&from_exist->entry);
 558         HeapFree(GetProcessHeap(), 0, &from_exist->from.name);
 559         HeapFree(GetProcessHeap(), 0, &from_exist->to.name);
 560         HeapFree(GetProcessHeap(), 0, from_exist);
 561         from_exist = NULL;
 562     }
 563
 564     if(!from_exist)
 565     {
 566         to_exist = get_font_subst(subst_list, subst->to.name, subst->to.charset);
 567
 568         if(to_exist)
 569         {
 570             HeapFree(GetProcessHeap(), 0, subst->to.name);
 571             subst->to.name = strdupW(to_exist->to.name);
 572         }
 573
 574         list_add_tail(subst_list, &subst->entry);
 575
 576         return TRUE;
 577     }
 578
 579     HeapFree(GetProcessHeap(), 0, subst->from.name);
 580     HeapFree(GetProcessHeap(), 0, subst->to.name);
 581     HeapFree(GetProcessHeap(), 0, subst);
 582     return FALSE;
 583 }
 584
 585 static void split_subst_info(NameCs *nc, LPSTR str)
 586 {
 587     CHAR *p = strrchr(str, ',');
 588     DWORD len;
 589
 590     nc->charset = -1;
 591     if(p && *(p+1)) {
 592         nc->charset = strtol(p+1, NULL, 10);
 593         *p = '\0';
 594     }
 595     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 596     nc->name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 597     MultiByteToWideChar(CP_ACP, 0, str, -1, nc->name, len);
 598 }
 599
 600 static void LoadSubstList(void)
 601 {
 602     FontSubst *psub;
 603     HKEY hkey;
 604     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
 605     LPSTR value;
 606     LPVOID data;
 607
 608     if(RegOpenKeyA(HKEY_LOCAL_MACHINE,
 609                    "Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes",
 610                    &hkey) == ERROR_SUCCESS) {
 611
 612         RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 613                          &valuelen, &datalen, NULL, NULL);
 614
 615         valuelen++; /* returned value doesn't include room for '\0' */
 616         value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
 617         data = HeapAlloc(GetProcessHeap(), 0, datalen);
 618
 619         dlen = datalen;
 620         vlen = valuelen;
 621         while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
 622                             &dlen) == ERROR_SUCCESS) {
 623             TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
 624
 625             psub = HeapAlloc(GetProcessHeap(), 0, sizeof(*psub));
 626             split_subst_info(&psub->from, value);
 627             split_subst_info(&psub->to, data);
 628
 629             /* Win 2000 doesn't allow mapping between different charsets
 630                or mapping of DEFAULT_CHARSET */
 631             if((psub->to.charset != psub->from.charset) ||
 632                psub->to.charset == DEFAULT_CHARSET) {
 633                 HeapFree(GetProcessHeap(), 0, psub->to.name);
 634                 HeapFree(GetProcessHeap(), 0, psub->from.name);
 635                 HeapFree(GetProcessHeap(), 0, psub);
 636             } else {
 637                 add_font_subst(&font_subst_list, psub, 0);
 638             }
 639             /* reset dlen and vlen */
 640             dlen = datalen;
 641             vlen = valuelen;
 642         }
 643         HeapFree(GetProcessHeap(), 0, data);
 644         HeapFree(GetProcessHeap(), 0, value);
 645         RegCloseKey(hkey);
 646     }
 647 }
 648
 649 static WCHAR *get_familyname(FT_Face ft_face)
 650 {
 651     WCHAR *family = NULL;
 652     FT_SfntName name;
 653     FT_UInt num_names, name_index, i;
 654
 655     if(FT_IS_SFNT(ft_face))
 656     {
 657         num_names = pFT_Get_Sfnt_Name_Count(ft_face);
 658
 659         for(name_index = 0; name_index < num_names; name_index++)
 660         {
 661             if(!pFT_Get_Sfnt_Name(ft_face, name_index, &name))
 662             {
 663                 if((name.name_id == TT_NAME_ID_FONT_FAMILY) &&
 664                    (name.language_id == GetUserDefaultLCID()) &&
 665                    (name.platform_id == TT_PLATFORM_MICROSOFT) &&
 666                    (name.encoding_id == TT_MS_ID_UNICODE_CS))
 667                 {
 668                     /* String is not nul terminated and string_len is a byte length. */
 669                     family = HeapAlloc(GetProcessHeap(), 0, name.string_len + 2);
 670                     for(i = 0; i < name.string_len / 2; i++)
 671                     {
 672                         WORD *tmp = (WORD *)&name.string[i * 2];
 673                         family[i] = GET_BE_WORD(*tmp);
 674                     }
 675                     family[i] = 0;
 676
 677                     TRACE("Got localised name %s\n", debugstr_w(family));
 678                     return family;
 679                 }
 680             }
 681         }
 682     }
 683
 684     return NULL;
 685 }
 686
 687
 688 #define ADDFONT_EXTERNAL_FONT 0x01
 689 #define ADDFONT_FORCE_BITMAP  0x02
 690 static BOOL AddFontFileToList(const char *file, char *fake_family, DWORD flags)
 691 {
 692     FT_Face ft_face;
 693     TT_OS2 *pOS2;
 694     TT_Header *pHeader = NULL;
 695     WCHAR *english_family, *localised_family, *StyleW;
 696     DWORD len;
 697     Family *family;
 698     Face *face;
 699     struct list *family_elem_ptr, *face_elem_ptr;
 700     FT_Error err;
 701     FT_Long face_index = 0, num_faces;
 702 #ifdef HAVE_FREETYPE_FTWINFNT_H
 703     FT_WinFNT_HeaderRec winfnt_header;
 704 #endif
 705     int i, bitmap_num, internal_leading;
 706     FONTSIGNATURE fs;
 707
 708     do {
 709         char *family_name = fake_family;
 710
 711         TRACE("Loading font file %s index %ld\n", debugstr_a(file), face_index);
 712         if((err = pFT_New_Face(library, file, face_index, &ft_face)) != 0) {
 713             WARN("Unable to load font file %s err = %x\n", debugstr_a(file), err);
 714             return FALSE;
 715         }
 716
 717         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*/
 718             WARN("Ignoring font %s\n", debugstr_a(file));
 719             pFT_Done_Face(ft_face);
 720             return FALSE;
 721         }
 722
 723         /* There are too many bugs in FreeType < 2.1.9 for bitmap font support */
 724         if(!FT_IS_SCALABLE(ft_face) && FT_SimpleVersion < ((2 << 16) | (1 << 8) | (9 << 0))) {
 725             WARN("FreeType version < 2.1.9, skipping bitmap font %s\n", debugstr_a(file));
 726             pFT_Done_Face(ft_face);
 727             return FALSE;
 728         }
 729
 730         if(FT_IS_SFNT(ft_face) && (!pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2) ||
 731            !pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea) ||
 732            !(pHeader = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_head)))) {
 733             TRACE("Font file %s lacks either an OS2, HHEA or HEAD table.\n"
 734                   "Skipping this font.\n", debugstr_a(file));
 735             pFT_Done_Face(ft_face);
 736             return FALSE;
 737         }
 738
 739         if(!ft_face->family_name || !ft_face->style_name) {
 740             TRACE("Font file %s lacks either a family or style name\n", debugstr_a(file));
 741             pFT_Done_Face(ft_face);
 742             return FALSE;
 743         }
 744
 745         if(!family_name)
 746             family_name = ft_face->family_name;
 747
 748         bitmap_num = 0;
 749         do {
 750             My_FT_Bitmap_Size *size = NULL;
 751
 752             if(!FT_IS_SCALABLE(ft_face))
 753                 size = (My_FT_Bitmap_Size *)ft_face->available_sizes + bitmap_num;
 754
 755             len = MultiByteToWideChar(CP_ACP, 0, family_name, -1, NULL, 0);
 756             english_family = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 757             MultiByteToWideChar(CP_ACP, 0, family_name, -1, english_family, len);
 758
 759             localised_family = NULL;
 760             if(!fake_family) {
 761                 localised_family = get_familyname(ft_face);
 762                 if(localised_family && !strcmpW(localised_family, english_family)) {
 763                     HeapFree(GetProcessHeap(), 0, localised_family);
 764                     localised_family = NULL;
 765                 }
 766             }
 767
 768             family = NULL;
 769             LIST_FOR_EACH(family_elem_ptr, &font_list) {
 770                 family = LIST_ENTRY(family_elem_ptr, Family, entry);
 771                 if(!strcmpW(family->FamilyName, localised_family ? localised_family : english_family))
 772                     break;
 773                 family = NULL;
 774             }
 775             if(!family) {
 776                 family = HeapAlloc(GetProcessHeap(), 0, sizeof(*family));
 777                 family->FamilyName = strdupW(localised_family ? localised_family : english_family);
 778                 list_init(&family->faces);
 779                 list_add_tail(&font_list, &family->entry);
 780
 781                 if(localised_family) {
 782                     FontSubst *subst = HeapAlloc(GetProcessHeap(), 0, sizeof(*subst));
 783                     subst->from.name = strdupW(english_family);
 784                     subst->from.charset = -1;
 785                     subst->to.name = strdupW(localised_family);
 786                     subst->to.charset = -1;
 787                     add_font_subst(&font_subst_list, subst, 0);
 788                 }
 789             }
 790             HeapFree(GetProcessHeap(), 0, localised_family);
 791             HeapFree(GetProcessHeap(), 0, english_family);
 792
 793             len = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0);
 794             StyleW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 795             MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, StyleW, len);
 796
 797             internal_leading = 0;
 798             memset(&fs, 0, sizeof(fs));
 799
 800             pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
 801             if(pOS2) {
 802                 fs.fsCsb[0] = pOS2->ulCodePageRange1;
 803                 fs.fsCsb[1] = pOS2->ulCodePageRange2;
 804                 fs.fsUsb[0] = pOS2->ulUnicodeRange1;
 805                 fs.fsUsb[1] = pOS2->ulUnicodeRange2;
 806                 fs.fsUsb[2] = pOS2->ulUnicodeRange3;
 807                 fs.fsUsb[3] = pOS2->ulUnicodeRange4;
 808                 if(pOS2->version == 0) {
 809                     FT_UInt dummy;
 810
 811                     if(!pFT_Get_First_Char || (pFT_Get_First_Char( ft_face, &dummy ) < 0x100))
 812                         fs.fsCsb[0] |= 1;
 813                     else
 814                         fs.fsCsb[0] |= 1L << 31;
 815                 }
 816             }
 817 #ifdef HAVE_FREETYPE_FTWINFNT_H
 818             else if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header)) {
 819                 CHARSETINFO csi;
 820                 TRACE("pix_h %d charset %d dpi %dx%d pt %d\n", winfnt_header.pixel_height, winfnt_header.charset,
 821                       winfnt_header.vertical_resolution,winfnt_header.horizontal_resolution, winfnt_header.nominal_point_size);
 822                 if(TranslateCharsetInfo((DWORD*)(UINT_PTR)winfnt_header.charset, &csi, TCI_SRCCHARSET))
 823                     memcpy(&fs, &csi.fs, sizeof(csi.fs));
 824                 internal_leading = winfnt_header.internal_leading;
 825             }
 826 #endif
 827
 828             face_elem_ptr = list_head(&family->faces);
 829             while(face_elem_ptr) {
 830                 face = LIST_ENTRY(face_elem_ptr, Face, entry);
 831                 face_elem_ptr = list_next(&family->faces, face_elem_ptr);
 832                 if(!strcmpW(face->StyleName, StyleW) &&
 833                    (FT_IS_SCALABLE(ft_face) || ((size->y_ppem == face->size.y_ppem) && !memcmp(&fs, &face->fs, sizeof(fs)) ))) {
 834                     TRACE("Already loaded font %s %s original version is %lx, this version is %lx\n",
 835                           debugstr_w(family->FamilyName), debugstr_w(StyleW),
 836                           face->font_version,  pHeader ? pHeader->Font_Revision : 0);
 837
 838                     if(fake_family) {
 839                         TRACE("This font is a replacement but the original really exists, so we'll skip the replacement\n");
 840                         HeapFree(GetProcessHeap(), 0, StyleW);
 841                         pFT_Done_Face(ft_face);
 842                         return FALSE;
 843                     }
 844                     if(!pHeader || pHeader->Font_Revision <= face->font_version) {
 845                         TRACE("Original font is newer so skipping this one\n");
 846                         HeapFree(GetProcessHeap(), 0, StyleW);
 847                         pFT_Done_Face(ft_face);
 848                         return FALSE;
 849                     } else {
 850                         TRACE("Replacing original with this one\n");
 851                         list_remove(&face->entry);
 852                         HeapFree(GetProcessHeap(), 0, face->file);
 853                         HeapFree(GetProcessHeap(), 0, face->StyleName);
 854                         HeapFree(GetProcessHeap(), 0, face);
 855                         break;
 856                     }
 857                 }
 858             }
 859             face = HeapAlloc(GetProcessHeap(), 0, sizeof(*face));
 860             list_add_tail(&family->faces, &face->entry);
 861             face->StyleName = StyleW;
 862             face->file = HeapAlloc(GetProcessHeap(),0,strlen(file)+1);
 863             strcpy(face->file, file);
 864             face->face_index = face_index;
 865             face->Italic = (ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 1 : 0;
 866             face->Bold = (ft_face->style_flags & FT_STYLE_FLAG_BOLD) ? 1 : 0;
 867             face->font_version = pHeader ? pHeader->Font_Revision : 0;
 868             face->family = family;
 869             face->external = (flags & ADDFONT_EXTERNAL_FONT) ? TRUE : FALSE;
 870             memcpy(&face->fs, &fs, sizeof(face->fs));
 871             memset(&face->fs_links, 0, sizeof(face->fs_links));
 872
 873             if(FT_IS_SCALABLE(ft_face)) {
 874                 memset(&face->size, 0, sizeof(face->size));
 875                 face->scalable = TRUE;
 876             } else {
 877                 TRACE("Adding bitmap size h %d w %d size %ld x_ppem %ld y_ppem %ld\n",
 878                       size->height, size->width, size->size >> 6,
 879                       size->x_ppem >> 6, size->y_ppem >> 6);
 880                 face->size.height = size->height;
 881                 face->size.width = size->width;
 882                 face->size.size = size->size;
 883                 face->size.x_ppem = size->x_ppem;
 884                 face->size.y_ppem = size->y_ppem;
 885                 face->size.internal_leading = internal_leading;
 886                 face->scalable = FALSE;
 887             }
 888
 889             TRACE("fsCsb = %08lx %08lx/%08lx %08lx %08lx %08lx\n",
 890                   face->fs.fsCsb[0], face->fs.fsCsb[1],
 891                   face->fs.fsUsb[0], face->fs.fsUsb[1],
 892                   face->fs.fsUsb[2], face->fs.fsUsb[3]);
 893
 894
 895             if(face->fs.fsCsb[0] == 0) { /* let's see if we can find any interesting cmaps */
 896                 for(i = 0; i < ft_face->num_charmaps; i++) {
 897                     switch(ft_face->charmaps[i]->encoding) {
 898                     case FT_ENCODING_UNICODE:
 899                     case FT_ENCODING_APPLE_ROMAN:
 900                         face->fs.fsCsb[0] |= 1;
 901                         break;
 902                     case FT_ENCODING_MS_SYMBOL:
 903                         face->fs.fsCsb[0] |= 1L << 31;
 904                         break;
 905                     default:
 906                         break;
 907                     }
 908                 }
 909             }
 910
 911             if(face->fs.fsCsb[0] & ~(1L << 31))
 912                 have_installed_roman_font = TRUE;
 913         } while(!FT_IS_SCALABLE(ft_face) && ++bitmap_num < ft_face->num_fixed_sizes);
 914
 915         num_faces = ft_face->num_faces;
 916         pFT_Done_Face(ft_face);
 917         TRACE("Added font %s %s\n", debugstr_w(family->FamilyName),
 918               debugstr_w(StyleW));
 919     } while(num_faces > ++face_index);
 920     return TRUE;
 921 }
 922
 923 static void DumpFontList(void)
 924 {
 925     Family *family;
 926     Face *face;
 927     struct list *family_elem_ptr, *face_elem_ptr;
 928
 929     LIST_FOR_EACH(family_elem_ptr, &font_list) {
 930         family = LIST_ENTRY(family_elem_ptr, Family, entry);
 931         TRACE("Family: %s\n", debugstr_w(family->FamilyName));
 932         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
 933             face = LIST_ENTRY(face_elem_ptr, Face, entry);
 934             TRACE("\t%s\t%08lx", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
 935             if(!face->scalable)
 936                 TRACE(" %d", face->size.height);
 937             TRACE("\n");
 938         }
 939     }
 940     return;
 941 }
 942
 943 /***********************************************************
 944  * The replacement list is a way to map an entire font
 945  * family onto another family.  For example adding
 946  *
 947  * [HKCU\Software\Wine\Fonts\Replacements]
 948  * "Wingdings"="Winedings"
 949  *
 950  * would enumerate the Winedings font both as Winedings and
 951  * Wingdings.  However if a real Wingdings font is present the
 952  * replacement does not take place.
 953  *
 954  */
 955 static void LoadReplaceList(void)
 956 {
 957     HKEY hkey;
 958     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
 959     LPSTR value;
 960     LPVOID data;
 961     Family *family;
 962     Face *face;
 963     struct list *family_elem_ptr, *face_elem_ptr;
 964     WCHAR old_nameW[200];
 965
 966     /* @@ Wine registry key: HKCU\Software\Wine\Fonts\Replacements */
 967     if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey) == ERROR_SUCCESS)
 968     {
 969         RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 970                          &valuelen, &datalen, NULL, NULL);
 971
 972         valuelen++; /* returned value doesn't include room for '\0' */
 973         value = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(CHAR));
 974         data = HeapAlloc(GetProcessHeap(), 0, datalen);
 975
 976         dlen = datalen;
 977         vlen = valuelen;
 978         while(RegEnumValueA(hkey, i++, value, &vlen, NULL, &type, data,
 979                             &dlen) == ERROR_SUCCESS) {
 980             TRACE("Got %s=%s\n", debugstr_a(value), debugstr_a(data));
 981             /* "NewName"="Oldname" */
 982             if(!MultiByteToWideChar(CP_ACP, 0, data, -1, old_nameW, sizeof(old_nameW)/sizeof(WCHAR)))
 983                 break;
 984
 985             /* Find the old family and hence all of the font files
 986                in that family */
 987             LIST_FOR_EACH(family_elem_ptr, &font_list) {
 988                 family = LIST_ENTRY(family_elem_ptr, Family, entry);
 989                 if(!strcmpiW(family->FamilyName, old_nameW)) {
 990                     LIST_FOR_EACH(face_elem_ptr, &family->faces) {
 991                         face = LIST_ENTRY(face_elem_ptr, Face, entry);
 992                         TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
 993                               debugstr_w(face->StyleName), value);
 994                         /* Now add a new entry with the new family name */
 995                         AddFontFileToList(face->file, value, ADDFONT_FORCE_BITMAP | (face->external ? ADDFONT_EXTERNAL_FONT : 0));
 996                     }
 997                     break;
 998                 }
 999             }
1000             /* reset dlen and vlen */
1001             dlen = datalen;
1002             vlen = valuelen;
1003         }
1004         HeapFree(GetProcessHeap(), 0, data);
1005         HeapFree(GetProcessHeap(), 0, value);
1006         RegCloseKey(hkey);
1007     }
1008 }
1009
1010 /*************************************************************
1011  * init_system_links
1012  */
1013 static BOOL init_system_links(void)
1014 {
1015     static const WCHAR system_link[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1016                                         'W','i','n','d','o','w','s',' ','N','T','\\',
1017                                         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','F','o','n','t','L','i','n','k','\\',
1018                                         'S','y','s','t','e','m','L','i','n','k',0};
1019     HKEY hkey;
1020     BOOL ret = FALSE;
1021     DWORD type, max_val, max_data, val_len, data_len, index;
1022     WCHAR *value, *data;
1023     WCHAR *entry, *next;
1024     SYSTEM_LINKS *font_link, *system_font_link;
1025     CHILD_FONT *child_font;
1026     static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
1027     static const WCHAR tahoma_ttf[] = {'t','a','h','o','m','a','.','t','t','f',0};
1028     static const WCHAR System[] = {'S','y','s','t','e','m',0};
1029     FONTSIGNATURE fs;
1030     Family *family;
1031     Face *face;
1032     FontSubst *psub;
1033
1034     if(RegOpenKeyW(HKEY_LOCAL_MACHINE, system_link, &hkey) == ERROR_SUCCESS)
1035     {
1036         RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_val, &max_data, NULL, NULL);
1037         value = HeapAlloc(GetProcessHeap(), 0, (max_val + 1) * sizeof(WCHAR));
1038         data = HeapAlloc(GetProcessHeap(), 0, max_data);
1039         val_len = max_val + 1;
1040         data_len = max_data;
1041         index = 0;
1042         while(RegEnumValueW(hkey, index++, value, &val_len, NULL, &type, (LPBYTE)data, &data_len) == ERROR_SUCCESS)
1043         {
1044             TRACE("%s:\n", debugstr_w(value));
1045
1046             memset(&fs, 0, sizeof(fs));
1047             font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*font_link));
1048             psub = get_font_subst(&font_subst_list, value, -1);
1049             font_link->font_name = (psub)? strdupW(psub->to.name) : strdupW(value);
1050             list_init(&font_link->links);
1051             for(entry = data; (char*)entry < (char*)data + data_len && *entry != 0; entry = next)
1052             {
1053                 WCHAR *face_name;
1054                 CHILD_FONT *child_font;
1055
1056                 TRACE("\t%s\n", debugstr_w(entry));
1057
1058                 next = entry + strlenW(entry) + 1;
1059
1060                 face_name = strchrW(entry, ',');
1061                 if(face_name)
1062                 {
1063                     *face_name++ = 0;
1064                     while(isspaceW(*face_name))
1065                         face_name++;
1066
1067                     psub = get_font_subst(&font_subst_list, face_name, -1);
1068                     if(psub)
1069                         face_name = psub->to.name;
1070                 }
1071                 face = find_face_from_filename(entry, face_name);
1072                 if(!face)
1073                 {
1074                     TRACE("Unable to find file %s face name %s\n", debugstr_w(entry), debugstr_w(face_name));
1075                     continue;
1076                 }
1077
1078                 child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1079                 child_font->file_name = strdupA(face->file);
1080                 child_font->index = face->face_index;
1081                 child_font->font = NULL;
1082                 fs.fsCsb[0] |= face->fs.fsCsb[0];
1083                 fs.fsCsb[1] |= face->fs.fsCsb[1];
1084                 TRACE("Adding file %s index %d\n", child_font->file_name, child_font->index);
1085                 list_add_tail(&font_link->links, &child_font->entry);
1086             }
1087             family = find_family_from_name(font_link->font_name);
1088             if(family)
1089             {
1090                 LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
1091                 {
1092                     memcpy(&face->fs_links, &fs, sizeof(fs));
1093                 }
1094             }
1095             list_add_tail(&system_links, &font_link->entry);
1096             val_len = max_val + 1;
1097             data_len = max_data;
1098         }
1099
1100         HeapFree(GetProcessHeap(), 0, value);
1101         HeapFree(GetProcessHeap(), 0, data);
1102         RegCloseKey(hkey);
1103     }
1104
1105     /* Explicitly add an entry for the system font, this links to Tahoma and any links
1106        that Tahoma has */
1107
1108     system_font_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*system_font_link));
1109     system_font_link->font_name = strdupW(System);
1110     list_init(&system_font_link->links);
1111
1112     face = find_face_from_filename(tahoma_ttf, Tahoma);
1113     if(face)
1114     {
1115         child_font = HeapAlloc(GetProcessHeap(), 0, sizeof(*child_font));
1116         child_font->file_name = strdupA(face->file);
1117         child_font->index = face->face_index;
1118         child_font->font = NULL;
1119         TRACE("Found Tahoma in %s index %d\n", child_font->file_name, child_font->index);
1120         list_add_tail(&system_font_link->links, &child_font->entry);
1121     }
1122     LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
1123     {
1124         if(!strcmpiW(font_link->font_name, Tahoma))
1125         {
1126             CHILD_FONT *font_link_entry;
1127             LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
1128             {
1129                 CHILD_FONT *new_child;
1130                 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
1131                 new_child->file_name = strdupA(font_link_entry->file_name);
1132                 new_child->index = font_link_entry->index;
1133                 new_child->font = NULL;
1134                 list_add_tail(&system_font_link->links, &new_child->entry);
1135             }
1136             break;
1137         }
1138     }
1139     list_add_tail(&system_links, &system_font_link->entry);
1140     return ret;
1141 }
1142
1143 static BOOL ReadFontDir(const char *dirname, BOOL external_fonts)
1144 {
1145     DIR *dir;
1146     struct dirent *dent;
1147     char path[MAX_PATH];
1148
1149     TRACE("Loading fonts from %s\n", debugstr_a(dirname));
1150
1151     dir = opendir(dirname);
1152     if(!dir) {
1153         WARN("Can't open directory %s\n", debugstr_a(dirname));
1154         return FALSE;
1155     }
1156     while((dent = readdir(dir)) != NULL) {
1157         struct stat statbuf;
1158
1159         if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
1160             continue;
1161
1162         TRACE("Found %s in %s\n", debugstr_a(dent->d_name), debugstr_a(dirname));
1163
1164         sprintf(path, "%s/%s", dirname, dent->d_name);
1165
1166         if(stat(path, &statbuf) == -1)
1167         {
1168             WARN("Can't stat %s\n", debugstr_a(path));
1169             continue;
1170         }
1171         if(S_ISDIR(statbuf.st_mode))
1172             ReadFontDir(path, external_fonts);
1173         else
1174             AddFontFileToList(path, NULL, external_fonts ? ADDFONT_EXTERNAL_FONT : 0);
1175     }
1176     closedir(dir);
1177     return TRUE;
1178 }
1179
1180 static void load_fontconfig_fonts(void)
1181 {
1182 #ifdef HAVE_FONTCONFIG_FONTCONFIG_H
1183     void *fc_handle = NULL;
1184     FcConfig *config;
1185     FcPattern *pat;
1186     FcObjectSet *os;
1187     FcFontSet *fontset;
1188     int i, len;
1189     const char *file, *ext;
1190
1191     fc_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0);
1192     if(!fc_handle) {
1193         TRACE("Wine cannot find the fontconfig library (%s).\n",
1194               SONAME_LIBFONTCONFIG);
1195         return;
1196     }
1197 #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;}
1198 LOAD_FUNCPTR(FcConfigGetCurrent);
1199 LOAD_FUNCPTR(FcFontList);
1200 LOAD_FUNCPTR(FcFontSetDestroy);
1201 LOAD_FUNCPTR(FcInit);
1202 LOAD_FUNCPTR(FcObjectSetAdd);
1203 LOAD_FUNCPTR(FcObjectSetCreate);
1204 LOAD_FUNCPTR(FcObjectSetDestroy);
1205 LOAD_FUNCPTR(FcPatternCreate);
1206 LOAD_FUNCPTR(FcPatternDestroy);
1207 LOAD_FUNCPTR(FcPatternGetString);
1208 #undef LOAD_FUNCPTR
1209
1210     if(!pFcInit()) return;
1211
1212     config = pFcConfigGetCurrent();
1213     pat = pFcPatternCreate();
1214     os = pFcObjectSetCreate();
1215     pFcObjectSetAdd(os, FC_FILE);
1216     fontset = pFcFontList(config, pat, os);
1217     if(!fontset) return;
1218     for(i = 0; i < fontset->nfont; i++) {
1219         if(pFcPatternGetString(fontset->fonts[i], FC_FILE, 0, (FcChar8**)&file) != FcResultMatch)
1220             continue;
1221         TRACE("fontconfig: %s\n", file);
1222
1223         /* We're just interested in OT/TT fonts for now, so this hack just
1224            picks up the standard extensions to save time loading every other
1225            font */
1226         len = strlen( file );
1227         if(len < 4) continue;
1228         ext = &file[ len - 3 ];
1229         if(!strcasecmp(ext, "ttf") || !strcasecmp(ext, "ttc") || !strcasecmp(ext, "otf"))
1230             AddFontFileToList(file, NULL, ADDFONT_EXTERNAL_FONT);
1231     }
1232     pFcFontSetDestroy(fontset);
1233     pFcObjectSetDestroy(os);
1234     pFcPatternDestroy(pat);
1235  sym_not_found:
1236 #endif
1237     return;
1238 }
1239
1240 static BOOL load_font_from_data_dir(LPCWSTR file)
1241 {
1242     BOOL ret = FALSE;
1243     const char *data_dir = wine_get_data_dir();
1244
1245     if (!data_dir) data_dir = wine_get_build_dir();
1246
1247     if (data_dir)
1248     {
1249         INT len;
1250         char *unix_name;
1251
1252         len = WideCharToMultiByte(CP_UNIXCP, 0, file, -1, NULL, 0, NULL, NULL);
1253
1254         unix_name = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + len + sizeof("/fonts/"));
1255
1256         strcpy(unix_name, data_dir);
1257         strcat(unix_name, "/fonts/");
1258
1259         WideCharToMultiByte(CP_UNIXCP, 0, file, -1, unix_name + strlen(unix_name), len, NULL, NULL);
1260
1261         ret = AddFontFileToList(unix_name, NULL, ADDFONT_FORCE_BITMAP);
1262         HeapFree(GetProcessHeap(), 0, unix_name);
1263     }
1264     return ret;
1265 }
1266
1267 static void load_system_fonts(void)
1268 {
1269     HKEY hkey;
1270     WCHAR data[MAX_PATH], windowsdir[MAX_PATH], pathW[MAX_PATH];
1271     const WCHAR * const *value;
1272     DWORD dlen, type;
1273     static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
1274     char *unixname;
1275
1276     if(RegOpenKeyW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, &hkey) == ERROR_SUCCESS) {
1277         GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1278         strcatW(windowsdir, fontsW);
1279         for(value = SystemFontValues; *value; value++) {
1280             dlen = sizeof(data);
1281             if(RegQueryValueExW(hkey, *value, 0, &type, (void*)data, &dlen) == ERROR_SUCCESS &&
1282                type == REG_SZ) {
1283                 BOOL added = FALSE;
1284
1285                 sprintfW(pathW, fmtW, windowsdir, data);
1286                 if((unixname = wine_get_unix_file_name(pathW))) {
1287                     added = AddFontFileToList(unixname, NULL, ADDFONT_FORCE_BITMAP);
1288                     HeapFree(GetProcessHeap(), 0, unixname);
1289                 }
1290                 if (!added)
1291                     load_font_from_data_dir(data);
1292             }
1293         }
1294         RegCloseKey(hkey);
1295     }
1296 }
1297
1298 /*************************************************************
1299  *
1300  * This adds registry entries for any externally loaded fonts
1301  * (fonts from fontconfig or FontDirs).  It also deletes entries
1302  * of no longer existing fonts.
1303  *
1304  */
1305 static void update_reg_entries(void)
1306 {
1307     HKEY winkey = 0, externalkey = 0;
1308     LPWSTR valueW;
1309     LPVOID data;
1310     DWORD dlen, vlen, datalen, valuelen, i, type, len, len_fam;
1311     Family *family;
1312     Face *face;
1313     struct list *family_elem_ptr, *face_elem_ptr;
1314     WCHAR *file;
1315     static const WCHAR TrueType[] = {' ','(','T','r','u','e','T','y','p','e',')','\0'};
1316     static const WCHAR spaceW[] = {' ', '\0'};
1317     char *path;
1318
1319     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
1320                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &winkey, NULL) != ERROR_SUCCESS) {
1321         ERR("Can't create Windows font reg key\n");
1322         goto end;
1323     }
1324     /* @@ Wine registry key: HKCU\Software\Wine\Fonts\ExternalFonts */
1325     if(RegCreateKeyW(HKEY_CURRENT_USER, external_fonts_reg_key, &externalkey) != ERROR_SUCCESS) {
1326         ERR("Can't create external font reg key\n");
1327         goto end;
1328     }
1329
1330     /* Delete all external fonts added last time */
1331
1332     RegQueryInfoKeyW(externalkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1333                      &valuelen, &datalen, NULL, NULL);
1334     valuelen++; /* returned value doesn't include room for '\0' */
1335     valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1336     data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
1337
1338     dlen = datalen * sizeof(WCHAR);
1339     vlen = valuelen;
1340     i = 0;
1341     while(RegEnumValueW(externalkey, i++, valueW, &vlen, NULL, &type, data,
1342                         &dlen) == ERROR_SUCCESS) {
1343
1344         RegDeleteValueW(winkey, valueW);
1345         /* reset dlen and vlen */
1346         dlen = datalen;
1347         vlen = valuelen;
1348     }
1349     HeapFree(GetProcessHeap(), 0, data);
1350     HeapFree(GetProcessHeap(), 0, valueW);
1351
1352     /* Delete the old external fonts key */
1353     RegCloseKey(externalkey);
1354     externalkey = 0;
1355     RegDeleteKeyW(HKEY_CURRENT_USER, external_fonts_reg_key);
1356
1357     /* @@ Wine registry key: HKCU\Software\Wine\Fonts\ExternalFonts */
1358     if(RegCreateKeyExW(HKEY_CURRENT_USER, external_fonts_reg_key,
1359                        0, NULL, 0, KEY_ALL_ACCESS, NULL, &externalkey, NULL) != ERROR_SUCCESS) {
1360         ERR("Can't create external font reg key\n");
1361         goto end;
1362     }
1363
1364     /* enumerate the fonts and add external ones to the two keys */
1365
1366     LIST_FOR_EACH(family_elem_ptr, &font_list) {
1367         family = LIST_ENTRY(family_elem_ptr, Family, entry);
1368         len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
1369         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
1370             face = LIST_ENTRY(face_elem_ptr, Face, entry);
1371             if(!face->external) continue;
1372             len = len_fam;
1373             if(strcmpiW(face->StyleName, RegularW))
1374                 len = len_fam + strlenW(face->StyleName) + 1;
1375             valueW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1376             strcpyW(valueW, family->FamilyName);
1377             if(len != len_fam) {
1378                 strcatW(valueW, spaceW);
1379                 strcatW(valueW, face->StyleName);
1380             }
1381             strcatW(valueW, TrueType);
1382             if((path = strrchr(face->file, '/')) == NULL)
1383                 path = face->file;
1384             else
1385                 path++;
1386             len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
1387
1388             file = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1389             MultiByteToWideChar(CP_ACP, 0, path, -1, file, len);
1390             RegSetValueExW(winkey, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1391             RegSetValueExW(externalkey, valueW, 0, REG_SZ, (BYTE*)file, len * sizeof(WCHAR));
1392
1393             HeapFree(GetProcessHeap(), 0, file);
1394             HeapFree(GetProcessHeap(), 0, valueW);
1395         }
1396     }
1397  end:
1398     if(externalkey)
1399         RegCloseKey(externalkey);
1400     if(winkey)
1401         RegCloseKey(winkey);
1402     return;
1403 }
1404
1405
1406 /*************************************************************
1407  *    WineEngAddFontResourceEx
1408  *
1409  */
1410 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
1411 {
1412     if (ft_handle)  /* do it only if we have freetype up and running */
1413     {
1414         char *unixname;
1415
1416         if(flags)
1417             FIXME("Ignoring flags %lx\n", flags);
1418
1419         if((unixname = wine_get_unix_file_name(file)))
1420         {
1421             AddFontFileToList(unixname, NULL, ADDFONT_FORCE_BITMAP);
1422             HeapFree(GetProcessHeap(), 0, unixname);
1423         }
1424     }
1425     return 1;
1426 }
1427
1428 /*************************************************************
1429  *    WineEngRemoveFontResourceEx
1430  *
1431  */
1432 BOOL WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
1433 {
1434     FIXME(":stub\n");
1435     return TRUE;
1436 }
1437
1438 static const struct nls_update_font_list
1439 {
1440     UINT ansi_cp, oem_cp;
1441     const char *oem, *fixed, *system;
1442     const char *courier, *serif, *small, *sserif;
1443 } nls_update_font_list[] =
1444 {
1445     /* Latin 1 (United States) */
1446     { 1252, 437, "vgaoem.fon", "vgafix.fon", "vgasys.fon",
1447       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1448     },
1449     /* Latin 1 (Multilingual) */
1450     { 1252, 850, "vga850.fon", "vgafix.fon", "vgasys.fon",
1451       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1452     },
1453     /* Eastern Europe */
1454     { 1250, 852, "vga852.fon", "vgafixe.fon", "vgasyse.fon",
1455       "couree.fon", "serifee.fon", "smallee.fon", "sserifee.fon",
1456     },
1457     /* Cyrillic */
1458     { 1251, 866, "vga866.fon", "vgafixr.fon", "vgasysr.fon",
1459       "courer.fon", "serifer.fon", "smaller.fon", "sserifer.fon",
1460     },
1461     /* Greek */
1462     { 1253, 737, "vga869.fon", "vgafixg.fon", "vgasysg.fon",
1463       "coureg.fon", "serifeg.fon", "smalleg.fon", "sserifeg.fon",
1464     },
1465     /* Turkish */
1466     { 1254, 857, "vga857.fon", "vgafixt.fon", "vgasyst.fon",
1467       "couret.fon", "serifet.fon", "smallet.fon", "sserifet.fon",
1468     },
1469     /* Hebrew */
1470     { 1255, 862, "vgaoem.fon", "vgaf1255.fon", "vgas1255.fon",
1471       "coue1255.fon", "sere1255.fon", "smae1255.fon", "ssee1255.fon",
1472     },
1473     /* Arabic */
1474     { 1256, 720, "vgaoem.fon", "vgaf1256.fon", "vgas1256.fon",
1475       "coue1256.fon", "sere1256.fon", "smae1256.fon", "ssee1256.fon",
1476     },
1477     /* Baltic */
1478     { 1257, 775, "vga775.fon", "vgaf1257.fon", "vgas1257.fon",
1479       "coue1257.fon", "sere1257.fon", "smae1257.fon", "ssee1257.fon",
1480     },
1481     /* Vietnamese */
1482     { 1258, 1258, "vga850.fon", "vgafix.fon", "vgasys.fon",
1483       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1484     },
1485     /* Thai */
1486     { 874, 874, "vga850.fon", "vgaf874.fon", "vgas874.fon",
1487       "coure.fon", "serife.fon", "smalle.fon", "ssee874.fon",
1488     },
1489     /* Japanese */
1490     { 932, 932, "vga932.fon", "jvgafix.fon", "jvgasys.fon",
1491       "coure.fon", "serife.fon", "jsmalle.fon", "sserife.fon",
1492     },
1493     /* Chinese Simplified */
1494     { 936, 936, "vga936.fon", "svgafix.fon", "svgasys.fon",
1495       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1496     },
1497     /* Korean */
1498     { 949, 949, "vga949.fon", "hvgafix.fon", "hvgasys.fon",
1499       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1500     },
1501     /* Chinese Traditional */
1502     { 950, 950, "vga950.fon", "cvgafix.fon", "cvgasys.fon",
1503       "coure.fon", "serife.fon", "smalle.fon", "sserife.fon",
1504     }
1505 };
1506
1507 inline static HKEY create_fonts_NT_registry_key(void)
1508 {
1509     HKEY hkey = 0;
1510
1511     RegCreateKeyExW(HKEY_LOCAL_MACHINE, winnt_font_reg_key, 0, NULL,
1512                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1513     return hkey;
1514 }
1515
1516 inline static HKEY create_fonts_9x_registry_key(void)
1517 {
1518     HKEY hkey = 0;
1519
1520     RegCreateKeyExW(HKEY_LOCAL_MACHINE, win9x_font_reg_key, 0, NULL,
1521                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1522     return hkey;
1523 }
1524
1525 inline static HKEY create_config_fonts_registry_key(void)
1526 {
1527     HKEY hkey = 0;
1528
1529     RegCreateKeyExW(HKEY_CURRENT_CONFIG, system_fonts_reg_key, 0, NULL,
1530                     0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1531     return hkey;
1532 }
1533
1534 static void add_font_list(HKEY hkey, const struct nls_update_font_list *fl)
1535 {
1536     RegSetValueExA(hkey, "Courier", 0, REG_SZ, (const BYTE *)fl->courier, strlen(fl->courier)+1);
1537     RegSetValueExA(hkey, "MS Serif", 0, REG_SZ, (const BYTE *)fl->serif, strlen(fl->serif)+1);
1538     RegSetValueExA(hkey, "MS Sans Serif", 0, REG_SZ, (const BYTE *)fl->sserif, strlen(fl->sserif)+1);
1539     RegSetValueExA(hkey, "Small Fonts", 0, REG_SZ, (const BYTE *)fl->small, strlen(fl->small)+1);
1540 }
1541
1542 static void update_font_info(void)
1543 {
1544     char buf[80];
1545     DWORD len, type;
1546     HKEY hkey = 0;
1547     UINT i, ansi_cp = 0, oem_cp = 0;
1548     LCID lcid = GetUserDefaultLCID();
1549
1550     if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) != ERROR_SUCCESS)
1551         return;
1552
1553     len = sizeof(buf);
1554     if (RegQueryValueExA(hkey, "Locale", 0, &type, (BYTE *)buf, &len) == ERROR_SUCCESS && type == REG_SZ)
1555     {
1556         if (strtoul(buf, NULL, 16 ) == lcid)  /* already set correctly */
1557         {
1558             RegCloseKey(hkey);
1559             return;
1560         }
1561         TRACE("updating registry, locale changed %s -> %08lx\n", debugstr_a(buf), lcid);
1562     }
1563     else TRACE("updating registry, locale changed none -> %08lx\n", lcid);
1564
1565     sprintf(buf, "%08lx", lcid);
1566     RegSetValueExA(hkey, "Locale", 0, REG_SZ, (const BYTE *)buf, strlen(buf)+1);
1567     RegCloseKey(hkey);
1568
1569     GetLocaleInfoW(lcid, LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
1570                    (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR));
1571     GetLocaleInfoW(lcid, LOCALE_IDEFAULTCODEPAGE|LOCALE_RETURN_NUMBER|LOCALE_NOUSEROVERRIDE,
1572                    (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR));
1573
1574     for (i = 0; i < sizeof(nls_update_font_list)/sizeof(nls_update_font_list[0]); i++)
1575     {
1576         if (nls_update_font_list[i].ansi_cp == ansi_cp &&
1577             nls_update_font_list[i].oem_cp == oem_cp)
1578         {
1579             HKEY hkey;
1580
1581             hkey = create_config_fonts_registry_key();
1582             RegSetValueExA(hkey, "OEMFONT.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].oem, strlen(nls_update_font_list[i].oem)+1);
1583             RegSetValueExA(hkey, "FIXEDFON.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].fixed, strlen(nls_update_font_list[i].fixed)+1);
1584             RegSetValueExA(hkey, "FONTS.FON", 0, REG_SZ, (const BYTE *)nls_update_font_list[i].system, strlen(nls_update_font_list[i].system)+1);
1585             RegCloseKey(hkey);
1586
1587             hkey = create_fonts_NT_registry_key();
1588             add_font_list(hkey, &nls_update_font_list[i]);
1589             RegCloseKey(hkey);
1590
1591             hkey = create_fonts_9x_registry_key();
1592             add_font_list(hkey, &nls_update_font_list[i]);
1593             RegCloseKey(hkey);
1594
1595             return;
1596         }
1597     }
1598     FIXME("there is no font defaults for lcid %04lx/ansi_cp %u\n", lcid, ansi_cp);
1599 }
1600
1601 /*************************************************************
1602  *    WineEngInit
1603  *
1604  * Initialize FreeType library and create a list of available faces
1605  */
1606 BOOL WineEngInit(void)
1607 {
1608     static const WCHAR dot_fonW[] = {'.','f','o','n','\0'};
1609     static const WCHAR pathW[] = {'P','a','t','h',0};
1610     HKEY hkey;
1611     DWORD valuelen, datalen, i = 0, type, dlen, vlen;
1612     LPVOID data;
1613     WCHAR windowsdir[MAX_PATH];
1614     char *unixname;
1615     HANDLE font_mutex;
1616     const char *data_dir;
1617
1618     TRACE("\n");
1619
1620     /* update locale dependent font info in registry */
1621     update_font_info();
1622
1623     ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
1624     if(!ft_handle) {
1625         WINE_MESSAGE(
1626       "Wine cannot find the FreeType font library.  To enable Wine to\n"
1627       "use TrueType fonts please install a version of FreeType greater than\n"
1628       "or equal to 2.0.5.\n"
1629       "http://www.freetype.org\n");
1630         return FALSE;
1631     }
1632
1633 #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;}
1634
1635     LOAD_FUNCPTR(FT_Vector_Unit)
1636     LOAD_FUNCPTR(FT_Done_Face)
1637     LOAD_FUNCPTR(FT_Get_Char_Index)
1638     LOAD_FUNCPTR(FT_Get_Module)
1639     LOAD_FUNCPTR(FT_Get_Sfnt_Name)
1640     LOAD_FUNCPTR(FT_Get_Sfnt_Name_Count)
1641     LOAD_FUNCPTR(FT_Get_Sfnt_Table)
1642     LOAD_FUNCPTR(FT_Init_FreeType)
1643     LOAD_FUNCPTR(FT_Load_Glyph)
1644     LOAD_FUNCPTR(FT_Matrix_Multiply)
1645     LOAD_FUNCPTR(FT_MulFix)
1646     LOAD_FUNCPTR(FT_New_Face)
1647     LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
1648     LOAD_FUNCPTR(FT_Outline_Transform)
1649     LOAD_FUNCPTR(FT_Outline_Translate)
1650     LOAD_FUNCPTR(FT_Select_Charmap)
1651     LOAD_FUNCPTR(FT_Set_Pixel_Sizes)
1652     LOAD_FUNCPTR(FT_Vector_Transform)
1653
1654 #undef LOAD_FUNCPTR
1655     /* Don't warn if this one is missing */
1656     pFT_Library_Version = wine_dlsym(ft_handle, "FT_Library_Version", NULL, 0);
1657     pFT_Load_Sfnt_Table = wine_dlsym(ft_handle, "FT_Load_Sfnt_Table", NULL, 0);
1658     pFT_Get_First_Char = wine_dlsym(ft_handle, "FT_Get_First_Char", NULL, 0);
1659     pFT_Get_Next_Char = wine_dlsym(ft_handle, "FT_Get_Next_Char", NULL, 0);
1660     pFT_Get_TrueType_Engine_Type = wine_dlsym(ft_handle, "FT_Get_TrueType_Engine_Type", NULL, 0);
1661 #ifdef HAVE_FREETYPE_FTWINFNT_H
1662     pFT_Get_WinFNT_Header = wine_dlsym(ft_handle, "FT_Get_WinFNT_Header", NULL, 0);
1663 #endif
1664       if(!wine_dlsym(ft_handle, "FT_Get_Postscript_Name", NULL, 0) &&
1665          !wine_dlsym(ft_handle, "FT_Sqrt64", NULL, 0)) {
1666         /* try to avoid 2.0.4: >= 2.0.5 has FT_Get_Postscript_Name and
1667            <= 2.0.3 has FT_Sqrt64 */
1668           goto sym_not_found;
1669       }
1670
1671     if(pFT_Init_FreeType(&library) != 0) {
1672         ERR("Can't init FreeType library\n");
1673         wine_dlclose(ft_handle, NULL, 0);
1674         ft_handle = NULL;
1675         return FALSE;
1676     }
1677     FT_Version.major=FT_Version.minor=FT_Version.patch=-1;
1678     if (pFT_Library_Version)
1679     {
1680         pFT_Library_Version(library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
1681     }
1682     if (FT_Version.major<=0)
1683     {
1684         FT_Version.major=2;
1685         FT_Version.minor=0;
1686         FT_Version.patch=5;
1687     }
1688     TRACE("FreeType version is %d.%d.%d\n",FT_Version.major,FT_Version.minor,FT_Version.patch);
1689     FT_SimpleVersion = ((FT_Version.major << 16) & 0xff0000) |
1690                        ((FT_Version.minor <<  8) & 0x00ff00) |
1691                        ((FT_Version.patch      ) & 0x0000ff);
1692
1693     if((font_mutex = CreateMutexW(NULL, FALSE, font_mutex_nameW)) == NULL) {
1694         ERR("Failed to create font mutex\n");
1695         return FALSE;
1696     }
1697     WaitForSingleObject(font_mutex, INFINITE);
1698
1699     /* load the system bitmap fonts */
1700     load_system_fonts();
1701
1702     /* load in the fonts from %WINDOWSDIR%\\Fonts first of all */
1703     GetWindowsDirectoryW(windowsdir, sizeof(windowsdir) / sizeof(WCHAR));
1704     strcatW(windowsdir, fontsW);
1705     if((unixname = wine_get_unix_file_name(windowsdir)))
1706     {
1707         ReadFontDir(unixname, FALSE);
1708         HeapFree(GetProcessHeap(), 0, unixname);
1709     }
1710
1711     /* load the system truetype fonts */
1712     data_dir = wine_get_data_dir();
1713     if (data_dir && (unixname = HeapAlloc(GetProcessHeap(), 0, strlen(data_dir) + sizeof("/fonts/")))) {
1714         strcpy(unixname, data_dir);
1715         strcat(unixname, "/fonts/");
1716         ReadFontDir(unixname, FALSE);
1717         HeapFree(GetProcessHeap(), 0, unixname);
1718     }
1719
1720     /* now look under HKLM\Software\Microsoft\Windows[ NT]\CurrentVersion\Fonts
1721        for any fonts not installed in %WINDOWSDIR%\Fonts.  They will have their
1722        full path as the entry.  Also look for any .fon fonts, since ReadFontDir
1723        will skip these. */
1724     if(RegOpenKeyW(HKEY_LOCAL_MACHINE,
1725                    is_win9x() ? win9x_font_reg_key : winnt_font_reg_key,
1726                    &hkey) == ERROR_SUCCESS) {
1727         LPWSTR valueW;
1728         RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1729                          &valuelen, &datalen, NULL, NULL);
1730
1731         valuelen++; /* returned value doesn't include room for '\0' */
1732         valueW = HeapAlloc(GetProcessHeap(), 0, valuelen * sizeof(WCHAR));
1733         data = HeapAlloc(GetProcessHeap(), 0, datalen * sizeof(WCHAR));
1734         if (valueW && data)
1735         {
1736             dlen = datalen * sizeof(WCHAR);
1737             vlen = valuelen;
1738             while(RegEnumValueW(hkey, i++, valueW, &vlen, NULL, &type, data,
1739                                 &dlen) == ERROR_SUCCESS) {
1740                 if(((LPWSTR)data)[0] && ((LPWSTR)data)[1] == ':')
1741                 {
1742                     if((unixname = wine_get_unix_file_name((LPWSTR)data)))
1743                     {
1744                         AddFontFileToList(unixname, NULL, ADDFONT_FORCE_BITMAP);
1745                         HeapFree(GetProcessHeap(), 0, unixname);
1746                     }
1747                 }
1748                 else if(dlen / 2 >= 6 && !strcmpiW(((LPWSTR)data) + dlen / 2 - 5, dot_fonW))
1749                 {
1750                     WCHAR pathW[MAX_PATH];
1751                     static const WCHAR fmtW[] = {'%','s','\\','%','s','\0'};
1752                     BOOL added = FALSE;
1753
1754                     sprintfW(pathW, fmtW, windowsdir, data);
1755                     if((unixname = wine_get_unix_file_name(pathW)))
1756                     {
1757                         added = AddFontFileToList(unixname, NULL, ADDFONT_FORCE_BITMAP);
1758                         HeapFree(GetProcessHeap(), 0, unixname);
1759                     }
1760                     if (!added)
1761                         load_font_from_data_dir(data);
1762                 }
1763                 /* reset dlen and vlen */
1764                 dlen = datalen;
1765                 vlen = valuelen;
1766             }
1767         }
1768         HeapFree(GetProcessHeap(), 0, data);
1769         HeapFree(GetProcessHeap(), 0, valueW);
1770         RegCloseKey(hkey);
1771     }
1772
1773     load_fontconfig_fonts();
1774
1775     /* then look in any directories that we've specified in the config file */
1776     /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
1777     if(RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) == ERROR_SUCCESS)
1778     {
1779         DWORD len;
1780         LPWSTR valueW;
1781         LPSTR valueA, ptr;
1782
1783         if (RegQueryValueExW( hkey, pathW, NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
1784         {
1785             len += sizeof(WCHAR);
1786             valueW = HeapAlloc( GetProcessHeap(), 0, len );
1787             if (RegQueryValueExW( hkey, pathW, NULL, NULL, (LPBYTE)valueW, &len ) == ERROR_SUCCESS)
1788             {
1789                 len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
1790                 valueA = HeapAlloc( GetProcessHeap(), 0, len );
1791                 WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
1792                 TRACE( "got font path %s\n", debugstr_a(valueA) );
1793                 ptr = valueA;
1794                 while (ptr)
1795                 {
1796                     LPSTR next = strchr( ptr, ':' );
1797                     if (next) *next++ = 0;
1798                     ReadFontDir( ptr, TRUE );
1799                     ptr = next;
1800                 }
1801                 HeapFree( GetProcessHeap(), 0, valueA );
1802             }
1803             HeapFree( GetProcessHeap(), 0, valueW );
1804         }
1805         RegCloseKey(hkey);
1806     }
1807
1808     DumpFontList();
1809     LoadSubstList();
1810     DumpSubstList();
1811     LoadReplaceList();
1812     update_reg_entries();
1813
1814     init_system_links();
1815
1816     ReleaseMutex(font_mutex);
1817     return TRUE;
1818 sym_not_found:
1819     WINE_MESSAGE(
1820       "Wine cannot find certain functions that it needs inside the FreeType\n"
1821       "font library.  To enable Wine to use TrueType fonts please upgrade\n"
1822       "FreeType to at least version 2.0.5.\n"
1823       "http://www.freetype.org\n");
1824     wine_dlclose(ft_handle, NULL, 0);
1825     ft_handle = NULL;
1826     return FALSE;
1827 }
1828
1829
1830 static LONG calc_ppem_for_height(FT_Face ft_face, LONG height)
1831 {
1832     TT_OS2 *pOS2;
1833     TT_HoriHeader *pHori;
1834
1835     LONG ppem;
1836
1837     pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
1838     pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
1839
1840     if(height == 0) height = 16;
1841
1842     /* Calc. height of EM square:
1843      *
1844      * For +ve lfHeight we have
1845      * lfHeight = (winAscent + winDescent) * ppem / units_per_em
1846      * Re-arranging gives:
1847      * ppem = units_per_em * lfheight / (winAscent + winDescent)
1848      *
1849      * For -ve lfHeight we have
1850      * |lfHeight| = ppem
1851      * [i.e. |lfHeight| = (winAscent + winDescent - il) * ppem / units_per_em
1852      * with il = winAscent + winDescent - units_per_em]
1853      *
1854      */
1855
1856     if(height > 0) {
1857         if(pOS2->usWinAscent + pOS2->usWinDescent == 0)
1858             ppem = ft_face->units_per_EM * height /
1859                 (pHori->Ascender - pHori->Descender);
1860         else
1861             ppem = ft_face->units_per_EM * height /
1862                 (pOS2->usWinAscent + pOS2->usWinDescent);
1863     }
1864     else
1865         ppem = -height;
1866
1867     return ppem;
1868 }
1869
1870 static LONG load_VDMX(GdiFont*, LONG);
1871
1872 static FT_Face OpenFontFile(GdiFont *font, char *file, FT_Long face_index, LONG width, LONG height)
1873 {
1874     FT_Error err;
1875     FT_Face ft_face;
1876
1877     TRACE("%s, %ld, %ld x %ld\n", debugstr_a(file), face_index, width, height);
1878     err = pFT_New_Face(library, file, face_index, &ft_face);
1879     if(err) {
1880         ERR("FT_New_Face rets %d\n", err);
1881         return 0;
1882     }
1883
1884     /* set it here, as load_VDMX needs it */
1885     font->ft_face = ft_face;
1886
1887     if(FT_IS_SCALABLE(ft_face)) {
1888         /* load the VDMX table if we have one */
1889         font->ppem = load_VDMX(font, height);
1890         if(font->ppem == 0)
1891             font->ppem = calc_ppem_for_height(ft_face, height);
1892
1893         if((err = pFT_Set_Pixel_Sizes(ft_face, 0, font->ppem)) != 0)
1894             WARN("FT_Set_Pixel_Sizes %d, %ld rets %x\n", 0, font->ppem, err);
1895     } else {
1896         font->ppem = height;
1897         if((err = pFT_Set_Pixel_Sizes(ft_face, width, height)) != 0)
1898             WARN("FT_Set_Pixel_Sizes %ld, %ld rets %x\n", width, height, err);
1899     }
1900     return ft_face;
1901 }
1902
1903
1904 static int get_nearest_charset(Face *face, int *cp)
1905 {
1906   /* Only get here if lfCharSet == DEFAULT_CHARSET or we couldn't find
1907      a single face with the requested charset.  The idea is to check if
1908      the selected font supports the current ANSI codepage, if it does
1909      return the corresponding charset, else return the first charset */
1910
1911     CHARSETINFO csi;
1912     int acp = GetACP(), i;
1913     DWORD fs0;
1914
1915     *cp = acp;
1916     if(TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE))
1917         if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
1918             return csi.ciCharset;
1919
1920     for(i = 0; i < 32; i++) {
1921         fs0 = 1L << i;
1922         if(face->fs.fsCsb[0] & fs0) {
1923             if(TranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG)) {
1924                 *cp = csi.ciACP;
1925                 return csi.ciCharset;
1926             }
1927             else
1928                 FIXME("TCI failing on %lx\n", fs0);
1929         }
1930     }
1931
1932     FIXME("returning DEFAULT_CHARSET face->fs.fsCsb[0] = %08lx file = %s\n",
1933           face->fs.fsCsb[0], face->file);
1934     *cp = acp;
1935     return DEFAULT_CHARSET;
1936 }
1937
1938 static GdiFont *alloc_font(void)
1939 {
1940     GdiFont *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
1941     ret->gmsize = INIT_GM_SIZE;
1942     ret->gm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1943                         ret->gmsize * sizeof(*ret->gm));
1944     ret->potm = NULL;
1945     ret->font_desc.matrix.eM11 = ret->font_desc.matrix.eM22 = 1.0;
1946     ret->total_kern_pairs = (DWORD)-1;
1947     ret->kern_pairs = NULL;
1948     list_init(&ret->hfontlist);
1949     list_init(&ret->child_fonts);
1950     return ret;
1951 }
1952
1953 static void free_font(GdiFont *font)
1954 {
1955     struct list *cursor, *cursor2;
1956
1957     LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
1958     {
1959         CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
1960         struct list *first_hfont;
1961         HFONTLIST *hfontlist;
1962         list_remove(cursor);
1963         if(child->font)
1964         {
1965             first_hfont = list_head(&child->font->hfontlist);
1966             hfontlist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
1967             DeleteObject(hfontlist->hfont);
1968             HeapFree(GetProcessHeap(), 0, hfontlist);
1969             free_font(child->font);
1970         }
1971         HeapFree(GetProcessHeap(), 0, child->file_name);
1972         HeapFree(GetProcessHeap(), 0, child);
1973     }
1974
1975     if (font->ft_face) pFT_Done_Face(font->ft_face);
1976     HeapFree(GetProcessHeap(), 0, font->kern_pairs);
1977     HeapFree(GetProcessHeap(), 0, font->potm);
1978     HeapFree(GetProcessHeap(), 0, font->name);
1979     HeapFree(GetProcessHeap(), 0, font->gm);
1980     HeapFree(GetProcessHeap(), 0, font);
1981 }
1982
1983
1984 /*************************************************************
1985  * load_VDMX
1986  *
1987  * load the vdmx entry for the specified height
1988  */
1989
1990 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
1991           ( ( (FT_ULong)_x4 << 24 ) |     \
1992             ( (FT_ULong)_x3 << 16 ) |     \
1993             ( (FT_ULong)_x2 <<  8 ) |     \
1994               (FT_ULong)_x1         )
1995
1996 #define MS_VDMX_TAG MS_MAKE_TAG('V', 'D', 'M', 'X')
1997
1998 typedef struct {
1999     BYTE bCharSet;
2000     BYTE xRatio;
2001     BYTE yStartRatio;
2002     BYTE yEndRatio;
2003 } Ratios;
2004
2005 typedef struct {
2006     WORD recs;
2007     BYTE startsz;
2008     BYTE endsz;
2009 } VDMX_group;
2010
2011 static LONG load_VDMX(GdiFont *font, LONG height)
2012 {
2013     WORD hdr[3], tmp;
2014     VDMX_group group;
2015     BYTE devXRatio, devYRatio;
2016     USHORT numRecs, numRatios;
2017     DWORD result, offset = -1;
2018     LONG ppem = 0;
2019     int i;
2020
2021     /* For documentation on VDMX records, see
2022      * http://www.microsoft.com/OpenType/OTSpec/vdmx.htm
2023      */
2024
2025     result = WineEngGetFontData(font, MS_VDMX_TAG, 0, hdr, 6);
2026
2027     if(result == GDI_ERROR) /* no vdmx table present, use linear scaling */
2028         return ppem;
2029
2030     /* FIXME: need the real device aspect ratio */
2031     devXRatio = 1;
2032     devYRatio = 1;
2033
2034     numRecs = GET_BE_WORD(hdr[1]);
2035     numRatios = GET_BE_WORD(hdr[2]);
2036
2037     TRACE("numRecs = %d numRatios = %d\n", numRecs, numRatios);
2038     for(i = 0; i < numRatios; i++) {
2039         Ratios ratio;
2040
2041         offset = (3 * 2) + (i * sizeof(Ratios));
2042         WineEngGetFontData(font, MS_VDMX_TAG, offset, &ratio, sizeof(Ratios));
2043         offset = -1;
2044
2045         TRACE("Ratios[%d] %d  %d : %d -> %d\n", i, ratio.bCharSet, ratio.xRatio, ratio.yStartRatio, ratio.yEndRatio);
2046
2047         if((ratio.xRatio == 0 &&
2048             ratio.yStartRatio == 0 &&
2049             ratio.yEndRatio == 0) ||
2050            (devXRatio == ratio.xRatio &&
2051             devYRatio >= ratio.yStartRatio &&
2052             devYRatio <= ratio.yEndRatio))
2053             {
2054                 offset = (3 * 2) + (numRatios * 4) + (i * 2);
2055                 WineEngGetFontData(font, MS_VDMX_TAG, offset, &tmp, 2);
2056                 offset = GET_BE_WORD(tmp);
2057                 break;
2058             }
2059     }
2060
2061     if(offset == -1) {
2062         FIXME("No suitable ratio found\n");
2063         return ppem;
2064     }
2065
2066     if(WineEngGetFontData(font, MS_VDMX_TAG, offset, &group, 4) != GDI_ERROR) {
2067         USHORT recs;
2068         BYTE startsz, endsz;
2069         WORD *vTable;
2070
2071         recs = GET_BE_WORD(group.recs);
2072         startsz = group.startsz;
2073         endsz = group.endsz;
2074
2075         TRACE("recs=%d  startsz=%d  endsz=%d\n", recs, startsz, endsz);
2076
2077         vTable = HeapAlloc(GetProcessHeap(), 0, recs * 6);
2078         result = WineEngGetFontData(font, MS_VDMX_TAG, offset + 4, vTable, recs * 6);
2079         if(result == GDI_ERROR) {
2080             FIXME("Failed to retrieve vTable\n");
2081             goto end;
2082         }
2083
2084         if(height > 0) {
2085             for(i = 0; i < recs; i++) {
2086                 SHORT yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2087                 SHORT yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2088                 ppem = GET_BE_WORD(vTable[i * 3]);
2089
2090                 if(yMax + -yMin == height) {
2091                     font->yMax = yMax;
2092                     font->yMin = yMin;
2093                     TRACE("ppem %ld found; height=%ld  yMax=%d  yMin=%d\n", ppem, height, font->yMax, font->yMin);
2094                     break;
2095                 }
2096                 if(yMax + -yMin > height) {
2097                     if(--i < 0) {
2098                         ppem = 0;
2099                         goto end; /* failed */
2100                     }
2101                     font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2102                     font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2103                     ppem = GET_BE_WORD(vTable[i * 3]);
2104                     TRACE("ppem %ld found; height=%ld  yMax=%d  yMin=%d\n", ppem, height, font->yMax, font->yMin);
2105                     break;
2106                 }
2107             }
2108             if(!font->yMax) {
2109                 ppem = 0;
2110                 TRACE("ppem not found for height %ld\n", height);
2111             }
2112         } else {
2113             ppem = -height;
2114             if(ppem < startsz || ppem > endsz)
2115                 goto end;
2116
2117             for(i = 0; i < recs; i++) {
2118                 USHORT yPelHeight;
2119                 yPelHeight = GET_BE_WORD(vTable[i * 3]);
2120
2121                 if(yPelHeight > ppem)
2122                     break; /* failed */
2123
2124                 if(yPelHeight == ppem) {
2125                     font->yMax = GET_BE_WORD(vTable[(i * 3) + 1]);
2126                     font->yMin = GET_BE_WORD(vTable[(i * 3) + 2]);
2127                     TRACE("ppem %ld found; yMax=%d  yMin=%d\n", ppem, font->yMax, font->yMin);
2128                     break;
2129                 }
2130             }
2131         }
2132         end:
2133         HeapFree(GetProcessHeap(), 0, vTable);
2134     }
2135
2136     return ppem;
2137 }
2138
2139 static BOOL fontcmp(GdiFont *font, FONT_DESC *fd)
2140 {
2141     if(font->font_desc.hash != fd->hash) return TRUE;
2142     if(memcmp(&font->font_desc.matrix, &fd->matrix, sizeof(fd->matrix))) return TRUE;
2143     if(memcmp(&font->font_desc.lf, &fd->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
2144     if(!font->font_desc.can_use_bitmap != !fd->can_use_bitmap) return TRUE;
2145     return strcmpiW(font->font_desc.lf.lfFaceName, fd->lf.lfFaceName);
2146 }
2147
2148 static void calc_hash(FONT_DESC *pfd)
2149 {
2150     DWORD hash = 0, *ptr, two_chars;
2151     WORD *pwc;
2152     unsigned int i;
2153
2154     for(i = 0, ptr = (DWORD*)&pfd->matrix; i < sizeof(FMAT2)/sizeof(DWORD); i++, ptr++)
2155         hash ^= *ptr;
2156     for(i = 0, ptr = (DWORD*)&pfd->lf; i < 7; i++, ptr++)
2157         hash ^= *ptr;
2158     for(i = 0, ptr = (DWORD*)&pfd->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
2159         two_chars = *ptr;
2160         pwc = (WCHAR *)&two_chars;
2161         if(!*pwc) break;
2162         *pwc = toupperW(*pwc);
2163         pwc++;
2164         *pwc = toupperW(*pwc);
2165         hash ^= two_chars;
2166         if(!*pwc) break;
2167     }
2168     hash ^= !pfd->can_use_bitmap;
2169     pfd->hash = hash;
2170     return;
2171 }
2172
2173 static GdiFont *find_in_cache(HFONT hfont, LOGFONTW *plf, XFORM *pxf, BOOL can_use_bitmap)
2174 {
2175     GdiFont *ret;
2176     FONT_DESC fd;
2177     HFONTLIST *hflist;
2178     struct list *font_elem_ptr, *hfontlist_elem_ptr;
2179
2180     memcpy(&fd.lf, plf, sizeof(LOGFONTW));
2181     memcpy(&fd.matrix, pxf, sizeof(FMAT2));
2182     fd.can_use_bitmap = can_use_bitmap;
2183     calc_hash(&fd);
2184
2185     /* try the in-use list */
2186     LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
2187         ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2188         if(!fontcmp(ret, &fd)) {
2189             if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2190             LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
2191                 hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
2192                 if(hflist->hfont == hfont)
2193                     return ret;
2194             }
2195             hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2196             hflist->hfont = hfont;
2197             list_add_head(&ret->hfontlist, &hflist->entry);
2198             return ret;
2199         }
2200     }
2201
2202     /* then the unused list */
2203     font_elem_ptr = list_head(&unused_gdi_font_list);
2204     while(font_elem_ptr) {
2205         ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2206         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2207         if(!fontcmp(ret, &fd)) {
2208             if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
2209             assert(list_empty(&ret->hfontlist));
2210             TRACE("Found %p in unused list\n", ret);
2211             list_remove(&ret->entry);
2212             list_add_head(&gdi_font_list, &ret->entry);
2213             hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2214             hflist->hfont = hfont;
2215             list_add_head(&ret->hfontlist, &hflist->entry);
2216             return ret;
2217         }
2218     }
2219     return NULL;
2220 }
2221
2222
2223 /*************************************************************
2224  * create_child_font_list
2225  */
2226 static BOOL create_child_font_list(GdiFont *font)
2227 {
2228     BOOL ret = FALSE;
2229     SYSTEM_LINKS *font_link;
2230     CHILD_FONT *font_link_entry, *new_child;
2231
2232     LIST_FOR_EACH_ENTRY(font_link, &system_links, SYSTEM_LINKS, entry)
2233     {
2234         if(!strcmpW(font_link->font_name, font->name))
2235         {
2236             TRACE("found entry in system list\n");
2237             LIST_FOR_EACH_ENTRY(font_link_entry, &font_link->links, CHILD_FONT, entry)
2238             {
2239                 new_child = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_child));
2240                 new_child->file_name = strdupA(font_link_entry->file_name);
2241                 new_child->index = font_link_entry->index;
2242                 new_child->font = NULL;
2243                 list_add_tail(&font->child_fonts, &new_child->entry);
2244                 TRACE("font %s %d\n", debugstr_a(new_child->file_name), new_child->index);
2245             }
2246             ret = TRUE;
2247             break;
2248         }
2249     }
2250
2251     return ret;
2252 }
2253
2254 /*************************************************************
2255  * WineEngCreateFontInstance
2256  *
2257  */
2258 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
2259 {
2260     GdiFont *ret;
2261     Face *face, *best, *best_bitmap;
2262     Family *family, *last_resort_family;
2263     struct list *family_elem_ptr, *face_elem_ptr;
2264     INT height, width = 0;
2265     unsigned int score = 0, new_score;
2266     signed int diff = 0, newdiff;
2267     BOOL bd, it, can_use_bitmap;
2268     LOGFONTW lf;
2269     CHARSETINFO csi;
2270     HFONTLIST *hflist;
2271
2272     LIST_FOR_EACH_ENTRY(ret, &child_font_list, struct tagGdiFont, entry)
2273     {
2274         struct list *first_hfont = list_head(&ret->hfontlist);
2275         hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2276         if(hflist->hfont == hfont)
2277             return ret;
2278     }
2279
2280     if (!GetObjectW( hfont, sizeof(lf), &lf )) return NULL;
2281     can_use_bitmap = GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_RA_ABLE;
2282
2283     TRACE("%s, h=%ld, it=%d, weight=%ld, PandF=%02x, charset=%d orient %ld escapement %ld\n",
2284           debugstr_w(lf.lfFaceName), lf.lfHeight, lf.lfItalic,
2285           lf.lfWeight, lf.lfPitchAndFamily, lf.lfCharSet, lf.lfOrientation,
2286           lf.lfEscapement);
2287
2288     /* check the cache first */
2289     if((ret = find_in_cache(hfont, &lf, &dc->xformWorld2Vport, can_use_bitmap)) != NULL) {
2290         TRACE("returning cached gdiFont(%p) for hFont %p\n", ret, hfont);
2291         return ret;
2292     }
2293
2294     TRACE("not in cache\n");
2295     if(list_empty(&font_list)) /* No fonts installed */
2296     {
2297         TRACE("No fonts installed\n");
2298         return NULL;
2299     }
2300     if(!have_installed_roman_font)
2301     {
2302         TRACE("No roman font installed\n");
2303         return NULL;
2304     }
2305
2306     ret = alloc_font();
2307
2308      memcpy(&ret->font_desc.matrix, &dc->xformWorld2Vport, sizeof(FMAT2));
2309      memcpy(&ret->font_desc.lf, &lf, sizeof(LOGFONTW));
2310      ret->font_desc.can_use_bitmap = can_use_bitmap;
2311      calc_hash(&ret->font_desc);
2312      hflist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hflist));
2313      hflist->hfont = hfont;
2314      list_add_head(&ret->hfontlist, &hflist->entry);
2315
2316
2317     /* If lfFaceName is "Symbol" then Windows fixes up lfCharSet to
2318        SYMBOL_CHARSET so that Symbol gets picked irrespective of the
2319        original value lfCharSet.  Note this is a special case for
2320        Symbol and doesn't happen at least for "Wingdings*" */
2321
2322     if(!strcmpiW(lf.lfFaceName, SymbolW))
2323         lf.lfCharSet = SYMBOL_CHARSET;
2324
2325     if(!TranslateCharsetInfo((DWORD*)(INT_PTR)lf.lfCharSet, &csi, TCI_SRCCHARSET)) {
2326         switch(lf.lfCharSet) {
2327         case DEFAULT_CHARSET:
2328             csi.fs.fsCsb[0] = 0;
2329             break;
2330         default:
2331             FIXME("Untranslated charset %d\n", lf.lfCharSet);
2332             csi.fs.fsCsb[0] = 0;
2333             break;
2334         }
2335     }
2336
2337     family = NULL;
2338     if(lf.lfFaceName[0] != '\0') {
2339         FontSubst *psub;
2340         psub = get_font_subst(&font_subst_list, lf.lfFaceName, lf.lfCharSet);
2341
2342         if(psub) {
2343             TRACE("substituting %s -> %s\n", debugstr_w(lf.lfFaceName),
2344                   debugstr_w(psub->to.name));
2345             strcpyW(lf.lfFaceName, psub->to.name);
2346         }
2347
2348         /* We want a match on name and charset or just name if
2349            charset was DEFAULT_CHARSET.  If the latter then
2350            we fixup the returned charset later in get_nearest_charset
2351            where we'll either use the charset of the current ansi codepage
2352            or if that's unavailable the first charset that the font supports.
2353         */
2354         LIST_FOR_EACH(family_elem_ptr, &font_list) {
2355             family = LIST_ENTRY(family_elem_ptr, Family, entry);
2356             if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
2357                 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2358                     face = LIST_ENTRY(face_elem_ptr, Face, entry);
2359                     if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
2360                         if(face->scalable || can_use_bitmap)
2361                             goto found;
2362                 }
2363             }
2364         }
2365     }
2366
2367     /* If requested charset was DEFAULT_CHARSET then try using charset
2368        corresponding to the current ansi codepage */
2369     if(!csi.fs.fsCsb[0]) {
2370         INT acp = GetACP();
2371         if(!TranslateCharsetInfo((DWORD*)(INT_PTR)acp, &csi, TCI_SRCCODEPAGE)) {
2372             FIXME("TCI failed on codepage %d\n", acp);
2373             csi.fs.fsCsb[0] = 0;
2374         } else
2375             lf.lfCharSet = csi.ciCharset;
2376     }
2377
2378     /* Face families are in the top 4 bits of lfPitchAndFamily,
2379        so mask with 0xF0 before testing */
2380
2381     if((lf.lfPitchAndFamily & FIXED_PITCH) ||
2382        (lf.lfPitchAndFamily & 0xF0) == FF_MODERN)
2383         strcpyW(lf.lfFaceName, defFixed);
2384     else if((lf.lfPitchAndFamily & 0xF0) == FF_ROMAN)
2385         strcpyW(lf.lfFaceName, defSerif);
2386     else if((lf.lfPitchAndFamily & 0xF0) == FF_SWISS)
2387         strcpyW(lf.lfFaceName, defSans);
2388     else
2389         strcpyW(lf.lfFaceName, defSans);
2390     LIST_FOR_EACH(family_elem_ptr, &font_list) {
2391         family = LIST_ENTRY(family_elem_ptr, Family, entry);
2392         if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
2393             LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2394                 face = LIST_ENTRY(face_elem_ptr, Face, entry);
2395                 if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
2396                     if(face->scalable || can_use_bitmap)
2397                         goto found;
2398             }
2399         }
2400     }
2401
2402     last_resort_family = NULL;
2403     LIST_FOR_EACH(family_elem_ptr, &font_list) {
2404         family = LIST_ENTRY(family_elem_ptr, Family, entry);
2405         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2406             face = LIST_ENTRY(face_elem_ptr, Face, entry);
2407             if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) {
2408                 if(face->scalable)
2409                     goto found;
2410                 if(can_use_bitmap && !last_resort_family)
2411                     last_resort_family = family;
2412             }
2413         }
2414     }
2415
2416     if(last_resort_family) {
2417         family = last_resort_family;
2418         csi.fs.fsCsb[0] = 0;
2419         goto found;
2420     }
2421
2422     LIST_FOR_EACH(family_elem_ptr, &font_list) {
2423         family = LIST_ENTRY(family_elem_ptr, Family, entry);
2424         LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2425             face = LIST_ENTRY(face_elem_ptr, Face, entry);
2426             if(face->scalable) {
2427                 csi.fs.fsCsb[0] = 0;
2428                 FIXME("just using first face for now\n");
2429                 goto found;
2430             }
2431             if(can_use_bitmap && !last_resort_family)
2432                 last_resort_family = family;
2433         }
2434     }
2435     if(!last_resort_family) {
2436         FIXME("can't find a single appropriate font - bailing\n");
2437         free_font(ret);
2438         return NULL;
2439     }
2440
2441     WARN("could only find a bitmap font - this will probably look awful!\n");
2442     family = last_resort_family;
2443     csi.fs.fsCsb[0] = 0;
2444
2445 found:
2446     it = lf.lfItalic ? 1 : 0;
2447     bd = lf.lfWeight > 550 ? 1 : 0;
2448
2449     height = GDI_ROUND( (FLOAT)lf.lfHeight * dc->xformWorld2Vport.eM22 );
2450     height = lf.lfHeight < 0 ? -abs(height) : abs(height);
2451
2452     face = best = best_bitmap = NULL;
2453     LIST_FOR_EACH_ENTRY(face, &family->faces, Face, entry)
2454     {
2455         if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
2456         {
2457             new_score = (face->Italic ^ it) + (face->Bold ^ bd);
2458             if(!best || new_score <= score)
2459             {
2460                 TRACE("(it=%d, bd=%d) is selected for (it=%d, bd=%d)\n",
2461                       face->Italic, face->Bold, it, bd);
2462                 score = new_score;
2463                 best = face;
2464                 if(best->scalable  && score == 0) break;
2465                 if(!best->scalable)
2466                 {
2467                     if(height > 0)
2468                         newdiff = height - (signed int)(best->size.height);
2469                     else
2470                         newdiff = -height - ((signed int)(best->size.height) - best->size.internal_leading);
2471                     if(!best_bitmap || new_score < score ||
2472                        (diff > 0 && newdiff < diff && newdiff >= 0) || (diff < 0 && newdiff > diff))
2473                     {
2474                         TRACE("%d is better for %d diff was %d\n", best->size.height, height, diff);
2475                         diff = newdiff;
2476                         best_bitmap = best;
2477                         if(score == 0 && diff == 0) break;
2478                     }
2479                 }
2480             }
2481         }
2482     }
2483     if(best)
2484         face = best->scalable ? best : best_bitmap;
2485     ret->fake_italic = (it && !face->Italic);
2486     ret->fake_bold = (bd && !face->Bold);
2487
2488     memcpy(&ret->fs, &face->fs, sizeof(FONTSIGNATURE));
2489
2490     if(csi.fs.fsCsb[0]) {
2491         ret->charset = lf.lfCharSet;
2492         ret->codepage = csi.ciACP;
2493     }
2494     else
2495         ret->charset = get_nearest_charset(face, &ret->codepage);
2496
2497     TRACE("Chosen: %s %s (%s:%ld)\n", debugstr_w(family->FamilyName),
2498           debugstr_w(face->StyleName), face->file, face->face_index);
2499
2500     if(!face->scalable) {
2501         width = face->size.x_ppem >> 6;
2502         height = face->size.y_ppem >> 6;
2503     }
2504     ret->ft_face = OpenFontFile(ret, face->file, face->face_index, width, height);
2505
2506     if (!ret->ft_face)
2507     {
2508         free_font( ret );
2509         return 0;
2510     }
2511
2512     if (ret->charset == SYMBOL_CHARSET &&
2513         !pFT_Select_Charmap(ret->ft_face, FT_ENCODING_MS_SYMBOL)) {
2514         /* No ops */
2515     }
2516     else if (!pFT_Select_Charmap(ret->ft_face, FT_ENCODING_UNICODE)) {
2517         /* No ops */
2518     }
2519     else {
2520         pFT_Select_Charmap(ret->ft_face, FT_ENCODING_APPLE_ROMAN);
2521     }
2522
2523     ret->orientation = FT_IS_SCALABLE(ret->ft_face) ? lf.lfOrientation : 0;
2524     ret->name = strdupW(family->FamilyName);
2525     ret->underline = lf.lfUnderline ? 0xff : 0;
2526     ret->strikeout = lf.lfStrikeOut ? 0xff : 0;
2527     create_child_font_list(ret);
2528
2529     TRACE("caching: gdiFont=%p  hfont=%p\n", ret, hfont);
2530
2531     ret->aveWidth = FT_IS_SCALABLE(ret->ft_face) ? lf.lfWidth : 0;
2532     list_add_head(&gdi_font_list, &ret->entry);
2533     return ret;
2534 }
2535
2536 static void dump_gdi_font_list(void)
2537 {
2538     GdiFont *gdiFont;
2539     struct list *elem_ptr;
2540
2541     TRACE("---------- gdiFont Cache ----------\n");
2542     LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
2543         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
2544         TRACE("gdiFont=%p %s %ld\n",
2545               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
2546     }
2547
2548     TRACE("---------- Unused gdiFont Cache ----------\n");
2549     LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
2550         gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
2551         TRACE("gdiFont=%p %s %ld\n",
2552               gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
2553     }
2554 }
2555
2556 /*************************************************************
2557  * WineEngDestroyFontInstance
2558  *
2559  * free the gdiFont associated with this handle
2560  *
2561  */
2562 BOOL WineEngDestroyFontInstance(HFONT handle)
2563 {
2564     GdiFont *gdiFont;
2565     HFONTLIST *hflist;
2566     BOOL ret = FALSE;
2567     struct list *font_elem_ptr, *hfontlist_elem_ptr;
2568     int i = 0;
2569
2570     LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
2571     {
2572         struct list *first_hfont = list_head(&gdiFont->hfontlist);
2573         hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
2574         if(hflist->hfont == handle)
2575         {
2576             TRACE("removing child font %p from child list\n", gdiFont);
2577             list_remove(&gdiFont->entry);
2578             return TRUE;
2579         }
2580     }
2581
2582     TRACE("destroying hfont=%p\n", handle);
2583     if(TRACE_ON(font))
2584         dump_gdi_font_list();
2585
2586     font_elem_ptr = list_head(&gdi_font_list);
2587     while(font_elem_ptr) {
2588         gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2589         font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
2590
2591         hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
2592         while(hfontlist_elem_ptr) {
2593             hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
2594             hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
2595             if(hflist->hfont == handle) {
2596                 list_remove(&hflist->entry);
2597                 HeapFree(GetProcessHeap(), 0, hflist);
2598                 ret = TRUE;
2599             }
2600         }
2601         if(list_empty(&gdiFont->hfontlist)) {
2602             TRACE("Moving to Unused list\n");
2603             list_remove(&gdiFont->entry);
2604             list_add_head(&unused_gdi_font_list, &gdiFont->entry);
2605         }
2606     }
2607
2608
2609     font_elem_ptr = list_head(&unused_gdi_font_list);
2610     while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
2611         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2612     while(font_elem_ptr) {
2613         gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
2614         font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
2615         TRACE("freeing %p\n", gdiFont);
2616         list_remove(&gdiFont->entry);
2617         free_font(gdiFont);
2618     }
2619     return ret;
2620 }
2621
2622 static void GetEnumStructs(Face *face, LPENUMLOGFONTEXW pelf,
2623                            NEWTEXTMETRICEXW *pntm, LPDWORD ptype)
2624 {
2625     OUTLINETEXTMETRICW *potm = NULL;
2626     UINT size;
2627     TEXTMETRICW tm, *ptm;
2628     GdiFont *font = alloc_font();
2629     LONG width, height;
2630
2631     if(face->scalable) {
2632         height = 100;
2633         width = 0;
2634     } else {
2635         height = face->size.y_ppem >> 6;
2636         width = face->size.x_ppem >> 6;
2637     }
2638
2639     if (!(font->ft_face = OpenFontFile(font, face->file, face->face_index, width, height)))
2640     {
2641         free_font(font);
2642         return;
2643     }
2644
2645     font->name = strdupW(face->family->FamilyName);
2646
2647     memset(&pelf->elfLogFont, 0, sizeof(LOGFONTW));
2648
2649     size = WineEngGetOutlineTextMetrics(font, 0, NULL);
2650     if(size) {
2651         potm = HeapAlloc(GetProcessHeap(), 0, size);
2652         WineEngGetOutlineTextMetrics(font, size, potm);
2653         ptm = (TEXTMETRICW*)&potm->otmTextMetrics;
2654     } else {
2655         WineEngGetTextMetrics(font, &tm);
2656         ptm = &tm;
2657     }
2658
2659     pntm->ntmTm.tmHeight = pelf->elfLogFont.lfHeight = ptm->tmHeight;
2660     pntm->ntmTm.tmAscent = ptm->tmAscent;
2661     pntm->ntmTm.tmDescent = ptm->tmDescent;
2662     pntm->ntmTm.tmInternalLeading = ptm->tmInternalLeading;
2663     pntm->ntmTm.tmExternalLeading = ptm->tmExternalLeading;
2664     pntm->ntmTm.tmAveCharWidth = pelf->elfLogFont.lfWidth = ptm->tmAveCharWidth;
2665     pntm->ntmTm.tmMaxCharWidth = ptm->tmMaxCharWidth;
2666     pntm->ntmTm.tmWeight = pelf->elfLogFont.lfWeight = ptm->tmWeight;
2667     pntm->ntmTm.tmOverhang = ptm->tmOverhang;
2668     pntm->ntmTm.tmDigitizedAspectX = ptm->tmDigitizedAspectX;
2669     pntm->ntmTm.tmDigitizedAspectY = ptm->tmDigitizedAspectY;
2670     pntm->ntmTm.tmFirstChar = ptm->tmFirstChar;
2671     pntm->ntmTm.tmLastChar = ptm->tmLastChar;
2672     pntm->ntmTm.tmDefaultChar = ptm->tmDefaultChar;
2673     pntm->ntmTm.tmBreakChar = ptm->tmBreakChar;
2674     pntm->ntmTm.tmItalic = pelf->elfLogFont.lfItalic = ptm->tmItalic;
2675     pntm->ntmTm.tmUnderlined = pelf->elfLogFont.lfUnderline = ptm->tmUnderlined;
2676     pntm->ntmTm.tmStruckOut = pelf->elfLogFont.lfStrikeOut = ptm->tmStruckOut;
2677     pntm->ntmTm.tmPitchAndFamily = ptm->tmPitchAndFamily;
2678     pelf->elfLogFont.lfPitchAndFamily = (ptm->tmPitchAndFamily & 0xf1) + 1;
2679     pntm->ntmTm.tmCharSet = pelf->elfLogFont.lfCharSet = ptm->tmCharSet;
2680     pelf->elfLogFont.lfOutPrecision = OUT_STROKE_PRECIS;
2681     pelf->elfLogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
2682     pelf->elfLogFont.lfQuality = DRAFT_QUALITY;
2683
2684     *ptype = ptm->tmPitchAndFamily & TMPF_TRUETYPE ? TRUETYPE_FONTTYPE : 0;
2685     if(!(ptm->tmPitchAndFamily & TMPF_VECTOR))
2686         *ptype |= RASTER_FONTTYPE;
2687
2688     pntm->ntmTm.ntmFlags = ptm->tmItalic ? NTM_ITALIC : 0;
2689     if(ptm->tmWeight > 550) pntm->ntmTm.ntmFlags |= NTM_BOLD;
2690     if(pntm->ntmTm.ntmFlags == 0) pntm->ntmTm.ntmFlags = NTM_REGULAR;
2691
2692     pntm->ntmTm.ntmCellHeight = pntm->ntmTm.tmHeight;
2693     pntm->ntmTm.ntmAvgWidth = pntm->ntmTm.tmAveCharWidth;
2694     memset(&pntm->ntmFontSig, 0, sizeof(FONTSIGNATURE));
2695
2696     if(potm) {
2697         pntm->ntmTm.ntmSizeEM = potm->otmEMSquare;
2698
2699         lstrcpynW(pelf->elfLogFont.lfFaceName,
2700                  (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFamilyName),
2701                  LF_FACESIZE);
2702         lstrcpynW(pelf->elfFullName,
2703                  (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpFaceName),
2704                  LF_FULLFACESIZE);
2705         lstrcpynW(pelf->elfStyle,
2706                  (WCHAR*)((char*)potm + (ptrdiff_t)potm->otmpStyleName),
2707                  LF_FACESIZE);
2708
2709         HeapFree(GetProcessHeap(), 0, potm);
2710     } else {
2711         pntm->ntmTm.ntmSizeEM = pntm->ntmTm.tmHeight - pntm->ntmTm.tmInternalLeading;
2712
2713         lstrcpynW(pelf->elfLogFont.lfFaceName, face->family->FamilyName, LF_FACESIZE);
2714         lstrcpynW(pelf->elfFullName, face->family->FamilyName, LF_FACESIZE);
2715         pelf->elfStyle[0] = '\0';
2716     }
2717
2718     pelf->elfScript[0] = '\0'; /* This will get set in WineEngEnumFonts */
2719
2720     free_font(font);
2721 }
2722
2723 /*************************************************************
2724  * WineEngEnumFonts
2725  *
2726  */
2727 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
2728 {
2729     Family *family;
2730     Face *face;
2731     struct list *family_elem_ptr, *face_elem_ptr;
2732     ENUMLOGFONTEXW elf;
2733     NEWTEXTMETRICEXW ntm;
2734     DWORD type, ret = 1;
2735     FONTSIGNATURE fs;
2736     CHARSETINFO csi;
2737     LOGFONTW lf;
2738     int i;
2739
2740     TRACE("facename = %s charset %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
2741
2742     if(plf->lfFaceName[0]) {
2743         FontSubst *psub;
2744         psub = get_font_subst(&font_subst_list, plf->lfFaceName, plf->lfCharSet);
2745
2746         if(psub) {
2747             TRACE("substituting %s -> %s\n", debugstr_w(plf->lfFaceName),
2748                   debugstr_w(psub->to.name));
2749             memcpy(&lf, plf, sizeof(lf));
2750             strcpyW(lf.lfFaceName, psub->to.name);
2751             plf = &lf;
2752         }
2753
2754         LIST_FOR_EACH(family_elem_ptr, &font_list) {
2755             family = LIST_ENTRY(family_elem_ptr, Family, entry);
2756             if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
2757                 LIST_FOR_EACH(face_elem_ptr, &family->faces) {
2758                     face = LIST_ENTRY(face_elem_ptr, Face, entry);
2759                     GetEnumStructs(face, &elf, &ntm, &type);
2760                     for(i = 0; i < 32; i++) {
2761                         if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
2762                             elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
2763                             strcpyW(elf.elfScript, OEM_DOSW);
2764                             i = 32; /* break out of loop */
2765                         } else if(!(face->fs.fsCsb[0] & (1L << i)))
2766                             continue;
2767                         else {
2768                             fs.fsCsb[0] = 1L << i;
2769                             fs.fsCsb[1] = 0;
2770                             if(!TranslateCharsetInfo(fs.fsCsb, &csi,
2771                                                      TCI_SRCFONTSIG))
2772                                 csi.ciCharset = DEFAULT_CHARSET;
2773                             if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
2774                             if(csi.ciCharset != DEFAULT_CHARSET) {
2775                                 elf.elfLogFont.lfCharSet =
2776                                     ntm.ntmTm.tmCharSet = csi.ciCharset;
2777                                 if(ElfScriptsW[i])
2778                                     strcpyW(elf.elfScript, ElfScriptsW[i]);
2779                                 else
2780                                     FIXME("Unknown elfscript for bit %d\n", i);
2781                             }
2782                         }
2783                         TRACE("enuming face %s full %s style %s charset %d type %ld script %s it %d weight %ld ntmflags %08lx\n",
2784                               debugstr_w(elf.elfLogFont.lfFaceName),
2785                               debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
2786                               csi.ciCharset, type, debugstr_w(elf.elfScript),
2787                               elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
2788                               ntm.ntmTm.ntmFlags);
2789                         ret = proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam);
2790                         if(!ret) goto end;
2791                     }
2792                 }
2793             }
2794         }
2795     } else {
2796         LIST_FOR_EACH(family_elem_ptr, &font_list) {
2797             family = LIST_ENTRY(family_elem_ptr, Family, entry);
2798             face_elem_ptr = list_head(&family->faces);
2799             face = LIST_ENTRY(face_elem_ptr, Face, entry);
2800             GetEnumStructs(face, &elf, &ntm, &type);
2801             for(i = 0; i < 32; i++) {
2802                 if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
2803                     elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET;
2804                     strcpyW(elf.elfScript, OEM_DOSW);
2805                     i = 32; /* break out of loop */
2806                 } else if(!(face->fs.fsCsb[0] & (1L << i)))
2807                     continue;
2808                 else {
2809                     fs.fsCsb[0] = 1L << i;
2810                     fs.fsCsb[1] = 0;
2811                     if(!TranslateCharsetInfo(fs.fsCsb, &csi,
2812                                              TCI_SRCFONTSIG))
2813                         csi.ciCharset = DEFAULT_CHARSET;
2814                     if(i == 31) csi.ciCharset = SYMBOL_CHARSET;
2815                     if(csi.ciCharset != DEFAULT_CHARSET) {
2816                         elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet =
2817                           csi.ciCharset;
2818                           if(ElfScriptsW[i])
2819                               strcpyW(elf.elfScript, ElfScriptsW[i]);
2820                           else
2821                               FIXME("Unknown elfscript for bit %d\n", i);
2822                     }
2823                 }
2824                 TRACE("enuming face %s full %s style %s charset = %d type %ld script %s it %d weight %ld ntmflags %08lx\n",
2825                       debugstr_w(elf.elfLogFont.lfFaceName),
2826                       debugstr_w(elf.elfFullName), debugstr_w(elf.elfStyle),
2827                       csi.ciCharset, type, debugstr_w(elf.elfScript),
2828                       elf.elfLogFont.lfItalic, elf.elfLogFont.lfWeight,
2829                       ntm.ntmTm.ntmFlags);
2830                 ret = proc(&elf.elfLogFont, (TEXTMETRICW *)&ntm, type, lparam);
2831                 if(!ret) goto end;
2832             }
2833         }
2834     }
2835 end:
2836     return ret;
2837 }
2838
2839 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
2840 {
2841     pt->x.value = vec->x >> 6;
2842     pt->x.fract = (vec->x & 0x3f) << 10;
2843     pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
2844     pt->y.value = vec->y >> 6;
2845     pt->y.fract = (vec->y & 0x3f) << 10;
2846     pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
2847     return;
2848 }
2849
2850 /***************************************************
2851  * According to the MSDN documentation on WideCharToMultiByte,
2852  * certain codepages cannot set the default_used parameter.
2853  * This returns TRUE if the codepage can set that parameter, false else
2854  * so that calls to WideCharToMultiByte don't fail with ERROR_INVALID_PARAMETER
2855  */
2856 static BOOL codepage_sets_default_used(UINT codepage)
2857 {
2858    switch (codepage)
2859    {
2860        case CP_UTF7:
2861        case CP_UTF8:
2862        case CP_SYMBOL:
2863            return FALSE;
2864        default:
2865            return TRUE;
2866    }
2867 }
2868
2869 static FT_UInt get_glyph_index(GdiFont *font, UINT glyph)
2870 {
2871     if(font->ft_face->charmap->encoding == FT_ENCODING_NONE) {
2872         WCHAR wc = (WCHAR)glyph;
2873         BOOL default_used;
2874         BOOL *default_used_pointer;
2875         FT_UInt ret;
2876         char buf;
2877         default_used_pointer = NULL;
2878         default_used = FALSE;
2879         if (codepage_sets_default_used(font->codepage))
2880             default_used_pointer = &default_used;
2881         if(!WideCharToMultiByte(font->codepage, 0, &wc, 1, &buf, sizeof(buf), NULL, default_used_pointer) || default_used)
2882             ret = 0;
2883         else
2884             ret = pFT_Get_Char_Index(font->ft_face, (unsigned char)buf);
2885         TRACE("%04x (%02x) -> ret %d def_used %d\n", glyph, buf, ret, default_used);
2886         return ret;
2887     }
2888
2889     if(font->charset == SYMBOL_CHARSET && glyph < 0x100)
2890         glyph = glyph + 0xf000;
2891     return pFT_Get_Char_Index(font->ft_face, glyph);
2892 }
2893
2894 /*************************************************************
2895  * WineEngGetGlyphIndices
2896  *
2897  * FIXME: add support for GGI_MARK_NONEXISTING_GLYPHS
2898  */
2899 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
2900                                 LPWORD pgi, DWORD flags)
2901 {
2902     int i;
2903     WCHAR default_char = 0;
2904     TEXTMETRICW textm;
2905
2906     if  (flags & GGI_MARK_NONEXISTING_GLYPHS) default_char = 0x001f;  /* Indicate non existence */
2907
2908     for(i = 0; i < count; i++)
2909     {
2910         pgi[i] = get_glyph_index(font, lpstr[i]);
2911         if  (pgi[i] == 0)
2912         {
2913             if (!default_char)
2914             {
2915                 WineEngGetTextMetrics(font, &textm);
2916                 default_char = textm.tmDefaultChar;
2917             }
2918             pgi[i] = default_char;
2919         }
2920     }
2921     return count;
2922 }
2923
2924 /*************************************************************
2925  * WineEngGetGlyphOutline
2926  *
2927  * Behaves in exactly the same way as the win32 api GetGlyphOutline
2928  * except that the first parameter is the HWINEENGFONT of the font in
2929  * question rather than an HDC.
2930  *
2931  */
2932 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
2933                              LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
2934                              const MAT2* lpmat)
2935 {
2936     static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
2937     FT_Face ft_face = font->ft_face;
2938     FT_UInt glyph_index;
2939     DWORD width, height, pitch, needed = 0;
2940     FT_Bitmap ft_bitmap;
2941     FT_Error err;
2942     INT left, right, top = 0, bottom = 0;
2943     FT_Angle angle = 0;
2944     FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
2945     float widthRatio = 1.0;
2946     FT_Matrix transMat = identityMat;
2947     BOOL needsTransform = FALSE;
2948
2949
2950     TRACE("%p, %04x, %08x, %p, %08lx, %p, %p\n", font, glyph, format, lpgm,
2951           buflen, buf, lpmat);
2952
2953     if(format & GGO_GLYPH_INDEX) {
2954         glyph_index = glyph;
2955         format &= ~GGO_GLYPH_INDEX;
2956     } else
2957         glyph_index = get_glyph_index(font, glyph);
2958
2959     if(glyph_index >= font->gmsize) {
2960         font->gmsize = (glyph_index / INIT_GM_SIZE + 1) * INIT_GM_SIZE;
2961         font->gm = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, font->gm,
2962                                font->gmsize * sizeof(*font->gm));
2963     } else {
2964         if(format == GGO_METRICS && font->gm[glyph_index].init) {
2965             memcpy(lpgm, &font->gm[glyph_index].gm, sizeof(*lpgm));
2966             return 1; /* FIXME */
2967         }
2968     }
2969
2970     if(font->orientation || (format != GGO_METRICS && format != GGO_BITMAP) || font->aveWidth || lpmat)
2971         load_flags |= FT_LOAD_NO_BITMAP;
2972
2973     err = pFT_Load_Glyph(ft_face, glyph_index, load_flags);
2974
2975     if(err) {
2976         FIXME("FT_Load_Glyph on index %x returns %d\n", glyph_index, err);
2977         return GDI_ERROR;
2978     }
2979
2980     /* Scaling factor */
2981     if (font->aveWidth && font->potm) {
2982         widthRatio = (float)font->aveWidth * font->font_desc.matrix.eM11 / (float) font->potm->otmTextMetrics.tmAveCharWidth;
2983     }
2984
2985     left = (INT)(ft_face->glyph->metrics.horiBearingX * widthRatio) & -64;
2986     right = (INT)((ft_face->glyph->metrics.horiBearingX + ft_face->glyph->metrics.width) * widthRatio + 63) & -64;
2987
2988     font->gm[glyph_index].adv = (INT)((ft_face->glyph->metrics.horiAdvance * widthRatio) + 63) >> 6;
2989     font->gm[glyph_index].lsb = left >> 6;
2990     font->gm[glyph_index].bbx = (right - left) >> 6;
2991
2992     /* Scaling transform */
2993     if(font->aveWidth) {
2994         FT_Matrix scaleMat;
2995         scaleMat.xx = FT_FixedFromFloat(widthRatio);
2996         scaleMat.xy = 0;
2997         scaleMat.yx = 0;
2998         scaleMat.yy = (1 << 16);
2999
3000         pFT_Matrix_Multiply(&scaleMat, &transMat);
3001         needsTransform = TRUE;
3002     }
3003
3004     /* Slant transform */
3005     if (font->fake_italic) {
3006         FT_Matrix slantMat;
3007
3008         slantMat.xx = (1 << 16);
3009         slantMat.xy = ((1 << 16) >> 2);
3010         slantMat.yx = 0;
3011         slantMat.yy = (1 << 16);
3012         pFT_Matrix_Multiply(&slantMat, &transMat);
3013         needsTransform = TRUE;
3014     }
3015
3016     /* Rotation transform */
3017     if(font->orientation) {
3018         FT_Matrix rotationMat;
3019         FT_Vector vecAngle;
3020         angle = FT_FixedFromFloat((float)font->orientation / 10.0);
3021         pFT_Vector_Unit(&vecAngle, angle);
3022         rotationMat.xx = vecAngle.x;
3023         rotationMat.xy = -vecAngle.y;
3024         rotationMat.yx = -rotationMat.xy;
3025         rotationMat.yy = rotationMat.xx;
3026
3027         pFT_Matrix_Multiply(&rotationMat, &transMat);
3028         needsTransform = TRUE;
3029     }
3030
3031     /* Extra transformation specified by caller */
3032     if (lpmat) {
3033         FT_Matrix extraMat;
3034         extraMat.xx = FT_FixedFromFIXED(lpmat->eM11);
3035         extraMat.xy = FT_FixedFromFIXED(lpmat->eM21);
3036         extraMat.yx = FT_FixedFromFIXED(lpmat->eM12);
3037         extraMat.yy = FT_FixedFromFIXED(lpmat->eM22);
3038         pFT_Matrix_Multiply(&extraMat, &transMat);
3039         needsTransform = TRUE;
3040     }
3041
3042     if(!needsTransform) {
3043         top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
3044         bottom = (ft_face->glyph->metrics.horiBearingY -
3045                   ft_face->glyph->metrics.height) & -64;
3046         lpgm->gmCellIncX = font->gm[glyph_index].adv;
3047         lpgm->gmCellIncY = 0;
3048     } else {
3049         INT xc, yc;
3050         FT_Vector vec;
3051         for(xc = 0; xc < 2; xc++) {
3052             for(yc = 0; yc < 2; yc++) {
3053                 vec.x = (ft_face->glyph->metrics.horiBearingX +
3054                   xc * ft_face->glyph->metrics.width);
3055                 vec.y = ft_face->glyph->metrics.horiBearingY -
3056                   yc * ft_face->glyph->metrics.height;
3057                 TRACE("Vec %ld,%ld\n", vec.x, vec.y);
3058                 pFT_Vector_Transform(&vec, &transMat);
3059                 if(xc == 0 && yc == 0) {
3060                     left = right = vec.x;
3061                     top = bottom = vec.y;
3062                 } else {
3063                     if(vec.x < left) left = vec.x;
3064                     else if(vec.x > right) right = vec.x;
3065                     if(vec.y < bottom) bottom = vec.y;
3066                     else if(vec.y > top) top = vec.y;
3067                 }
3068             }
3069         }
3070         left = left & -64;
3071         right = (right + 63) & -64;
3072         bottom = bottom & -64;
3073         top = (top + 63) & -64;
3074
3075         TRACE("transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
3076         vec.x = ft_face->glyph->metrics.horiAdvance;
3077         vec.y = 0;
3078         pFT_Vector_Transform(&vec, &transMat);
3079         lpgm->gmCellIncX = (vec.x+63) >> 6;
3080         lpgm->gmCellIncY = -((vec.y+63) >> 6);
3081     }
3082     lpgm->gmBlackBoxX = (right - left) >> 6;
3083     lpgm->gmBlackBoxY = (top - bottom) >> 6;
3084     lpgm->gmptGlyphOrigin.x = left >> 6;
3085     lpgm->gmptGlyphOrigin.y = top >> 6;
3086
3087     memcpy(&font->gm[glyph_index].gm, lpgm, sizeof(*lpgm));
3088     font->gm[glyph_index].init = TRUE;
3089
3090     if(format == GGO_METRICS)
3091         return 1; /* FIXME */
3092
3093     if(ft_face->glyph->format != ft_glyph_format_outline && format != GGO_BITMAP) {
3094         TRACE("loaded a bitmap\n");
3095         return GDI_ERROR;
3096     }
3097
3098     switch(format) {
3099     case GGO_BITMAP:
3100         width = lpgm->gmBlackBoxX;
3101         height = lpgm->gmBlackBoxY;
3102         pitch = ((width + 31) >> 5) << 2;
3103         needed = pitch * height;
3104
3105         if(!buf || !buflen) break;
3106
3107         switch(ft_face->glyph->format) {
3108         case ft_glyph_format_bitmap:
3109           {
3110             BYTE *src = ft_face->glyph->bitmap.buffer, *dst = buf;
3111             INT w = (ft_face->glyph->bitmap.width + 7) >> 3;
3112             INT h = ft_face->glyph->bitmap.rows;
3113             while(h--) {
3114                 memcpy(dst, src, w);
3115                 src += ft_face->glyph->bitmap.pitch;
3116                 dst += pitch;
3117             }
3118             break;
3119           }
3120
3121         case ft_glyph_format_outline:
3122             ft_bitmap.width = width;
3123             ft_bitmap.rows = height;
3124             ft_bitmap.pitch = pitch;
3125             ft_bitmap.pixel_mode = ft_pixel_mode_mono;
3126             ft_bitmap.buffer = buf;
3127
3128                 if(needsTransform) {
3129                         pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
3130             }
3131
3132             pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
3133
3134             /* Note: FreeType will only set 'black' bits for us. */
3135             memset(buf, 0, needed);
3136             pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
3137             break;
3138
3139         default:
3140             FIXME("loaded glyph format %x\n", ft_face->glyph->format);
3141             return GDI_ERROR;
3142         }
3143         break;
3144
3145     case GGO_GRAY2_BITMAP:
3146     case GGO_GRAY4_BITMAP:
3147     case GGO_GRAY8_BITMAP:
3148     case WINE_GGO_GRAY16_BITMAP:
3149       {
3150         unsigned int mult, row, col;
3151         BYTE *start, *ptr;
3152
3153         width = lpgm->gmBlackBoxX;
3154         height = lpgm->gmBlackBoxY;
3155         pitch = (width + 3) / 4 * 4;
3156         needed = pitch * height;
3157
3158         if(!buf || !buflen) break;
3159         ft_bitmap.width = width;
3160         ft_bitmap.rows = height;
3161         ft_bitmap.pitch = pitch;
3162         ft_bitmap.pixel_mode = ft_pixel_mode_grays;
3163         ft_bitmap.buffer = buf;
3164
3165         if(needsTransform) {
3166                 pFT_Outline_Transform(&ft_face->glyph->outline, &transMat);
3167         }
3168
3169         pFT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
3170
3171         memset(ft_bitmap.buffer, 0, buflen);
3172
3173         pFT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
3174
3175         if(format == GGO_GRAY2_BITMAP)
3176             mult = 4;
3177         else if(format == GGO_GRAY4_BITMAP)
3178             mult = 16;
3179         else if(format == GGO_GRAY8_BITMAP)
3180             mult = 64;
3181         else if(format == WINE_GGO_GRAY16_BITMAP)
3182             break;
3183         else {
3184             assert(0);
3185             break;
3186         }
3187
3188         start = buf;
3189         for(row = 0; row < height; row++) {
3190             ptr = start;
3191             for(col = 0; col < width; col++, ptr++) {
3192                 *ptr = (((int)*ptr) * mult + 128) / 256;
3193             }
3194             start += pitch;
3195         }
3196         break;
3197       }
3198
3199     case GGO_NATIVE:
3200       {
3201         int contour, point = 0, first_pt;
3202         FT_Outline *outline = &ft_face->glyph->outline;
3203         TTPOLYGONHEADER *pph;
3204         TTPOLYCURVE *ppc;
3205         DWORD pph_start, cpfx, type;
3206
3207         if(buflen == 0) buf = NULL;
3208
3209         if (needsTransform && buf) {
3210                 pFT_Outline_Transform(outline, &transMat);
3211         }
3212
3213         for(contour = 0; contour < outline->n_contours; contour++) {
3214             pph_start = needed;
3215             pph = (TTPOLYGONHEADER *)((char *)buf + needed);
3216             first_pt = point;
3217             if(buf) {
3218                 pph->dwType = TT_POLYGON_TYPE;
3219                 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
3220             }
3221             needed += sizeof(*pph);
3222             point++;
3223             while(point <= outline->contours[contour]) {
3224                 ppc = (TTPOLYCURVE *)((char *)buf + needed);
3225                 type = (outline->tags[point] & FT_Curve_Tag_On) ?
3226                   TT_PRIM_LINE : TT_PRIM_QSPLINE;
3227                 cpfx = 0;
3228                 do {
3229                     if(buf)
3230                         FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3231                     cpfx++;
3232                     point++;
3233                 } while(point <= outline->contours[contour] &&
3234                         (outline->tags[point] & FT_Curve_Tag_On) ==
3235                         (outline->tags[point-1] & FT_Curve_Tag_On));
3236                 /* At the end of a contour Windows adds the start point, but
3237                    only for Beziers */
3238                 if(point > outline->contours[contour] &&
3239                    !(outline->tags[point-1] & FT_Curve_Tag_On)) {
3240                     if(buf)
3241                         FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
3242                     cpfx++;
3243                 } else if(point <= outline->contours[contour] &&
3244                           outline->tags[point] & FT_Curve_Tag_On) {
3245                   /* add closing pt for bezier */
3246                     if(buf)
3247                         FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3248                     cpfx++;
3249                     point++;
3250                 }
3251                 if(buf) {
3252                     ppc->wType = type;
3253                     ppc->cpfx = cpfx;
3254                 }
3255                 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
3256             }
3257             if(buf)
3258                 pph->cb = needed - pph_start;
3259         }
3260         break;
3261       }
3262     case GGO_BEZIER:
3263       {
3264         /* Convert the quadratic Beziers to cubic Beziers.
3265            The parametric eqn for a cubic Bezier is, from PLRM:
3266            r(t) = at^3 + bt^2 + ct + r0
3267            with the control points:
3268            r1 = r0 + c/3
3269            r2 = r1 + (c + b)/3
3270            r3 = r0 + c + b + a
3271
3272            A quadratic Beizer has the form:
3273            p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
3274
3275            So equating powers of t leads to:
3276            r1 = 2/3 p1 + 1/3 p0
3277            r2 = 2/3 p1 + 1/3 p2
3278            and of course r0 = p0, r3 = p2
3279         */
3280
3281         int contour, point = 0, first_pt;
3282         FT_Outline *outline = &ft_face->glyph->outline;
3283         TTPOLYGONHEADER *pph;
3284         TTPOLYCURVE *ppc;
3285         DWORD pph_start, cpfx, type;
3286         FT_Vector cubic_control[4];
3287         if(buflen == 0) buf = NULL;
3288
3289         if (needsTransform && buf) {
3290                 pFT_Outline_Transform(outline, &transMat);
3291         }
3292
3293         for(contour = 0; contour < outline->n_contours; contour++) {
3294             pph_start = needed;
3295             pph = (TTPOLYGONHEADER *)((char *)buf + needed);
3296             first_pt = point;
3297             if(buf) {
3298                 pph->dwType = TT_POLYGON_TYPE;
3299                 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
3300             }
3301             needed += sizeof(*pph);
3302             point++;
3303             while(point <= outline->contours[contour]) {
3304                 ppc = (TTPOLYCURVE *)((char *)buf + needed);
3305                 type = (outline->tags[point] & FT_Curve_Tag_On) ?
3306                   TT_PRIM_LINE : TT_PRIM_CSPLINE;
3307                 cpfx = 0;
3308                 do {
3309                     if(type == TT_PRIM_LINE) {
3310                         if(buf)
3311                             FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
3312                         cpfx++;
3313                         point++;
3314                     } else {
3315                       /* Unlike QSPLINEs, CSPLINEs always have their endpoint
3316                          so cpfx = 3n */
3317
3318                       /* FIXME: Possible optimization in endpoint calculation
3319                          if there are two consecutive curves */
3320                         cubic_control[0] = outline->points[point-1];
3321                         if(!(outline->tags[point-1] & FT_Curve_Tag_On)) {
3322                             cubic_control[0].x += outline->points[point].x + 1;
3323                             cubic_control[0].y += outline->points[point].y + 1;
3324                             cubic_control[0].x >>= 1;
3325                             cubic_control[0].y >>= 1;
3326                         }
3327                         if(point+1 > outline->contours[contour])
3328                             cubic_control[3] = outline->points[first_pt];
3329                         else {
3330                             cubic_control[3] = outline->points[point+1];
3331                             if(!(outline->tags[point+1] & FT_Curve_Tag_On)) {
3332                                 cubic_control[3].x += outline->points[point].x + 1;
3333                                 cubic_control[3].y += outline->points[point].y + 1;
3334                                 cubic_control[3].x >>= 1;
3335                                 cubic_control[3].y >>= 1;
3336                             }
3337                         }
3338                         /* r1 = 1/3 p0 + 2/3 p1
3339                            r2 = 1/3 p2 + 2/3 p1 */
3340                         cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
3341                         cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
3342                         cubic_control[2] = cubic_control[1];
3343                         cubic_control[1].x += (cubic_control[0].x + 1) / 3;
3344                         cubic_control[1].y += (cubic_control[0].y + 1) / 3;
3345                         cubic_control[2].x += (cubic_control[3].x + 1) / 3;
3346                         cubic_control[2].y += (cubic_control[3].y + 1) / 3;
3347                         if(buf) {
3348                             FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
3349                             FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
3350                             FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
3351                         }
3352                         cpfx += 3;
3353                         point++;
3354                     }
3355                 } while(point <= outline->contours[contour] &&
3356                         (outline->tags[point] & FT_Curve_Tag_On) ==
3357                         (outline->tags[point-1] & FT_Curve_Tag_On));
3358                 /* At the end of a contour Windows adds the start point,
3359                    but only for Beziers and we've already done that.
3360                 */
3361                 if(point <= outline->contours[contour] &&
3362                    outline->tags[point] & FT_Curve_Tag_On) {
3363                   /* This is the closing pt of a bezier, but we've already
3364                      added it, so just inc point and carry on */
3365                     point++;
3366                 }
3367                 if(buf) {
3368                     ppc->wType = type;
3369                     ppc->cpfx = cpfx;
3370                 }
3371                 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
3372             }
3373             if(buf)
3374                 pph->cb = needed - pph_start;
3375         }
3376         break;
3377       }
3378
3379     default:
3380         FIXME("Unsupported format %d\n", format);
3381         return GDI_ERROR;
3382     }
3383     return needed;
3384 }
3385
3386 static BOOL get_bitmap_text_metrics(GdiFont *font)
3387 {
3388     FT_Face ft_face = font->ft_face;
3389 #ifdef HAVE_FREETYPE_FTWINFNT_H
3390     FT_WinFNT_HeaderRec winfnt_header;
3391 #endif
3392     const DWORD size = offsetof(OUTLINETEXTMETRICW, otmFiller);
3393     font->potm = HeapAlloc(GetProcessHeap(), 0, size);
3394     font->potm->otmSize = size;
3395
3396 #define TM font->potm->otmTextMetrics
3397 #ifdef HAVE_FREETYPE_FTWINFNT_H
3398     if(pFT_Get_WinFNT_Header && !pFT_Get_WinFNT_Header(ft_face, &winfnt_header))
3399     {
3400         TM.tmHeight = winfnt_header.pixel_height;
3401         TM.tmAscent = winfnt_header.ascent;
3402         TM.tmDescent = TM.tmHeight - TM.tmAscent;
3403         TM.tmInternalLeading = winfnt_header.internal_leading;
3404         TM.tmExternalLeading = winfnt_header.external_leading;
3405         TM.tmAveCharWidth = winfnt_header.avg_width;
3406         TM.tmMaxCharWidth = winfnt_header.max_width;
3407         TM.tmWeight = winfnt_header.weight;
3408         TM.tmOverhang = 0;
3409         TM.tmDigitizedAspectX = winfnt_header.horizontal_resolution;
3410         TM.tmDigitizedAspectY = winfnt_header.vertical_resolution;
3411         TM.tmFirstChar = winfnt_header.first_char;
3412         TM.tmLastChar = winfnt_header.last_char;
3413         TM.tmDefaultChar = winfnt_header.default_char + winfnt_header.first_char;
3414         TM.tmBreakChar = winfnt_header.break_char + winfnt_header.first_char;
3415         TM.tmItalic = winfnt_header.italic;
3416         TM.tmUnderlined = font->underline;
3417         TM.tmStruckOut = font->strikeout;
3418         TM.tmPitchAndFamily = winfnt_header.pitch_and_family;
3419         TM.tmCharSet = winfnt_header.charset;
3420     }
3421     else
3422 #endif
3423     {
3424         TM.tmAscent = ft_face->size->metrics.ascender >> 6;
3425         TM.tmDescent = -ft_face->size->metrics.descender >> 6;
3426         TM.tmHeight = TM.tmAscent + TM.tmDescent;
3427         TM.tmInternalLeading = TM.tmHeight - ft_face->size->metrics.y_ppem;
3428         TM.tmExternalLeading = (ft_face->size->metrics.height >> 6) - TM.tmHeight;
3429         TM.tmMaxCharWidth = ft_face->size->metrics.max_advance >> 6;
3430         TM.tmAveCharWidth = TM.tmMaxCharWidth * 2 / 3; /* FIXME */
3431         TM.tmWeight = ft_face->style_flags & FT_STYLE_FLAG_BOLD ? FW_BOLD : FW_NORMAL;
3432         TM.tmOverhang = 0;
3433         TM.tmDigitizedAspectX = 96; /* FIXME */
3434         TM.tmDigitizedAspectY = 96; /* FIXME */
3435         TM.tmFirstChar = 1;
3436         TM.tmLastChar = 255;
3437         TM.tmDefaultChar = 32;
3438         TM.tmBreakChar = 32;
3439         TM.tmItalic = ft_face->style_flags & FT_STYLE_FLAG_ITALIC ? 1 : 0;
3440         TM.tmUnderlined = font->underline;
3441         TM.tmStruckOut = font->strikeout;
3442         /* NB inverted meaning of TMPF_FIXED_PITCH */
3443         TM.tmPitchAndFamily = ft_face->face_flags & FT_FACE_FLAG_FIXED_WIDTH ? 0 : TMPF_FIXED_PITCH;
3444         TM.tmCharSet = font->charset;
3445     }
3446 #undef TM
3447
3448     return TRUE;
3449 }
3450
3451 /*************************************************************
3452  * WineEngGetTextMetrics
3453  *
3454  */
3455 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
3456 {
3457     if(!font->potm) {
3458         if(!WineEngGetOutlineTextMetrics(font, 0, NULL))
3459             if(!get_bitmap_text_metrics(font))
3460                 return FALSE;
3461     }
3462     if(!font->potm) return FALSE;
3463     memcpy(ptm, &font->potm->otmTextMetrics, sizeof(*ptm));
3464
3465     if (font->aveWidth) {
3466         ptm->tmAveCharWidth = font->aveWidth * font->font_desc.matrix.eM11;
3467     }
3468     return TRUE;
3469 }
3470
3471
3472 /*************************************************************
3473  * WineEngGetOutlineTextMetrics
3474  *
3475  */
3476 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
3477                                   OUTLINETEXTMETRICW *potm)
3478 {
3479     FT_Face ft_face = font->ft_face;
3480     UINT needed, lenfam, lensty, ret;
3481     TT_OS2 *pOS2;
3482     TT_HoriHeader *pHori;
3483     TT_Postscript *pPost;
3484     FT_Fixed x_scale, y_scale;
3485     WCHAR *family_nameW, *style_nameW;
3486     static const WCHAR spaceW[] = {' ', '\0'};
3487     char *cp;
3488     INT ascent, descent;
3489
3490     TRACE("font=%p\n", font);
3491
3492     if(!FT_IS_SCALABLE(ft_face))
3493         return 0;
3494
3495     if(font->potm) {
3496         if(cbSize >= font->potm->otmSize)
3497             memcpy(potm, font->potm, font->potm->otmSize);
3498         return font->potm->otmSize;
3499     }
3500
3501
3502     needed = sizeof(*potm);
3503
3504     lenfam = (strlenW(font->name) + 1) * sizeof(WCHAR);
3505     family_nameW = strdupW(font->name);
3506
3507     lensty = MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1, NULL, 0)
3508       * sizeof(WCHAR);
3509     style_nameW = HeapAlloc(GetProcessHeap(), 0, lensty);
3510     MultiByteToWideChar(CP_ACP, 0, ft_face->style_name, -1,
3511                         style_nameW, lensty/sizeof(WCHAR));
3512
3513     /* These names should be read from the TT name table */
3514
3515     /* length of otmpFamilyName */
3516     needed += lenfam;
3517
3518     /* length of otmpFaceName */
3519     if(!strcasecmp(ft_face->style_name, "regular")) {
3520       needed += lenfam; /* just the family name */
3521     } else {
3522       needed += lenfam + lensty; /* family + " " + style */
3523     }
3524
3525     /* length of otmpStyleName */
3526     needed += lensty;
3527
3528     /* length of otmpFullName */
3529     needed += lenfam + lensty;
3530
3531
3532     x_scale = ft_face->size->metrics.x_scale;
3533     y_scale = ft_face->size->metrics.y_scale;
3534
3535     pOS2 = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_os2);
3536     if(!pOS2) {
3537         FIXME("Can't find OS/2 table - not TT font?\n");
3538         ret = 0;
3539         goto end;
3540     }
3541
3542     pHori = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_hhea);
3543     if(!pHori) {
3544         FIXME("Can't find HHEA table - not TT font?\n");
3545         ret = 0;
3546         goto end;
3547     }
3548
3549     pPost = pFT_Get_Sfnt_Table(ft_face, ft_sfnt_post); /* we can live with this failing */
3550
3551     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",
3552           pOS2->usWinAscent, pOS2->usWinDescent,
3553           pOS2->sTypoAscender, pOS2->sTypoDescender, pOS2->sTypoLineGap,
3554           ft_face->ascender, ft_face->descender, ft_face->height,
3555           pHori->Ascender, pHori->Descender, pHori->Line_Gap,
3556           ft_face->bbox.yMax, ft_face->bbox.yMin);
3557
3558     font->potm = HeapAlloc(GetProcessHeap(), 0, needed);
3559     font->potm->otmSize = needed;
3560
3561 #define TM font->potm->otmTextMetrics
3562
3563     if(pOS2->usWinAscent + pOS2->usWinDescent == 0) {
3564         ascent = pHori->Ascender;
3565         descent = -pHori->Descender;
3566     } else {
3567         ascent = pOS2->usWinAscent;
3568         descent = pOS2->usWinDescent;
3569     }
3570
3571     if(font->yMax) {
3572         TM.tmAscent = font->yMax;
3573         TM.tmDescent = -font->yMin;
3574         TM.tmInternalLeading = (TM.tmAscent + TM.tmDescent) - ft_face->size->metrics.y_ppem;
3575     } else {
3576         TM.tmAscent = (pFT_MulFix(ascent, y_scale) + 32) >> 6;
3577         TM.tmDescent = (pFT_MulFix(descent, y_scale) + 32) >> 6;
3578         TM.tmInternalLeading = (pFT_MulFix(ascent + descent
3579                                             - ft_face->units_per_EM, y_scale) + 32) >> 6;
3580     }
3581
3582     TM.tmHeight = TM.tmAscent + TM.tmDescent;
3583
3584     /* MSDN says:
3585      el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
3586     */
3587     TM.tmExternalLeading = max(0, (pFT_MulFix(pHori->Line_Gap -
3588                  ((ascent + descent) -
3589                   (pHori->Ascender - pHori->Descender)), y_scale) + 32) >> 6);
3590
3591     TM.tmAveCharWidth = (pFT_MulFix(pOS2->xAvgCharWidth, x_scale) + 32) >> 6;
3592     if (TM.tmAveCharWidth == 0) {
3593         TM.tmAveCharWidth = 1;
3594     }
3595     TM.tmMaxCharWidth = (pFT_MulFix(ft_face->bbox.xMax - ft_face->bbox.xMin, x_scale) + 32) >> 6;
3596     TM.tmWeight = font->fake_bold ? FW_BOLD : pOS2->usWeightClass;
3597     TM.tmOverhang = 0;
3598     TM.tmDigitizedAspectX = 300;
3599     TM.tmDigitizedAspectY = 300;
3600     TM.tmFirstChar = pOS2->usFirstCharIndex;
3601     TM.tmLastChar = pOS2->usLastCharIndex;
3602     TM.tmDefaultChar = pOS2->usDefaultChar;
3603     TM.tmBreakChar = pOS2->usBreakChar ? pOS2->usBreakChar : ' ';
3604     TM.tmItalic = font->fake_italic ? 255 : ((ft_face->style_flags & FT_STYLE_FLAG_ITALIC) ? 255 : 0);
3605     TM.tmUnderlined = font->underline;
3606     TM.tmStruckOut = font->strikeout;
3607
3608     /* Yes TPMF_FIXED_PITCH is correct; braindead api */
3609     if(!FT_IS_FIXED_WIDTH(ft_face) &&
3610        (pOS2->version == 0xFFFFU ||
3611         pOS2->panose[PAN_PROPORTION_INDEX] != PAN_PROP_MONOSPACED))
3612         TM.tmPitchAndFamily = TMPF_FIXED_PITCH;
3613     else
3614         TM.tmPitchAndFamily = 0;
3615
3616     switch(pOS2->panose[PAN_FAMILYTYPE_INDEX]) {
3617     case PAN_FAMILY_SCRIPT:
3618         TM.tmPitchAndFamily |= FF_SCRIPT;
3619         break;
3620     case PAN_FAMILY_DECORATIVE:
3621     case PAN_FAMILY_PICTORIAL:
3622         TM.tmPitchAndFamily |= FF_DECORATIVE;
3623         break;
3624     case PAN_FAMILY_TEXT_DISPLAY:
3625         if(TM.tmPitchAndFamily == 0) /* fixed */
3626             TM.tmPitchAndFamily = FF_MODERN;
3627         else {
3628             switch(pOS2->panose[PAN_SERIFSTYLE_INDEX]) {
3629             case PAN_SERIF_NORMAL_SANS:
3630             case PAN_SERIF_OBTUSE_SANS:
3631             case PAN_SERIF_PERP_SANS:
3632                 TM.tmPitchAndFamily |= FF_SWISS;
3633                 break;
3634             default:
3635                 TM.tmPitchAndFamily |= FF_ROMAN;
3636             }
3637         }
3638         break;
3639     default:
3640         TM.tmPitchAndFamily |= FF_DONTCARE;
3641     }
3642
3643     if(FT_IS_SCALABLE(ft_face))
3644         TM.tmPitchAndFamily |= TMPF_VECTOR;
3645     if(FT_IS_SFNT(ft_face))
3646         TM.tmPitchAndFamily |= TMPF_TRUETYPE;
3647
3648     TM.tmCharSet = font->charset;
3649 #undef TM
3650
3651     font->potm->otmFiller = 0;
3652     memcpy(&font->potm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
3653     font->potm->otmfsSelection = pOS2->fsSelection;
3654     font->potm->otmfsType = pOS2->fsType;
3655     font->potm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
3656     font->potm->otmsCharSlopeRun = pHori->caret_Slope_Run;
3657     font->potm->otmItalicAngle = 0; /* POST table */
3658     font->potm->otmEMSquare = ft_face->units_per_EM;
3659     font->potm->otmAscent = (pFT_MulFix(pOS2->sTypoAscender, y_scale) + 32) >> 6;
3660     font->potm->otmDescent = (pFT_MulFix(pOS2->sTypoDescender, y_scale) + 32) >> 6;
3661     font->potm->otmLineGap = (pFT_MulFix(pOS2->sTypoLineGap, y_scale) + 32) >> 6;
3662     font->potm->otmsCapEmHeight = (pFT_MulFix(pOS2->sCapHeight, y_scale) + 32) >> 6;
3663     font->potm->otmsXHeight = (pFT_MulFix(pOS2->sxHeight, y_scale) + 32) >> 6;
3664     font->potm->otmrcFontBox.left = (pFT_MulFix(ft_face->bbox.xMin, x_scale) + 32) >> 6;
3665     font->potm->otmrcFontBox.right = (pFT_MulFix(ft_face->bbox.xMax, x_scale) + 32) >> 6;
3666     font->potm->otmrcFontBox.top = (pFT_MulFix(ft_face->bbox.yMax, y_scale) + 32) >> 6;
3667     font->potm->otmrcFontBox.bottom = (pFT_MulFix(ft_face->bbox.yMin, y_scale) + 32) >> 6;
3668     font->potm->otmMacAscent = 0; /* where do these come from ? */
3669     font->potm->otmMacDescent = 0;
3670     font->potm->otmMacLineGap = 0;
3671     font->potm->otmusMinimumPPEM = 0; /* TT Header */
3672     font->potm->otmptSubscriptSize.x = (pFT_MulFix(pOS2->ySubscriptXSize, x_scale) + 32) >> 6;
3673     font->potm->otmptSubscriptSize.y = (pFT_MulFix(pOS2->ySubscriptYSize, y_scale) + 32) >> 6;
3674     font->potm->otmptSubscriptOffset.x = (pFT_MulFix(pOS2->ySubscriptXOffset, x_scale) + 32) >> 6;
3675     font->potm->otmptSubscriptOffset.y = (pFT_MulFix(pOS2->ySubscriptYOffset, y_scale) + 32) >> 6;
3676     font->potm->otmptSuperscriptSize.x = (pFT_MulFix(pOS2->ySuperscriptXSize, x_scale) + 32) >> 6;
3677     font->potm->otmptSuperscriptSize.y = (pFT_MulFix(pOS2->ySuperscriptYSize, y_scale) + 32) >> 6;
3678     font->potm->otmptSuperscriptOffset.x = (pFT_MulFix(pOS2->ySuperscriptXOffset, x_scale) + 32) >> 6;
3679     font->potm->otmptSuperscriptOffset.y = (pFT_MulFix(pOS2->ySuperscriptYOffset, y_scale) + 32) >> 6;
3680     font->potm->otmsStrikeoutSize = (pFT_MulFix(pOS2->yStrikeoutSize, y_scale) + 32) >> 6;
3681     font->potm->otmsStrikeoutPosition = (pFT_MulFix(pOS2->yStrikeoutPosition, y_scale) + 32) >> 6;
3682     if(!pPost) {
3683         font->potm->otmsUnderscoreSize = 0;
3684         font->potm->otmsUnderscorePosition = 0;
3685     } else {
3686         font->potm->otmsUnderscoreSize = (pFT_MulFix(pPost->underlineThickness, y_scale) + 32) >> 6;
3687         font->potm->otmsUnderscorePosition = (pFT_MulFix(pPost->underlinePosition, y_scale) + 32) >> 6;
3688     }
3689
3690     /* otmp* members should clearly have type ptrdiff_t, but M$ knows best */
3691     cp = (char*)font->potm + sizeof(*font->potm);
3692     font->potm->otmpFamilyName = (LPSTR)(cp - (char*)font->potm);
3693     strcpyW((WCHAR*)cp, family_nameW);
3694     cp += lenfam;
3695     font->potm->otmpStyleName = (LPSTR)(cp - (char*)font->potm);
3696     strcpyW((WCHAR*)cp, style_nameW);
3697     cp += lensty;
3698     font->potm->otmpFaceName = (LPSTR)(cp - (char*)font->potm);
3699     strcpyW((WCHAR*)cp, family_nameW);
3700     if(strcasecmp(ft_face->style_name, "regular")) {
3701         strcatW((WCHAR*)cp, spaceW);
3702         strcatW((WCHAR*)cp, style_nameW);
3703         cp += lenfam + lensty;
3704     } else
3705         cp += lenfam;
3706     font->potm->otmpFullName = (LPSTR)(cp - (char*)font->potm);
3707     strcpyW((WCHAR*)cp, family_nameW);
3708     strcatW((WCHAR*)cp, spaceW);
3709     strcatW((WCHAR*)cp, style_nameW);
3710     ret = needed;
3711
3712     if(potm && needed <= cbSize)
3713         memcpy(potm, font->potm, font->potm->otmSize);
3714
3715 end:
3716     HeapFree(GetProcessHeap(), 0, style_nameW);
3717     HeapFree(GetProcessHeap(), 0, family_nameW);
3718
3719     return ret;
3720 }
3721
3722 static BOOL load_child_font(GdiFont *font, CHILD_FONT *child)
3723 {
3724     HFONTLIST *hfontlist;
3725     child->font = alloc_font();
3726     child->font->ft_face = OpenFontFile(child->font, child->file_name, child->index, 0, -font->ppem);
3727     if(!child->font->ft_face)
3728     {
3729         free_font(child->font);
3730         child->font = NULL;
3731         return FALSE;
3732     }
3733
3734     child->font->orientation = font->orientation;
3735     hfontlist = HeapAlloc(GetProcessHeap(), 0, sizeof(*hfontlist));
3736     hfontlist->hfont = CreateFontIndirectW(&font->font_desc.lf);
3737     list_add_head(&child->font->hfontlist, &hfontlist->entry);
3738     child->font->base_font = font;
3739     list_add_head(&child_font_list, &child->font->entry);
3740     TRACE("created child font hfont %p for base %p child %p\n", hfontlist->hfont, font, child->font);
3741     return TRUE;
3742 }
3743
3744 static BOOL get_glyph_index_linked(GdiFont *font, UINT c, GdiFont **linked_font, FT_UInt *glyph)
3745 {
3746     FT_UInt g;
3747     CHILD_FONT *child_font;
3748
3749     if(font->base_font)
3750         font = font->base_font;
3751
3752     *linked_font = font;
3753
3754     if((*glyph = get_glyph_index(font, c)))
3755         return TRUE;
3756
3757     LIST_FOR_EACH_ENTRY(child_font, &font->child_fonts, CHILD_FONT, entry)
3758     {
3759         if(!child_font->font)
3760             if(!load_child_font(font, child_font))
3761                 continue;
3762
3763         if(!child_font->font->ft_face)
3764             continue;
3765         g = get_glyph_index(child_font->font, c);
3766         if(g)
3767         {
3768             *glyph = g;
3769             *linked_font = child_font->font;
3770             return TRUE;
3771         }
3772     }
3773     return FALSE;
3774 }
3775
3776 /*************************************************************
3777  * WineEngGetCharWidth
3778  *
3779  */
3780 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
3781                          LPINT buffer)
3782 {
3783     UINT c;
3784     GLYPHMETRICS gm;
3785     FT_UInt glyph_index;
3786     GdiFont *linked_font;
3787
3788     TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
3789
3790     for(c = firstChar; c <= lastChar; c++) {
3791         get_glyph_index_linked(font, c, &linked_font, &glyph_index);
3792         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
3793                                &gm, 0, NULL, NULL);
3794         buffer[c - firstChar] = linked_font->gm[glyph_index].adv;
3795     }
3796     return TRUE;
3797 }
3798
3799 /*************************************************************
3800  * WineEngGetCharABCWidths
3801  *
3802  */
3803 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
3804                              LPABC buffer)
3805 {
3806     UINT c;
3807     GLYPHMETRICS gm;
3808     FT_UInt glyph_index;
3809     GdiFont *linked_font;
3810
3811     TRACE("%p, %d, %d, %p\n", font, firstChar, lastChar, buffer);
3812
3813     if(!FT_IS_SCALABLE(font->ft_face))
3814         return FALSE;
3815
3816     for(c = firstChar; c <= lastChar; c++) {
3817         get_glyph_index_linked(font, c, &linked_font, &glyph_index);
3818         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
3819                                &gm, 0, NULL, NULL);
3820         buffer[c - firstChar].abcA = linked_font->gm[glyph_index].lsb;
3821         buffer[c - firstChar].abcB = linked_font->gm[glyph_index].bbx;
3822         buffer[c - firstChar].abcC = linked_font->gm[glyph_index].adv - linked_font->gm[glyph_index].lsb -
3823           linked_font->gm[glyph_index].bbx;
3824     }
3825     return TRUE;
3826 }
3827
3828 /*************************************************************
3829  * WineEngGetCharABCWidthsI
3830  *
3831  */
3832 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
3833                               LPABC buffer)
3834 {
3835     UINT c;
3836     GLYPHMETRICS gm;
3837     FT_UInt glyph_index;
3838     GdiFont *linked_font;
3839
3840     if(!FT_IS_SCALABLE(font->ft_face))
3841         return FALSE;
3842
3843     get_glyph_index_linked(font, 'a', &linked_font, &glyph_index);
3844     if (!pgi)
3845         for(c = firstChar; c < firstChar+count; c++) {
3846             WineEngGetGlyphOutline(linked_font, c, GGO_METRICS | GGO_GLYPH_INDEX,
3847                                    &gm, 0, NULL, NULL);
3848             buffer[c - firstChar].abcA = linked_font->gm[c].lsb;
3849             buffer[c - firstChar].abcB = linked_font->gm[c].bbx;
3850             buffer[c - firstChar].abcC = linked_font->gm[c].adv - linked_font->gm[c].lsb
3851                - linked_font->gm[c].bbx;
3852         }
3853     else
3854         for(c = 0; c < count; c++) {
3855             WineEngGetGlyphOutline(linked_font, pgi[c], GGO_METRICS | GGO_GLYPH_INDEX,
3856                                    &gm, 0, NULL, NULL);
3857             buffer[c].abcA = linked_font->gm[pgi[c]].lsb;
3858             buffer[c].abcB = linked_font->gm[pgi[c]].bbx;
3859             buffer[c].abcC = linked_font->gm[pgi[c]].adv
3860                - linked_font->gm[pgi[c]].lsb - linked_font->gm[pgi[c]].bbx;
3861         }
3862
3863     return TRUE;
3864 }
3865
3866 /*************************************************************
3867  * WineEngGetTextExtentExPoint
3868  *
3869  */
3870 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
3871                                  INT max_ext, LPINT pnfit, LPINT dxs, LPSIZE size)
3872 {
3873     INT idx;
3874     INT nfit = 0, ext;
3875     GLYPHMETRICS gm;
3876     TEXTMETRICW tm;
3877     FT_UInt glyph_index;
3878     GdiFont *linked_font;
3879
3880     TRACE("%p, %s, %d, %d, %p\n", font, debugstr_wn(wstr, count), count,
3881           max_ext, size);
3882
3883     size->cx = 0;
3884     WineEngGetTextMetrics(font, &tm);
3885     size->cy = tm.tmHeight;
3886
3887     for(idx = 0; idx < count; idx++) {
3888         get_glyph_index_linked(font, wstr[idx], &linked_font, &glyph_index);
3889         WineEngGetGlyphOutline(linked_font, glyph_index, GGO_METRICS | GGO_GLYPH_INDEX,
3890                                &gm, 0, NULL, NULL);
3891         size->cx += linked_font->gm[glyph_index].adv;
3892         ext = size->cx;
3893         if (! pnfit || ext <= max_ext) {
3894             ++nfit;
3895             if (dxs)
3896                 dxs[idx] = ext;
3897         }
3898     }
3899
3900     if (pnfit)
3901         *pnfit = nfit;
3902
3903     TRACE("return %ld, %ld, %d\n", size->cx, size->cy, nfit);
3904     return TRUE;
3905 }
3906
3907 /*************************************************************
3908  * WineEngGetTextExtentPointI
3909  *
3910  */
3911 BOOL WineEngGetTextExtentPointI(GdiFont *font, const WORD *indices, INT count,
3912                                 LPSIZE size)
3913 {
3914     INT idx;
3915     GLYPHMETRICS gm;
3916     TEXTMETRICW tm;
3917
3918     TRACE("%p, %p, %d, %p\n", font, indices, count, size);
3919
3920     size->cx = 0;
3921     WineEngGetTextMetrics(font, &tm);
3922     size->cy = tm.tmHeight;
3923
3924     for(idx = 0; idx < count; idx++) {
3925         WineEngGetGlyphOutline(font, indices[idx],
3926                                GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL,
3927                                NULL);
3928         size->cx += font->gm[indices[idx]].adv;
3929     }
3930     TRACE("return %ld,%ld\n", size->cx, size->cy);
3931     return TRUE;
3932 }
3933
3934 /*************************************************************
3935  * WineEngGetFontData
3936  *
3937  */
3938 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
3939                          DWORD cbData)
3940 {
3941     FT_Face ft_face = font->ft_face;
3942     FT_ULong len;
3943     FT_Error err;
3944
3945     TRACE("font=%p, table=%08lx, offset=%08lx, buf=%p, cbData=%lx\n",
3946         font, table, offset, buf, cbData);
3947
3948     if(!FT_IS_SFNT(ft_face))
3949         return GDI_ERROR;
3950
3951     if(!buf || !cbData)
3952         len = 0;
3953     else
3954         len = cbData;
3955
3956     if(table) { /* MS tags differ in endidness from FT ones */
3957         table = table >> 24 | table << 24 |
3958           (table >> 8 & 0xff00) | (table << 8 & 0xff0000);
3959     }
3960
3961     /* If the FT_Load_Sfnt_Table function is there we'll use it */
3962     if(pFT_Load_Sfnt_Table) {
3963         /* make sure value of len is the value freetype says it needs */
3964         if( buf && len) {
3965             FT_ULong needed = 0;
3966             err = pFT_Load_Sfnt_Table(ft_face, table, offset, NULL, &needed);
3967             if( !err && needed < len) len = needed;
3968         }
3969         err = pFT_Load_Sfnt_Table(ft_face, table, offset, buf, &len);
3970     }
3971 #ifdef HAVE_FREETYPE_INTERNAL_SFNT_H
3972     else { /* Do it the hard way */
3973         TT_Face tt_face = (TT_Face) ft_face;
3974         SFNT_Interface *sfnt;
3975         if (FT_Version.major==2 && FT_Version.minor==0)
3976         {
3977             /* 2.0.x */
3978             sfnt = *(SFNT_Interface**)((char*)tt_face + 528);
3979         }
3980         else
3981         {
3982             /* A field was added in the middle of the structure in 2.1.x */
3983             sfnt = *(SFNT_Interface**)((char*)tt_face + 532);
3984         }
3985         /* make sure value of len is the value freetype says it needs */
3986         if( buf && len) {
3987             FT_ULong needed = 0;
3988             err = sfnt->load_any(tt_face, table, offset, NULL, &needed);
3989             if( !err && needed < len) len = needed;
3990         }
3991         err = sfnt->load_any(tt_face, table, offset, buf, &len);
3992     }
3993 #else
3994     else {
3995         static int msg;
3996         if(!msg) {
3997             MESSAGE("This version of Wine was compiled with freetype headers later than 2.2.0\n"
3998                     "but is being run with a freetype library without the FT_Load_Sfnt_Table function.\n"
3999                     "Please upgrade your freetype library.\n");
4000             msg++;
4001         }
4002         err = FT_Err_Unimplemented_Feature;
4003     }
4004 #endif
4005     if(err) {
4006         TRACE("Can't find table %08lx.\n", table);
4007         return GDI_ERROR;
4008     }
4009     return len;
4010 }
4011
4012 /*************************************************************
4013  * WineEngGetTextFace
4014  *
4015  */
4016 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
4017 {
4018     if(str) {
4019         lstrcpynW(str, font->name, count);
4020         return strlenW(font->name);
4021     } else
4022         return strlenW(font->name) + 1;
4023 }
4024
4025 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
4026 {
4027     if (fs) memcpy(fs, &font->fs, sizeof(FONTSIGNATURE));
4028     return font->charset;
4029 }
4030
4031 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
4032 {
4033     GdiFont *font = dc->gdiFont, *linked_font;
4034     struct list *first_hfont;
4035     BOOL ret;
4036
4037     ret = get_glyph_index_linked(font, c, &linked_font, glyph);
4038     TRACE("get_glyph_index_linked glyph %d font %p\n", *glyph, linked_font);
4039     if(font == linked_font)
4040         *new_hfont = dc->hFont;
4041     else
4042     {
4043         first_hfont = list_head(&linked_font->hfontlist);
4044         *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
4045     }
4046
4047     return ret;
4048 }
4049
4050
4051 /*************************************************************
4052  *     FontIsLinked
4053  */
4054 BOOL WINAPI FontIsLinked(HDC hdc)
4055 {
4056     DC *dc = DC_GetDCPtr(hdc);
4057     BOOL ret = FALSE;
4058
4059     if(!dc) return FALSE;
4060     if(dc->gdiFont && !list_empty(&dc->gdiFont->child_fonts))
4061         ret = TRUE;
4062     GDI_ReleaseObj(hdc);
4063     TRACE("returning %d\n", ret);
4064     return ret;
4065 }
4066
4067 static BOOL is_hinting_enabled(void)
4068 {
4069     /* Use the >= 2.2.0 function if available */
4070     if(pFT_Get_TrueType_Engine_Type)
4071     {
4072         FT_TrueTypeEngineType type = pFT_Get_TrueType_Engine_Type(library);
4073         return type == FT_TRUETYPE_ENGINE_TYPE_PATENTED;
4074     }
4075 #ifdef FT_DRIVER_HAS_HINTER
4076     else
4077     {
4078         FT_Module mod;
4079
4080         /* otherwise if we've been compiled with < 2.2.0 headers
4081            use the internal macro */
4082         mod = pFT_Get_Module(library, "truetype");
4083         if(mod && FT_DRIVER_HAS_HINTER(mod))
4084             return TRUE;
4085     }
4086 #endif
4087
4088     return FALSE;
4089 }
4090
4091 /*************************************************************************
4092  *             GetRasterizerCaps   (GDI32.@)
4093  */
4094 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
4095 {
4096     static int hinting = -1;
4097
4098     if(hinting == -1)
4099         hinting = is_hinting_enabled();
4100
4101     lprs->nSize = sizeof(RASTERIZER_STATUS);
4102     lprs->wFlags = TT_AVAILABLE | TT_ENABLED | (hinting ? WINE_TT_HINTER_ENABLED : 0);
4103     lprs->nLanguageID = 0;
4104     return TRUE;
4105 }
4106
4107 /*************************************************************************
4108  * Kerning support for TrueType fonts
4109  */
4110 #define MS_KERN_TAG MS_MAKE_TAG('k', 'e', 'r', 'n')
4111
4112 struct TT_kern_table
4113 {
4114     USHORT version;
4115     USHORT nTables;
4116 };
4117
4118 struct TT_kern_subtable
4119 {
4120     USHORT version;
4121     USHORT length;
4122     union
4123     {
4124         USHORT word;
4125         struct
4126         {
4127             USHORT horizontal : 1;
4128             USHORT minimum : 1;
4129             USHORT cross_stream: 1;
4130             USHORT override : 1;
4131             USHORT reserved1 : 4;
4132             USHORT format : 8;
4133         } bits;
4134     } coverage;
4135 };
4136
4137 struct TT_format0_kern_subtable
4138 {
4139     USHORT nPairs;
4140     USHORT searchRange;
4141     USHORT entrySelector;
4142     USHORT rangeShift;
4143 };
4144
4145 struct TT_kern_pair
4146 {
4147     USHORT left;
4148     USHORT right;
4149     short  value;
4150 };
4151
4152 static DWORD parse_format0_kern_subtable(GdiFont *font,
4153                                          const struct TT_format0_kern_subtable *tt_f0_ks,
4154                                          const USHORT *glyph_to_char,
4155                                          KERNINGPAIR *kern_pair, DWORD cPairs)
4156 {
4157     USHORT i, nPairs;
4158     const struct TT_kern_pair *tt_kern_pair;
4159
4160     TRACE("font height %ld, units_per_EM %d\n", font->ppem, font->ft_face->units_per_EM);
4161
4162     nPairs = GET_BE_WORD(tt_f0_ks->nPairs);
4163
4164     TRACE("nPairs %u, searchRange %u, entrySelector %u, rangeShift %u\n",
4165            nPairs, GET_BE_WORD(tt_f0_ks->searchRange),
4166            GET_BE_WORD(tt_f0_ks->entrySelector), GET_BE_WORD(tt_f0_ks->rangeShift));
4167
4168     if (!kern_pair || !cPairs)
4169         return nPairs;
4170
4171     tt_kern_pair = (const struct TT_kern_pair *)(tt_f0_ks + 1);
4172
4173     nPairs = min(nPairs, cPairs);
4174
4175     for (i = 0; i < nPairs; i++)
4176     {
4177         kern_pair->wFirst = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].left)];
4178         kern_pair->wSecond = glyph_to_char[GET_BE_WORD(tt_kern_pair[i].right)];
4179         /* this algorithm appears to better match what Windows does */
4180         kern_pair->iKernAmount = (short)GET_BE_WORD(tt_kern_pair[i].value) * font->ppem;
4181         if (kern_pair->iKernAmount < 0)
4182         {
4183             kern_pair->iKernAmount -= font->ft_face->units_per_EM / 2;
4184             kern_pair->iKernAmount -= font->ppem;
4185         }
4186         else if (kern_pair->iKernAmount > 0)
4187         {
4188             kern_pair->iKernAmount += font->ft_face->units_per_EM / 2;
4189             kern_pair->iKernAmount += font->ppem;
4190         }
4191         kern_pair->iKernAmount /= font->ft_face->units_per_EM;
4192
4193         TRACE("left %u right %u value %d\n",
4194                kern_pair->wFirst, kern_pair->wSecond, kern_pair->iKernAmount);
4195
4196         kern_pair++;
4197     }
4198     TRACE("copied %u entries\n", nPairs);
4199     return nPairs;
4200 }
4201
4202 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
4203 {
4204     DWORD length;
4205     void *buf;
4206     const struct TT_kern_table *tt_kern_table;
4207     const struct TT_kern_subtable *tt_kern_subtable;
4208     USHORT i, nTables;
4209     USHORT *glyph_to_char;
4210
4211     if (font->total_kern_pairs != (DWORD)-1)
4212     {
4213         if (cPairs && kern_pair)
4214         {
4215             cPairs = min(cPairs, font->total_kern_pairs);
4216             memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
4217             return cPairs;
4218         }
4219         return font->total_kern_pairs;
4220     }
4221
4222     font->total_kern_pairs = 0;
4223
4224     length = WineEngGetFontData(font, MS_KERN_TAG, 0, NULL, 0);
4225
4226     if (length == GDI_ERROR)
4227     {
4228         TRACE("no kerning data in the font\n");
4229         return 0;
4230     }
4231
4232     buf = HeapAlloc(GetProcessHeap(), 0, length);
4233     if (!buf)
4234     {
4235         WARN("Out of memory\n");
4236         return 0;
4237     }
4238
4239     WineEngGetFontData(font, MS_KERN_TAG, 0, buf, length);
4240
4241     /* build a glyph index to char code map */
4242     glyph_to_char = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USHORT) * 65536);
4243     if (!glyph_to_char)
4244     {
4245         WARN("Out of memory allocating a glyph index to char code map\n");
4246         HeapFree(GetProcessHeap(), 0, buf);
4247         return 0;
4248     }
4249
4250     if (font->ft_face->charmap->encoding == FT_ENCODING_UNICODE && pFT_Get_First_Char)
4251     {
4252         FT_UInt glyph_code;
4253         FT_ULong char_code;
4254
4255         glyph_code = 0;
4256         char_code = pFT_Get_First_Char(font->ft_face, &glyph_code);
4257
4258         TRACE("face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %lu\n",
4259                font->ft_face->num_glyphs, glyph_code, char_code);
4260
4261         while (glyph_code)
4262         {
4263             /*TRACE("Char %04lX -> Index %u%s\n", char_code, glyph_code, glyph_to_char[glyph_code] ? "  !" : "" );*/
4264
4265             /* FIXME: This doesn't match what Windows does: it does some fancy
4266              * things with duplicate glyph index to char code mappings, while
4267              * we just avoid overriding existing entries.
4268              */
4269             if (glyph_code <= 65535 && !glyph_to_char[glyph_code])
4270                 glyph_to_char[glyph_code] = (USHORT)char_code;
4271
4272             char_code = pFT_Get_Next_Char(font->ft_face, char_code, &glyph_code);
4273         }
4274     }
4275     else
4276     {
4277         ULONG n;
4278
4279         FIXME("encoding %u not supported\n", font->ft_face->charmap->encoding);
4280         for (n = 0; n <= 65535; n++)
4281             glyph_to_char[n] = (USHORT)n;
4282     }
4283
4284     tt_kern_table = buf;
4285     nTables = GET_BE_WORD(tt_kern_table->nTables);
4286     TRACE("version %u, nTables %u\n",
4287            GET_BE_WORD(tt_kern_table->version), nTables);
4288
4289     tt_kern_subtable = (const struct TT_kern_subtable *)(tt_kern_table + 1);
4290
4291     for (i = 0; i < nTables; i++)
4292     {
4293         struct TT_kern_subtable tt_kern_subtable_copy;
4294
4295         tt_kern_subtable_copy.version = GET_BE_WORD(tt_kern_subtable->version);
4296         tt_kern_subtable_copy.length = GET_BE_WORD(tt_kern_subtable->length);
4297         tt_kern_subtable_copy.coverage.word = GET_BE_WORD(tt_kern_subtable->coverage.word);
4298
4299         TRACE("version %u, length %u, coverage %u, subtable format %u\n",
4300                tt_kern_subtable_copy.version, tt_kern_subtable_copy.length,
4301                tt_kern_subtable_copy.coverage.word, tt_kern_subtable_copy.coverage.bits.format);
4302
4303         /* According to the TrueType specification this is the only format
4304          * that will be properly interpreted by Windows and OS/2
4305          */
4306         if (tt_kern_subtable_copy.coverage.bits.format == 0)
4307         {
4308             DWORD new_chunk, old_total = font->total_kern_pairs;
4309
4310             new_chunk = parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
4311                                                     glyph_to_char, NULL, 0);
4312             font->total_kern_pairs += new_chunk;
4313
4314             if (!font->kern_pairs)
4315                 font->kern_pairs = HeapAlloc(GetProcessHeap(), 0,
4316                                              font->total_kern_pairs * sizeof(*font->kern_pairs));
4317             else
4318                 font->kern_pairs = HeapReAlloc(GetProcessHeap(), 0, font->kern_pairs,
4319                                                font->total_kern_pairs * sizeof(*font->kern_pairs));
4320
4321             parse_format0_kern_subtable(font, (const struct TT_format0_kern_subtable *)(tt_kern_subtable + 1),
4322                         glyph_to_char, font->kern_pairs + old_total, new_chunk);
4323         }
4324         else
4325             TRACE("skipping kerning table format %u\n", tt_kern_subtable_copy.coverage.bits.format);
4326
4327         tt_kern_subtable = (const struct TT_kern_subtable *)((const char *)tt_kern_subtable + tt_kern_subtable_copy.length);
4328     }
4329
4330     HeapFree(GetProcessHeap(), 0, glyph_to_char);
4331     HeapFree(GetProcessHeap(), 0, buf);
4332
4333     if (cPairs && kern_pair)
4334     {
4335         cPairs = min(cPairs, font->total_kern_pairs);
4336         memcpy(kern_pair, font->kern_pairs, cPairs * sizeof(*kern_pair));
4337         return cPairs;
4338     }
4339     return font->total_kern_pairs;
4340 }
4341
4342 #else /* HAVE_FREETYPE */
4343
4344 /*************************************************************************/
4345
4346 BOOL WineEngInit(void)
4347 {
4348     return FALSE;
4349 }
4350 GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
4351 {
4352     return NULL;
4353 }
4354 BOOL WineEngDestroyFontInstance(HFONT hfont)
4355 {
4356     return FALSE;
4357 }
4358
4359 DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
4360 {
4361     return 1;
4362 }
4363
4364 DWORD WineEngGetGlyphIndices(GdiFont *font, LPCWSTR lpstr, INT count,
4365                                 LPWORD pgi, DWORD flags)
4366 {
4367     return GDI_ERROR;
4368 }
4369
4370 DWORD WineEngGetGlyphOutline(GdiFont *font, UINT glyph, UINT format,
4371                              LPGLYPHMETRICS lpgm, DWORD buflen, LPVOID buf,
4372                              const MAT2* lpmat)
4373 {
4374     ERR("called but we don't have FreeType\n");
4375     return GDI_ERROR;
4376 }
4377
4378 BOOL WineEngGetTextMetrics(GdiFont *font, LPTEXTMETRICW ptm)
4379 {
4380     ERR("called but we don't have FreeType\n");
4381     return FALSE;
4382 }
4383
4384 UINT WineEngGetOutlineTextMetrics(GdiFont *font, UINT cbSize,
4385                                   OUTLINETEXTMETRICW *potm)
4386 {
4387     ERR("called but we don't have FreeType\n");
4388     return 0;
4389 }
4390
4391 BOOL WineEngGetCharWidth(GdiFont *font, UINT firstChar, UINT lastChar,
4392                          LPINT buffer)
4393 {
4394     ERR("called but we don't have FreeType\n");
4395     return FALSE;
4396 }
4397
4398 BOOL WineEngGetCharABCWidths(GdiFont *font, UINT firstChar, UINT lastChar,
4399                              LPABC buffer)
4400 {
4401     ERR("called but we don't have FreeType\n");
4402     return FALSE;
4403 }
4404
4405 BOOL WineEngGetCharABCWidthsI(GdiFont *font, UINT firstChar, UINT count, LPWORD pgi,
4406                               LPABC buffer)
4407 {
4408     ERR("called but we don't have FreeType\n");
4409     return FALSE;
4410 }
4411
4412 BOOL WineEngGetTextExtentExPoint(GdiFont *font, LPCWSTR wstr, INT count,
4413                                  INT max_ext, LPINT nfit, LPINT dx, LPSIZE size)
4414 {
4415     ERR("called but we don't have FreeType\n");
4416     return FALSE;
4417 }
4418
4419 BOOL WineEngGetTextExtentPointI(GdiFont *font, const WORD *indices, INT count,
4420                                 LPSIZE size)
4421 {
4422     ERR("called but we don't have FreeType\n");
4423     return FALSE;
4424 }
4425
4426 DWORD WineEngGetFontData(GdiFont *font, DWORD table, DWORD offset, LPVOID buf,
4427                          DWORD cbData)
4428 {
4429     ERR("called but we don't have FreeType\n");
4430     return GDI_ERROR;
4431 }
4432
4433 INT WineEngGetTextFace(GdiFont *font, INT count, LPWSTR str)
4434 {
4435     ERR("called but we don't have FreeType\n");
4436     return 0;
4437 }
4438
4439 INT WineEngAddFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
4440 {
4441     FIXME(":stub\n");
4442     return 1;
4443 }
4444
4445 INT WineEngRemoveFontResourceEx(LPCWSTR file, DWORD flags, PVOID pdv)
4446 {
4447     FIXME(":stub\n");
4448     return TRUE;
4449 }
4450
4451 UINT WineEngGetTextCharsetInfo(GdiFont *font, LPFONTSIGNATURE fs, DWORD flags)
4452 {
4453     FIXME(":stub\n");
4454     return DEFAULT_CHARSET;
4455 }
4456
4457 BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
4458 {
4459     return FALSE;
4460 }
4461
4462 BOOL WINAPI FontIsLinked(HDC hdc)
4463 {
4464     return FALSE;
4465 }
4466
4467 /*************************************************************************
4468  *             GetRasterizerCaps   (GDI32.@)
4469  */
4470 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
4471 {
4472     lprs->nSize = sizeof(RASTERIZER_STATUS);
4473     lprs->wFlags = 0;
4474     lprs->nLanguageID = 0;
4475     return TRUE;
4476 }
4477
4478 DWORD WineEngGetKerningPairs(GdiFont *font, DWORD cPairs, KERNINGPAIR *kern_pair)
4479 {
4480     ERR("called but we don't have FreeType\n");
4481     return 0;
4482 }
4483
4484 #endif /* HAVE_FREETYPE */