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

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