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

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