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

   1 /*
   2  * GDI font objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1997 Alex Korobka
   6  * Copyright 2002,2003 Shachar Shemesh
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <limits.h>
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <assert.h>
  31 #include "winerror.h"
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winnls.h"
  35 #include "winternl.h"
  36 #include "gdi_private.h"
  37 #include "wine/exception.h"
  38 #include "wine/unicode.h"
  39 #include "wine/debug.h"
  40
  41 #ifdef WORDS_BIGENDIAN
  42 #define get_be_word(x) (x)
  43 #else
  44 #define get_be_word(x) RtlUshortByteSwap(x)
  45 #endif
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(font);
  48
  49   /* Device -> World size conversion */
  50
  51 /* Performs a device to world transformation on the specified width (which
  52  * is in integer format).
  53  */
  54 static inline INT INTERNAL_XDSTOWS(DC *dc, INT width)
  55 {
  56     double floatWidth;
  57
  58     /* Perform operation with floating point */
  59     floatWidth = (double)width * dc->xformVport2World.eM11;
  60     /* Round to integers */
  61     return GDI_ROUND(floatWidth);
  62 }
  63
  64 /* Performs a device to world transformation on the specified size (which
  65  * is in integer format).
  66  */
  67 static inline INT INTERNAL_YDSTOWS(DC *dc, INT height)
  68 {
  69     double floatHeight;
  70
  71     /* Perform operation with floating point */
  72     floatHeight = (double)height * dc->xformVport2World.eM22;
  73     /* Round to integers */
  74     return GDI_ROUND(floatHeight);
  75 }
  76
  77 static inline INT INTERNAL_XWSTODS(DC *dc, INT width)
  78 {
  79     POINT pt[2];
  80     pt[0].x = pt[0].y = 0;
  81     pt[1].x = width;
  82     pt[1].y = 0;
  83     LPtoDP(dc->hSelf, pt, 2);
  84     return pt[1].x - pt[0].x;
  85 }
  86
  87 static inline INT INTERNAL_YWSTODS(DC *dc, INT height)
  88 {
  89     POINT pt[2];
  90     pt[0].x = pt[0].y = 0;
  91     pt[1].x = 0;
  92     pt[1].y = height;
  93     LPtoDP(dc->hSelf, pt, 2);
  94     return pt[1].y - pt[0].y;
  95 }
  96
  97 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, HDC hdc );
  98 static INT FONT_GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer );
  99 static INT FONT_GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer );
 100 static BOOL FONT_DeleteObject( HGDIOBJ handle );
 101
 102 static const struct gdi_obj_funcs font_funcs =
 103 {
 104     FONT_SelectObject,  /* pSelectObject */
 105     FONT_GetObjectA,    /* pGetObjectA */
 106     FONT_GetObjectW,    /* pGetObjectW */
 107     NULL,               /* pUnrealizeObject */
 108     FONT_DeleteObject   /* pDeleteObject */
 109 };
 110
 111 typedef struct
 112 {
 113     LOGFONTW    logfont;
 114 } FONTOBJ;
 115
 116 struct font_enum
 117 {
 118   LPLOGFONTW          lpLogFontParam;
 119   FONTENUMPROCW       lpEnumFunc;
 120   LPARAM              lpData;
 121   BOOL                unicode;
 122   HDC                 hdc;
 123   INT                 retval;
 124 };
 125
 126 /*
 127  *  For TranslateCharsetInfo
 128  */
 129 #define MAXTCIINDEX 32
 130 static const CHARSETINFO FONT_tci[MAXTCIINDEX] = {
 131   /* ANSI */
 132   { ANSI_CHARSET, 1252, {{0,0,0,0},{FS_LATIN1,0}} },
 133   { EASTEUROPE_CHARSET, 1250, {{0,0,0,0},{FS_LATIN2,0}} },
 134   { RUSSIAN_CHARSET, 1251, {{0,0,0,0},{FS_CYRILLIC,0}} },
 135   { GREEK_CHARSET, 1253, {{0,0,0,0},{FS_GREEK,0}} },
 136   { TURKISH_CHARSET, 1254, {{0,0,0,0},{FS_TURKISH,0}} },
 137   { HEBREW_CHARSET, 1255, {{0,0,0,0},{FS_HEBREW,0}} },
 138   { ARABIC_CHARSET, 1256, {{0,0,0,0},{FS_ARABIC,0}} },
 139   { BALTIC_CHARSET, 1257, {{0,0,0,0},{FS_BALTIC,0}} },
 140   { VIETNAMESE_CHARSET, 1258, {{0,0,0,0},{FS_VIETNAMESE,0}} },
 141   /* reserved by ANSI */
 142   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 143   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 144   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 145   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 146   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 147   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 148   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 149   /* ANSI and OEM */
 150   { THAI_CHARSET, 874, {{0,0,0,0},{FS_THAI,0}} },
 151   { SHIFTJIS_CHARSET, 932, {{0,0,0,0},{FS_JISJAPAN,0}} },
 152   { GB2312_CHARSET, 936, {{0,0,0,0},{FS_CHINESESIMP,0}} },
 153   { HANGEUL_CHARSET, 949, {{0,0,0,0},{FS_WANSUNG,0}} },
 154   { CHINESEBIG5_CHARSET, 950, {{0,0,0,0},{FS_CHINESETRAD,0}} },
 155   { JOHAB_CHARSET, 1361, {{0,0,0,0},{FS_JOHAB,0}} },
 156   /* reserved for alternate ANSI and OEM */
 157   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 158   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 159   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 160   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 161   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 162   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 163   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 164   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 165   /* reserved for system */
 166   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 167   { SYMBOL_CHARSET, CP_SYMBOL, {{0,0,0,0},{FS_SYMBOL,0}} }
 168 };
 169
 170 static void FONT_LogFontAToW( const LOGFONTA *fontA, LPLOGFONTW fontW )
 171 {
 172     memcpy(fontW, fontA, sizeof(LOGFONTA) - LF_FACESIZE);
 173     MultiByteToWideChar(CP_ACP, 0, fontA->lfFaceName, -1, fontW->lfFaceName,
 174                         LF_FACESIZE);
 175     fontW->lfFaceName[LF_FACESIZE-1] = 0;
 176 }
 177
 178 static void FONT_LogFontWToA( const LOGFONTW *fontW, LPLOGFONTA fontA )
 179 {
 180     memcpy(fontA, fontW, sizeof(LOGFONTA) - LF_FACESIZE);
 181     WideCharToMultiByte(CP_ACP, 0, fontW->lfFaceName, -1, fontA->lfFaceName,
 182                         LF_FACESIZE, NULL, NULL);
 183     fontA->lfFaceName[LF_FACESIZE-1] = 0;
 184 }
 185
 186 static void FONT_EnumLogFontExWToA( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEXA fontA )
 187 {
 188     FONT_LogFontWToA( &fontW->elfLogFont, &fontA->elfLogFont );
 189
 190     WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
 191                          (LPSTR) fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL );
 192     fontA->elfFullName[LF_FULLFACESIZE-1] = '\0';
 193     WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
 194                          (LPSTR) fontA->elfStyle, LF_FACESIZE, NULL, NULL );
 195     fontA->elfStyle[LF_FACESIZE-1] = '\0';
 196     WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
 197                          (LPSTR) fontA->elfScript, LF_FACESIZE, NULL, NULL );
 198     fontA->elfScript[LF_FACESIZE-1] = '\0';
 199 }
 200
 201 static void FONT_EnumLogFontExAToW( const ENUMLOGFONTEXA *fontA, LPENUMLOGFONTEXW fontW )
 202 {
 203     FONT_LogFontAToW( &fontA->elfLogFont, &fontW->elfLogFont );
 204
 205     MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfFullName, -1,
 206                          fontW->elfFullName, LF_FULLFACESIZE );
 207     fontW->elfFullName[LF_FULLFACESIZE-1] = '\0';
 208     MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfStyle, -1,
 209                          fontW->elfStyle, LF_FACESIZE );
 210     fontW->elfStyle[LF_FACESIZE-1] = '\0';
 211     MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfScript, -1,
 212                          fontW->elfScript, LF_FACESIZE );
 213     fontW->elfScript[LF_FACESIZE-1] = '\0';
 214 }
 215
 216 /***********************************************************************
 217  *              TEXTMETRIC conversion functions.
 218  */
 219 static void FONT_TextMetricWToA(const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA )
 220 {
 221     ptmA->tmHeight = ptmW->tmHeight;
 222     ptmA->tmAscent = ptmW->tmAscent;
 223     ptmA->tmDescent = ptmW->tmDescent;
 224     ptmA->tmInternalLeading = ptmW->tmInternalLeading;
 225     ptmA->tmExternalLeading = ptmW->tmExternalLeading;
 226     ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
 227     ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
 228     ptmA->tmWeight = ptmW->tmWeight;
 229     ptmA->tmOverhang = ptmW->tmOverhang;
 230     ptmA->tmDigitizedAspectX = ptmW->tmDigitizedAspectX;
 231     ptmA->tmDigitizedAspectY = ptmW->tmDigitizedAspectY;
 232     ptmA->tmFirstChar = min(ptmW->tmFirstChar, 255);
 233     if (ptmW->tmCharSet == SYMBOL_CHARSET)
 234     {
 235         ptmA->tmFirstChar = 0x1e;
 236         ptmA->tmLastChar = 0xff;  /* win9x behaviour - we need the OS2 table data to calculate correctly */
 237     }
 238     else if (ptmW->tmPitchAndFamily & TMPF_TRUETYPE)
 239     {
 240         ptmA->tmFirstChar = ptmW->tmDefaultChar - 1;
 241         ptmA->tmLastChar = min(ptmW->tmLastChar, 0xff);
 242     }
 243     else
 244     {
 245         ptmA->tmFirstChar = min(ptmW->tmFirstChar, 0xff);
 246         ptmA->tmLastChar  = min(ptmW->tmLastChar,  0xff);
 247     }
 248     ptmA->tmDefaultChar = ptmW->tmDefaultChar;
 249     ptmA->tmBreakChar = ptmW->tmBreakChar;
 250     ptmA->tmItalic = ptmW->tmItalic;
 251     ptmA->tmUnderlined = ptmW->tmUnderlined;
 252     ptmA->tmStruckOut = ptmW->tmStruckOut;
 253     ptmA->tmPitchAndFamily = ptmW->tmPitchAndFamily;
 254     ptmA->tmCharSet = ptmW->tmCharSet;
 255 }
 256
 257
 258 static void FONT_NewTextMetricExWToA(const NEWTEXTMETRICEXW *ptmW, NEWTEXTMETRICEXA *ptmA )
 259 {
 260     FONT_TextMetricWToA((const TEXTMETRICW *)ptmW, (LPTEXTMETRICA)ptmA);
 261     ptmA->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
 262     ptmA->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
 263     ptmA->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
 264     ptmA->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
 265     memcpy(&ptmA->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
 266 }
 267
 268 static DWORD get_font_ppem( HDC hdc )
 269 {
 270     TEXTMETRICW tm;
 271     DWORD ppem;
 272     DC *dc = get_dc_ptr( hdc );
 273
 274     if (!dc) return GDI_ERROR;
 275
 276     GetTextMetricsW( hdc, &tm );
 277     ppem = abs( INTERNAL_YWSTODS( dc, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading ) );
 278     release_dc_ptr( dc );
 279     return ppem;
 280 }
 281
 282 #define GASP_GRIDFIT 0x01
 283 #define GASP_DOGRAY  0x02
 284
 285 static BOOL get_gasp_flags( HDC hdc, WORD *flags )
 286 {
 287     DWORD size, gasp_tag = 0x70736167;
 288     WORD buf[16]; /* Enough for seven ranges before we need to alloc */
 289     WORD *alloced = NULL, *ptr = buf;
 290     WORD num_recs, version;
 291     DWORD ppem = get_font_ppem( hdc );
 292     BOOL ret = FALSE;
 293
 294     *flags = 0;
 295     if (ppem == GDI_ERROR) return FALSE;
 296
 297     size = GetFontData( hdc, gasp_tag,  0, NULL, 0 );
 298     if (size == GDI_ERROR) return FALSE;
 299     if (size < 4 * sizeof(WORD)) return FALSE;
 300     if (size > sizeof(buf))
 301     {
 302         ptr = alloced = HeapAlloc( GetProcessHeap(), 0, size );
 303         if (!ptr) return FALSE;
 304     }
 305
 306     GetFontData( hdc, gasp_tag, 0, ptr, size );
 307
 308     version  = get_be_word( *ptr++ );
 309     num_recs = get_be_word( *ptr++ );
 310
 311     if (version > 1 || size < (num_recs * 2 + 2) * sizeof(WORD))
 312     {
 313         FIXME( "Unsupported gasp table: ver %d size %d recs %d\n", version, size, num_recs );
 314         goto done;
 315     }
 316
 317     while (num_recs--)
 318     {
 319         *flags = get_be_word( *(ptr + 1) );
 320         if (ppem <= get_be_word( *ptr )) break;
 321         ptr += 2;
 322     }
 323     TRACE( "got flags %04x for ppem %d\n", *flags, ppem );
 324     ret = TRUE;
 325
 326 done:
 327     HeapFree( GetProcessHeap(), 0, alloced );
 328     return ret;
 329 }
 330
 331 UINT get_font_aa_flags( HDC hdc )
 332 {
 333     LOGFONTW lf;
 334     WORD gasp_flags;
 335
 336     if (GetObjectType( hdc ) == OBJ_MEMDC)
 337     {
 338         BITMAP bm;
 339         GetObjectW( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bm), &bm );
 340         if (bm.bmBitsPixel <= 8) return GGO_BITMAP;
 341     }
 342     else if (GetDeviceCaps( hdc, BITSPIXEL ) <= 8) return GGO_BITMAP;
 343
 344     GetObjectW( GetCurrentObject( hdc, OBJ_FONT ), sizeof(lf), &lf );
 345     if (lf.lfQuality == NONANTIALIASED_QUALITY) return GGO_BITMAP;
 346
 347     if (get_gasp_flags( hdc, &gasp_flags ) && !(gasp_flags & GASP_DOGRAY))
 348         return GGO_BITMAP;
 349
 350     /* FIXME, check user prefs */
 351     return GGO_GRAY4_BITMAP;
 352 }
 353
 354 /***********************************************************************
 355  *           GdiGetCodePage   (GDI32.@)
 356  */
 357 DWORD WINAPI GdiGetCodePage( HDC hdc )
 358 {
 359     UINT cp = CP_ACP;
 360     DC *dc = get_dc_ptr( hdc );
 361
 362     if (dc)
 363     {
 364         cp = dc->font_code_page;
 365         release_dc_ptr( dc );
 366     }
 367     return cp;
 368 }
 369
 370 /***********************************************************************
 371  *           FONT_mbtowc
 372  *
 373  * Returns a Unicode translation of str using the charset of the
 374  * currently selected font in hdc.  If count is -1 then str is assumed
 375  * to be '\0' terminated, otherwise it contains the number of bytes to
 376  * convert.  If plenW is non-NULL, on return it will point to the
 377  * number of WCHARs that have been written.  If pCP is non-NULL, on
 378  * return it will point to the codepage used in the conversion.  The
 379  * caller should free the returned LPWSTR from the process heap
 380  * itself.
 381  */
 382 static LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
 383 {
 384     UINT cp;
 385     INT lenW;
 386     LPWSTR strW;
 387
 388     cp = GdiGetCodePage( hdc );
 389
 390     if(count == -1) count = strlen(str);
 391     lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
 392     strW = HeapAlloc(GetProcessHeap(), 0, lenW*sizeof(WCHAR));
 393     MultiByteToWideChar(cp, 0, str, count, strW, lenW);
 394     TRACE("mapped %s -> %s\n", debugstr_an(str, count), debugstr_wn(strW, lenW));
 395     if(plenW) *plenW = lenW;
 396     if(pCP) *pCP = cp;
 397     return strW;
 398 }
 399
 400 /***********************************************************************
 401  *           CreateFontIndirectExA   (GDI32.@)
 402  */
 403 HFONT WINAPI CreateFontIndirectExA( const ENUMLOGFONTEXDVA *penumexA )
 404 {
 405     ENUMLOGFONTEXDVW enumexW;
 406
 407     if (!penumexA) return 0;
 408
 409     FONT_EnumLogFontExAToW( &penumexA->elfEnumLogfontEx, &enumexW.elfEnumLogfontEx );
 410     enumexW.elfDesignVector = penumexA->elfDesignVector;
 411     return CreateFontIndirectExW( &enumexW );
 412 }
 413
 414 /***********************************************************************
 415  *           CreateFontIndirectExW   (GDI32.@)
 416  */
 417 HFONT WINAPI CreateFontIndirectExW( const ENUMLOGFONTEXDVW *penumex )
 418 {
 419     HFONT hFont;
 420     FONTOBJ *fontPtr;
 421     const LOGFONTW *plf;
 422
 423     if (!penumex) return 0;
 424
 425     if (penumex->elfEnumLogfontEx.elfFullName[0] ||
 426         penumex->elfEnumLogfontEx.elfStyle[0] ||
 427         penumex->elfEnumLogfontEx.elfScript[0])
 428     {
 429         FIXME("some fields ignored. fullname=%s, style=%s, script=%s\n",
 430             debugstr_w(penumex->elfEnumLogfontEx.elfFullName),
 431             debugstr_w(penumex->elfEnumLogfontEx.elfStyle),
 432             debugstr_w(penumex->elfEnumLogfontEx.elfScript));
 433     }
 434
 435     plf = &penumex->elfEnumLogfontEx.elfLogFont;
 436     if (!(fontPtr = HeapAlloc( GetProcessHeap(), 0, sizeof(*fontPtr) ))) return 0;
 437
 438     fontPtr->logfont = *plf;
 439
 440     if (plf->lfEscapement != plf->lfOrientation)
 441     {
 442         /* this should really depend on whether GM_ADVANCED is set */
 443         fontPtr->logfont.lfOrientation = fontPtr->logfont.lfEscapement;
 444         WARN("orientation angle %f set to "
 445              "escapement angle %f for new font %p\n",
 446              plf->lfOrientation/10., plf->lfEscapement/10., fontPtr);
 447     }
 448
 449     if (!(hFont = alloc_gdi_handle( fontPtr, OBJ_FONT, &font_funcs )))
 450     {
 451         HeapFree( GetProcessHeap(), 0, fontPtr );
 452         return 0;
 453     }
 454
 455     TRACE("(%d %d %d %d %x %d %x %d %d) %s %s %s %s => %p\n",
 456           plf->lfHeight, plf->lfWidth,
 457           plf->lfEscapement, plf->lfOrientation,
 458           plf->lfPitchAndFamily,
 459           plf->lfOutPrecision, plf->lfClipPrecision,
 460           plf->lfQuality, plf->lfCharSet,
 461           debugstr_w(plf->lfFaceName),
 462           plf->lfWeight > 400 ? "Bold" : "",
 463           plf->lfItalic ? "Italic" : "",
 464           plf->lfUnderline ? "Underline" : "", hFont);
 465
 466     return hFont;
 467 }
 468
 469 /***********************************************************************
 470  *           CreateFontIndirectA   (GDI32.@)
 471  */
 472 HFONT WINAPI CreateFontIndirectA( const LOGFONTA *plfA )
 473 {
 474     LOGFONTW lfW;
 475
 476     if (!plfA) return 0;
 477
 478     FONT_LogFontAToW( plfA, &lfW );
 479     return CreateFontIndirectW( &lfW );
 480 }
 481
 482 /***********************************************************************
 483  *           CreateFontIndirectW   (GDI32.@)
 484  */
 485 HFONT WINAPI CreateFontIndirectW( const LOGFONTW *plf )
 486 {
 487     ENUMLOGFONTEXDVW exdv;
 488
 489     if (!plf) return 0;
 490
 491     exdv.elfEnumLogfontEx.elfLogFont = *plf;
 492     exdv.elfEnumLogfontEx.elfFullName[0] = 0;
 493     exdv.elfEnumLogfontEx.elfStyle[0] = 0;
 494     exdv.elfEnumLogfontEx.elfScript[0] = 0;
 495     return CreateFontIndirectExW( &exdv );
 496 }
 497
 498 /*************************************************************************
 499  *           CreateFontA    (GDI32.@)
 500  */
 501 HFONT WINAPI CreateFontA( INT height, INT width, INT esc,
 502                               INT orient, INT weight, DWORD italic,
 503                               DWORD underline, DWORD strikeout, DWORD charset,
 504                               DWORD outpres, DWORD clippres, DWORD quality,
 505                               DWORD pitch, LPCSTR name )
 506 {
 507     LOGFONTA logfont;
 508
 509     logfont.lfHeight = height;
 510     logfont.lfWidth = width;
 511     logfont.lfEscapement = esc;
 512     logfont.lfOrientation = orient;
 513     logfont.lfWeight = weight;
 514     logfont.lfItalic = italic;
 515     logfont.lfUnderline = underline;
 516     logfont.lfStrikeOut = strikeout;
 517     logfont.lfCharSet = charset;
 518     logfont.lfOutPrecision = outpres;
 519     logfont.lfClipPrecision = clippres;
 520     logfont.lfQuality = quality;
 521     logfont.lfPitchAndFamily = pitch;
 522
 523     if (name)
 524         lstrcpynA(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
 525     else
 526         logfont.lfFaceName[0] = '\0';
 527
 528     return CreateFontIndirectA( &logfont );
 529 }
 530
 531 /*************************************************************************
 532  *           CreateFontW    (GDI32.@)
 533  */
 534 HFONT WINAPI CreateFontW( INT height, INT width, INT esc,
 535                               INT orient, INT weight, DWORD italic,
 536                               DWORD underline, DWORD strikeout, DWORD charset,
 537                               DWORD outpres, DWORD clippres, DWORD quality,
 538                               DWORD pitch, LPCWSTR name )
 539 {
 540     LOGFONTW logfont;
 541
 542     logfont.lfHeight = height;
 543     logfont.lfWidth = width;
 544     logfont.lfEscapement = esc;
 545     logfont.lfOrientation = orient;
 546     logfont.lfWeight = weight;
 547     logfont.lfItalic = italic;
 548     logfont.lfUnderline = underline;
 549     logfont.lfStrikeOut = strikeout;
 550     logfont.lfCharSet = charset;
 551     logfont.lfOutPrecision = outpres;
 552     logfont.lfClipPrecision = clippres;
 553     logfont.lfQuality = quality;
 554     logfont.lfPitchAndFamily = pitch;
 555
 556     if (name)
 557         lstrcpynW(logfont.lfFaceName, name,
 558                   sizeof(logfont.lfFaceName) / sizeof(WCHAR));
 559     else
 560         logfont.lfFaceName[0] = '\0';
 561
 562     return CreateFontIndirectW( &logfont );
 563 }
 564
 565 static void update_font_code_page( DC *dc )
 566 {
 567     CHARSETINFO csi;
 568     int charset = GetTextCharsetInfo( dc->hSelf, NULL, 0 );
 569
 570     /* Hmm, nicely designed api this one! */
 571     if (TranslateCharsetInfo( ULongToPtr(charset), &csi, TCI_SRCCHARSET) )
 572         dc->font_code_page = csi.ciACP;
 573     else {
 574         switch(charset) {
 575         case OEM_CHARSET:
 576             dc->font_code_page = GetOEMCP();
 577             break;
 578         case DEFAULT_CHARSET:
 579             dc->font_code_page = GetACP();
 580             break;
 581
 582         case VISCII_CHARSET:
 583         case TCVN_CHARSET:
 584         case KOI8_CHARSET:
 585         case ISO3_CHARSET:
 586         case ISO4_CHARSET:
 587         case ISO10_CHARSET:
 588         case CELTIC_CHARSET:
 589             /* FIXME: These have no place here, but because x11drv
 590                enumerates fonts with these (made up) charsets some apps
 591                might use them and then the FIXME below would become
 592                annoying.  Now we could pick the intended codepage for
 593                each of these, but since it's broken anyway we'll just
 594                use CP_ACP and hope it'll go away...
 595             */
 596             dc->font_code_page = CP_ACP;
 597             break;
 598
 599         default:
 600             FIXME("Can't find codepage for charset %d\n", charset);
 601             dc->font_code_page = CP_ACP;
 602             break;
 603         }
 604     }
 605
 606     TRACE("charset %d => cp %d\n", charset, dc->font_code_page);
 607 }
 608
 609 /***********************************************************************
 610  *           FONT_SelectObject
 611  */
 612 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, HDC hdc )
 613 {
 614     HGDIOBJ ret = 0;
 615     DC *dc = get_dc_ptr( hdc );
 616     PHYSDEV physdev;
 617
 618     if (!dc) return 0;
 619
 620     if (!GDI_inc_ref_count( handle ))
 621     {
 622         release_dc_ptr( dc );
 623         return 0;
 624     }
 625
 626     physdev = GET_DC_PHYSDEV( dc, pSelectFont );
 627     if (physdev->funcs->pSelectFont( physdev, handle ))
 628     {
 629         ret = dc->hFont;
 630         dc->hFont = handle;
 631         update_font_code_page( dc );
 632         GDI_dec_ref_count( ret );
 633     }
 634     else GDI_dec_ref_count( handle );
 635
 636     release_dc_ptr( dc );
 637     return ret;
 638 }
 639
 640
 641 /***********************************************************************
 642  *           FONT_GetObjectA
 643  */
 644 static INT FONT_GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer )
 645 {
 646     FONTOBJ *font = GDI_GetObjPtr( handle, OBJ_FONT );
 647     LOGFONTA lfA;
 648
 649     if (!font) return 0;
 650     if (buffer)
 651     {
 652         FONT_LogFontWToA( &font->logfont, &lfA );
 653         if (count > sizeof(lfA)) count = sizeof(lfA);
 654         memcpy( buffer, &lfA, count );
 655     }
 656     else count = sizeof(lfA);
 657     GDI_ReleaseObj( handle );
 658     return count;
 659 }
 660
 661 /***********************************************************************
 662  *           FONT_GetObjectW
 663  */
 664 static INT FONT_GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer )
 665 {
 666     FONTOBJ *font = GDI_GetObjPtr( handle, OBJ_FONT );
 667
 668     if (!font) return 0;
 669     if (buffer)
 670     {
 671         if (count > sizeof(LOGFONTW)) count = sizeof(LOGFONTW);
 672         memcpy( buffer, &font->logfont, count );
 673     }
 674     else count = sizeof(LOGFONTW);
 675     GDI_ReleaseObj( handle );
 676     return count;
 677 }
 678
 679
 680 /***********************************************************************
 681  *           FONT_DeleteObject
 682  */
 683 static BOOL FONT_DeleteObject( HGDIOBJ handle )
 684 {
 685     FONTOBJ *obj;
 686
 687     WineEngDestroyFontInstance( handle );
 688
 689     if (!(obj = free_gdi_handle( handle ))) return FALSE;
 690     return HeapFree( GetProcessHeap(), 0, obj );
 691 }
 692
 693
 694 /***********************************************************************
 695  *              FONT_EnumInstance
 696  *
 697  * Note: plf is really an ENUMLOGFONTEXW, and ptm is a NEWTEXTMETRICEXW.
 698  *       We have to use other types because of the FONTENUMPROCW definition.
 699  */
 700 static INT CALLBACK FONT_EnumInstance( const LOGFONTW *plf, const TEXTMETRICW *ptm,
 701                                        DWORD fType, LPARAM lp )
 702 {
 703     struct font_enum *pfe = (struct font_enum *)lp;
 704     INT ret = 1;
 705
 706     /* lfCharSet is at the same offset in both LOGFONTA and LOGFONTW */
 707     if ((!pfe->lpLogFontParam ||
 708         pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
 709         pfe->lpLogFontParam->lfCharSet == plf->lfCharSet) &&
 710        (!(fType & RASTER_FONTTYPE) || GetDeviceCaps(pfe->hdc, TEXTCAPS) & TC_RA_ABLE) )
 711     {
 712         /* convert font metrics */
 713         ENUMLOGFONTEXA logfont;
 714         NEWTEXTMETRICEXA tmA;
 715
 716         if (!pfe->unicode)
 717         {
 718             FONT_EnumLogFontExWToA( (const ENUMLOGFONTEXW *)plf, &logfont);
 719             FONT_NewTextMetricExWToA( (const NEWTEXTMETRICEXW *)ptm, &tmA );
 720             plf = (LOGFONTW *)&logfont.elfLogFont;
 721             ptm = (TEXTMETRICW *)&tmA;
 722         }
 723         ret = pfe->lpEnumFunc( plf, ptm, fType, pfe->lpData );
 724         pfe->retval = ret;
 725     }
 726     return ret;
 727 }
 728
 729 /***********************************************************************
 730  *              FONT_EnumFontFamiliesEx
 731  */
 732 static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf, FONTENUMPROCW efproc,
 733                                     LPARAM lParam, BOOL unicode )
 734 {
 735     INT ret = 0;
 736     DC *dc = get_dc_ptr( hDC );
 737     struct font_enum fe;
 738
 739     if (dc)
 740     {
 741         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pEnumFonts );
 742
 743         if (plf) TRACE("lfFaceName = %s lfCharset = %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
 744         fe.lpLogFontParam = plf;
 745         fe.lpEnumFunc = efproc;
 746         fe.lpData = lParam;
 747         fe.unicode = unicode;
 748         fe.hdc = hDC;
 749         fe.retval = 1;
 750         ret = physdev->funcs->pEnumFonts( physdev, plf, FONT_EnumInstance, (LPARAM)&fe );
 751         release_dc_ptr( dc );
 752     }
 753     return ret ? fe.retval : 0;
 754 }
 755
 756 /***********************************************************************
 757  *              EnumFontFamiliesExW     (GDI32.@)
 758  */
 759 INT WINAPI EnumFontFamiliesExW( HDC hDC, LPLOGFONTW plf,
 760                                     FONTENUMPROCW efproc,
 761                                     LPARAM lParam, DWORD dwFlags )
 762 {
 763     return FONT_EnumFontFamiliesEx( hDC, plf, efproc, lParam, TRUE );
 764 }
 765
 766 /***********************************************************************
 767  *              EnumFontFamiliesExA     (GDI32.@)
 768  */
 769 INT WINAPI EnumFontFamiliesExA( HDC hDC, LPLOGFONTA plf,
 770                                     FONTENUMPROCA efproc,
 771                                     LPARAM lParam, DWORD dwFlags)
 772 {
 773     LOGFONTW lfW, *plfW;
 774
 775     if (plf)
 776     {
 777         FONT_LogFontAToW( plf, &lfW );
 778         plfW = &lfW;
 779     }
 780     else plfW = NULL;
 781
 782     return FONT_EnumFontFamiliesEx( hDC, plfW, (FONTENUMPROCW)efproc, lParam, FALSE );
 783 }
 784
 785 /***********************************************************************
 786  *              EnumFontFamiliesA       (GDI32.@)
 787  */
 788 INT WINAPI EnumFontFamiliesA( HDC hDC, LPCSTR lpFamily,
 789                                   FONTENUMPROCA efproc, LPARAM lpData )
 790 {
 791     LOGFONTA lf, *plf;
 792
 793     if (lpFamily)
 794     {
 795         if (!*lpFamily) return 1;
 796         lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
 797         lf.lfCharSet = DEFAULT_CHARSET;
 798         lf.lfPitchAndFamily = 0;
 799         plf = &lf;
 800     }
 801     else plf = NULL;
 802
 803     return EnumFontFamiliesExA( hDC, plf, efproc, lpData, 0 );
 804 }
 805
 806 /***********************************************************************
 807  *              EnumFontFamiliesW       (GDI32.@)
 808  */
 809 INT WINAPI EnumFontFamiliesW( HDC hDC, LPCWSTR lpFamily,
 810                                   FONTENUMPROCW efproc, LPARAM lpData )
 811 {
 812     LOGFONTW lf, *plf;
 813
 814     if (lpFamily)
 815     {
 816         if (!*lpFamily) return 1;
 817         lstrcpynW( lf.lfFaceName, lpFamily, LF_FACESIZE );
 818         lf.lfCharSet = DEFAULT_CHARSET;
 819         lf.lfPitchAndFamily = 0;
 820         plf = &lf;
 821     }
 822     else plf = NULL;
 823
 824     return EnumFontFamiliesExW( hDC, plf, efproc, lpData, 0 );
 825 }
 826
 827 /***********************************************************************
 828  *              EnumFontsA              (GDI32.@)
 829  */
 830 INT WINAPI EnumFontsA( HDC hDC, LPCSTR lpName, FONTENUMPROCA efproc,
 831                            LPARAM lpData )
 832 {
 833     return EnumFontFamiliesA( hDC, lpName, efproc, lpData );
 834 }
 835
 836 /***********************************************************************
 837  *              EnumFontsW              (GDI32.@)
 838  */
 839 INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
 840                            LPARAM lpData )
 841 {
 842     return EnumFontFamiliesW( hDC, lpName, efproc, lpData );
 843 }
 844
 845
 846 /***********************************************************************
 847  *           GetTextCharacterExtra    (GDI32.@)
 848  */
 849 INT WINAPI GetTextCharacterExtra( HDC hdc )
 850 {
 851     INT ret;
 852     DC *dc = get_dc_ptr( hdc );
 853     if (!dc) return 0x80000000;
 854     ret = dc->charExtra;
 855     release_dc_ptr( dc );
 856     return ret;
 857 }
 858
 859
 860 /***********************************************************************
 861  *           SetTextCharacterExtra    (GDI32.@)
 862  */
 863 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
 864 {
 865     INT ret = 0x80000000;
 866     DC * dc = get_dc_ptr( hdc );
 867
 868     if (dc)
 869     {
 870         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextCharacterExtra );
 871         extra = physdev->funcs->pSetTextCharacterExtra( physdev, extra );
 872         if (extra != 0x80000000)
 873         {
 874             ret = dc->charExtra;
 875             dc->charExtra = extra;
 876         }
 877         release_dc_ptr( dc );
 878     }
 879     return ret;
 880 }
 881
 882
 883 /***********************************************************************
 884  *           SetTextJustification    (GDI32.@)
 885  */
 886 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
 887 {
 888     BOOL ret;
 889     PHYSDEV physdev;
 890     DC * dc = get_dc_ptr( hdc );
 891
 892     if (!dc) return FALSE;
 893
 894     physdev = GET_DC_PHYSDEV( dc, pSetTextJustification );
 895     ret = physdev->funcs->pSetTextJustification( physdev, extra, breaks );
 896     if (ret)
 897     {
 898         extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
 899         if (!extra) breaks = 0;
 900         if (breaks)
 901         {
 902             dc->breakExtra = extra / breaks;
 903             dc->breakRem   = extra - (breaks * dc->breakExtra);
 904         }
 905         else
 906         {
 907             dc->breakExtra = 0;
 908             dc->breakRem   = 0;
 909         }
 910     }
 911     release_dc_ptr( dc );
 912     return ret;
 913 }
 914
 915
 916 /***********************************************************************
 917  *           GetTextFaceA    (GDI32.@)
 918  */
 919 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
 920 {
 921     INT res = GetTextFaceW(hdc, 0, NULL);
 922     LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, res * 2 );
 923     GetTextFaceW( hdc, res, nameW );
 924
 925     if (name)
 926     {
 927         if (count)
 928         {
 929             res = WideCharToMultiByte(CP_ACP, 0, nameW, -1, name, count, NULL, NULL);
 930             if (res == 0)
 931                 res = count;
 932             name[count-1] = 0;
 933             /* GetTextFaceA does NOT include the nul byte in the return count.  */
 934             res--;
 935         }
 936         else
 937             res = 0;
 938     }
 939     else
 940         res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL);
 941     HeapFree( GetProcessHeap(), 0, nameW );
 942     return res;
 943 }
 944
 945 /***********************************************************************
 946  *           GetTextFaceW    (GDI32.@)
 947  */
 948 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
 949 {
 950     PHYSDEV dev;
 951     INT ret;
 952
 953     DC * dc = get_dc_ptr( hdc );
 954     if (!dc) return 0;
 955
 956     dev = GET_DC_PHYSDEV( dc, pGetTextFace );
 957     ret = dev->funcs->pGetTextFace( dev, count, name );
 958     release_dc_ptr( dc );
 959     return ret;
 960 }
 961
 962
 963 /***********************************************************************
 964  *           GetTextExtentPoint32A    (GDI32.@)
 965  *
 966  * See GetTextExtentPoint32W.
 967  */
 968 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
 969                                      LPSIZE size )
 970 {
 971     BOOL ret = FALSE;
 972     INT wlen;
 973     LPWSTR p;
 974
 975     if (count < 0) return FALSE;
 976
 977     p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
 978
 979     if (p)
 980     {
 981         ret = GetTextExtentPoint32W( hdc, p, wlen, size );
 982         HeapFree( GetProcessHeap(), 0, p );
 983     }
 984
 985     TRACE("(%p %s %d %p): returning %d x %d\n",
 986           hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
 987     return ret;
 988 }
 989
 990
 991 /***********************************************************************
 992  * GetTextExtentPoint32W [GDI32.@]
 993  *
 994  * Computes width/height for a string.
 995  *
 996  * Computes width and height of the specified string.
 997  *
 998  * RETURNS
 999  *    Success: TRUE
1000  *    Failure: FALSE
1001  */
1002 BOOL WINAPI GetTextExtentPoint32W(
1003     HDC hdc,     /* [in]  Handle of device context */
1004     LPCWSTR str,   /* [in]  Address of text string */
1005     INT count,   /* [in]  Number of characters in string */
1006     LPSIZE size) /* [out] Address of structure for string size */
1007 {
1008     return GetTextExtentExPointW(hdc, str, count, 0, NULL, NULL, size);
1009 }
1010
1011 /***********************************************************************
1012  * GetTextExtentExPointI [GDI32.@]
1013  *
1014  * Computes width and height of the array of glyph indices.
1015  *
1016  * PARAMS
1017  *    hdc     [I] Handle of device context.
1018  *    indices [I] Glyph index array.
1019  *    count   [I] Number of glyphs in array.
1020  *    max_ext [I] Maximum width in glyphs.
1021  *    nfit    [O] Maximum number of characters.
1022  *    dxs     [O] Partial string widths.
1023  *    size    [O] Returned string size.
1024  *
1025  * RETURNS
1026  *    Success: TRUE
1027  *    Failure: FALSE
1028  */
1029 BOOL WINAPI GetTextExtentExPointI( HDC hdc, const WORD *indices, INT count, INT max_ext,
1030                                    LPINT nfit, LPINT dxs, LPSIZE size )
1031 {
1032     PHYSDEV dev;
1033     BOOL ret;
1034     DC *dc;
1035
1036     if (count < 0) return FALSE;
1037
1038     dc = get_dc_ptr( hdc );
1039     if (!dc) return FALSE;
1040
1041     dev = GET_DC_PHYSDEV( dc, pGetTextExtentExPointI );
1042     ret = dev->funcs->pGetTextExtentExPointI( dev, indices, count, max_ext, nfit, dxs, size );
1043     size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1044     size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1045     size->cx += count * dc->charExtra;
1046     release_dc_ptr( dc );
1047
1048     TRACE("(%p %p %d %p): returning %d x %d\n",
1049           hdc, indices, count, size, size->cx, size->cy );
1050     return ret;
1051 }
1052
1053 /***********************************************************************
1054  * GetTextExtentPointI [GDI32.@]
1055  *
1056  * Computes width and height of the array of glyph indices.
1057  *
1058  * PARAMS
1059  *    hdc     [I] Handle of device context.
1060  *    indices [I] Glyph index array.
1061  *    count   [I] Number of glyphs in array.
1062  *    size    [O] Returned string size.
1063  *
1064  * RETURNS
1065  *    Success: TRUE
1066  *    Failure: FALSE
1067  */
1068 BOOL WINAPI GetTextExtentPointI( HDC hdc, const WORD *indices, INT count, LPSIZE size )
1069 {
1070     return GetTextExtentExPointI( hdc, indices, count, 0, NULL, NULL, size );
1071 }
1072
1073
1074 /***********************************************************************
1075  *           GetTextExtentPointA    (GDI32.@)
1076  */
1077 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
1078                                           LPSIZE size )
1079 {
1080     TRACE("not bug compatible.\n");
1081     return GetTextExtentPoint32A( hdc, str, count, size );
1082 }
1083
1084 /***********************************************************************
1085  *           GetTextExtentPointW   (GDI32.@)
1086  */
1087 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
1088                                           LPSIZE size )
1089 {
1090     TRACE("not bug compatible.\n");
1091     return GetTextExtentPoint32W( hdc, str, count, size );
1092 }
1093
1094
1095 /***********************************************************************
1096  *           GetTextExtentExPointA    (GDI32.@)
1097  */
1098 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
1099                                    INT maxExt, LPINT lpnFit,
1100                                    LPINT alpDx, LPSIZE size )
1101 {
1102     BOOL ret;
1103     INT wlen;
1104     INT *walpDx = NULL;
1105     LPWSTR p = NULL;
1106
1107     if (count < 0) return FALSE;
1108
1109     if (alpDx)
1110     {
1111         walpDx = HeapAlloc( GetProcessHeap(), 0, count * sizeof(INT) );
1112         if (!walpDx) return FALSE;
1113     }
1114
1115     p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1116     ret = GetTextExtentExPointW( hdc, p, wlen, maxExt, lpnFit, walpDx, size);
1117     if (walpDx)
1118     {
1119         INT n = lpnFit ? *lpnFit : wlen;
1120         INT i, j;
1121         for(i = 0, j = 0; i < n; i++, j++)
1122         {
1123             alpDx[j] = walpDx[i];
1124             if (IsDBCSLeadByte(str[j])) alpDx[++j] = walpDx[i];
1125         }
1126     }
1127     if (lpnFit) *lpnFit = WideCharToMultiByte(CP_ACP,0,p,*lpnFit,NULL,0,NULL,NULL);
1128     HeapFree( GetProcessHeap(), 0, p );
1129     HeapFree( GetProcessHeap(), 0, walpDx );
1130     return ret;
1131 }
1132
1133
1134 /***********************************************************************
1135  *           GetTextExtentExPointW    (GDI32.@)
1136  *
1137  * Return the size of the string as it would be if it was output properly by
1138  * e.g. TextOut.
1139  *
1140  * This should include
1141  * - Intercharacter spacing
1142  * - justification spacing (not yet done)
1143  * - kerning? see below
1144  *
1145  * Kerning.  Since kerning would be carried out by the rendering code it should
1146  * be done by the driver.  However they don't support it yet.  Also I am not
1147  * yet persuaded that (certainly under Win95) any kerning is actually done.
1148  *
1149  * str: According to MSDN this should be null-terminated.  That is not true; a
1150  *      null will not terminate it early.
1151  * size: Certainly under Win95 this appears buggy or weird if *lpnFit is less
1152  *       than count.  I have seen it be either the size of the full string or
1153  *       1 less than the size of the full string.  I have not seen it bear any
1154  *       resemblance to the portion that would fit.
1155  * lpnFit: What exactly is fitting?  Stupidly, in my opinion, it includes the
1156  *         trailing intercharacter spacing and any trailing justification.
1157  *
1158  * FIXME
1159  * Currently we do this by measuring each character etc.  We should do it by
1160  * passing the request to the driver, perhaps by extending the
1161  * pGetTextExtentPoint function to take the alpDx argument.  That would avoid
1162  * thinking about kerning issues and rounding issues in the justification.
1163  */
1164
1165 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
1166                                    INT maxExt, LPINT lpnFit,
1167                                    LPINT alpDx, LPSIZE size )
1168 {
1169     INT nFit = 0;
1170     LPINT dxs = NULL;
1171     DC *dc;
1172     BOOL ret = FALSE;
1173     TEXTMETRICW tm;
1174     PHYSDEV dev;
1175
1176     TRACE("(%p, %s, %d)\n",hdc,debugstr_wn(str,count),maxExt);
1177
1178     if (count < 0) return FALSE;
1179
1180     dc = get_dc_ptr(hdc);
1181     if (!dc) return FALSE;
1182
1183     GetTextMetricsW(hdc, &tm);
1184
1185     /* If we need to calculate nFit, then we need the partial extents even if
1186        the user hasn't provided us with an array.  */
1187     if (lpnFit)
1188     {
1189         dxs = alpDx ? alpDx : HeapAlloc(GetProcessHeap(), 0, count * sizeof alpDx[0]);
1190         if (! dxs)
1191         {
1192             release_dc_ptr(dc);
1193             SetLastError(ERROR_OUTOFMEMORY);
1194             return FALSE;
1195         }
1196     }
1197     else
1198         dxs = alpDx;
1199
1200     dev = GET_DC_PHYSDEV( dc, pGetTextExtentExPoint );
1201     ret = dev->funcs->pGetTextExtentExPoint(dev, str, count, 0, NULL, dxs, size);
1202
1203     /* Perform device size to world size transformations.  */
1204     if (ret)
1205     {
1206         INT extra      = dc->charExtra,
1207         breakExtra = dc->breakExtra,
1208         breakRem   = dc->breakRem,
1209         i;
1210
1211         if (dxs)
1212         {
1213             for (i = 0; i < count; ++i)
1214             {
1215                 dxs[i] = abs(INTERNAL_XDSTOWS(dc, dxs[i]));
1216                 dxs[i] += (i+1) * extra;
1217                 if (count > 1 && (breakExtra || breakRem) && str[i] == tm.tmBreakChar)
1218                 {
1219                     dxs[i] += breakExtra;
1220                     if (breakRem > 0)
1221                     {
1222                         breakRem--;
1223                         dxs[i]++;
1224                     }
1225                 }
1226                 if (dxs[i] <= maxExt)
1227                     ++nFit;
1228             }
1229             breakRem = dc->breakRem;
1230         }
1231         size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1232         size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1233
1234         if (!dxs && count > 1 && (breakExtra || breakRem))
1235         {
1236             for (i = 0; i < count; i++)
1237             {
1238                 if (str[i] == tm.tmBreakChar)
1239                 {
1240                     size->cx += breakExtra;
1241                     if (breakRem > 0)
1242                     {
1243                         breakRem--;
1244                         (size->cx)++;
1245                     }
1246                 }
1247             }
1248         }
1249     }
1250
1251     if (lpnFit)
1252         *lpnFit = nFit;
1253
1254     if (! alpDx)
1255         HeapFree(GetProcessHeap(), 0, dxs);
1256
1257     release_dc_ptr( dc );
1258
1259     TRACE("returning %d %d x %d\n",nFit,size->cx,size->cy);
1260     return ret;
1261 }
1262
1263 /***********************************************************************
1264  *           GetTextMetricsA    (GDI32.@)
1265  */
1266 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
1267 {
1268     TEXTMETRICW tm32;
1269
1270     if (!GetTextMetricsW( hdc, &tm32 )) return FALSE;
1271     FONT_TextMetricWToA( &tm32, metrics );
1272     return TRUE;
1273 }
1274
1275 /***********************************************************************
1276  *           GetTextMetricsW    (GDI32.@)
1277  */
1278 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1279 {
1280     PHYSDEV physdev;
1281     BOOL ret = FALSE;
1282     DC * dc = get_dc_ptr( hdc );
1283     if (!dc) return FALSE;
1284
1285     physdev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
1286     ret = physdev->funcs->pGetTextMetrics( physdev, metrics );
1287
1288     if (ret)
1289     {
1290     /* device layer returns values in device units
1291      * therefore we have to convert them to logical */
1292
1293         metrics->tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
1294         metrics->tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
1295
1296 #define WDPTOLP(x) ((x<0)?                                      \
1297                 (-abs(INTERNAL_XDSTOWS(dc, (x)))):              \
1298                 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1299 #define HDPTOLP(y) ((y<0)?                                      \
1300                 (-abs(INTERNAL_YDSTOWS(dc, (y)))):              \
1301                 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1302
1303         metrics->tmHeight           = HDPTOLP(metrics->tmHeight);
1304         metrics->tmAscent           = HDPTOLP(metrics->tmAscent);
1305         metrics->tmDescent          = HDPTOLP(metrics->tmDescent);
1306         metrics->tmInternalLeading  = HDPTOLP(metrics->tmInternalLeading);
1307         metrics->tmExternalLeading  = HDPTOLP(metrics->tmExternalLeading);
1308         metrics->tmAveCharWidth     = WDPTOLP(metrics->tmAveCharWidth);
1309         metrics->tmMaxCharWidth     = WDPTOLP(metrics->tmMaxCharWidth);
1310         metrics->tmOverhang         = WDPTOLP(metrics->tmOverhang);
1311         ret = TRUE;
1312 #undef WDPTOLP
1313 #undef HDPTOLP
1314     TRACE("text metrics:\n"
1315           "    Weight = %03i\t FirstChar = %i\t AveCharWidth = %i\n"
1316           "    Italic = % 3i\t LastChar = %i\t\t MaxCharWidth = %i\n"
1317           "    UnderLined = %01i\t DefaultChar = %i\t Overhang = %i\n"
1318           "    StruckOut = %01i\t BreakChar = %i\t CharSet = %i\n"
1319           "    PitchAndFamily = %02x\n"
1320           "    --------------------\n"
1321           "    InternalLeading = %i\n"
1322           "    Ascent = %i\n"
1323           "    Descent = %i\n"
1324           "    Height = %i\n",
1325           metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1326           metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1327           metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1328           metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1329           metrics->tmPitchAndFamily,
1330           metrics->tmInternalLeading,
1331           metrics->tmAscent,
1332           metrics->tmDescent,
1333           metrics->tmHeight );
1334     }
1335     release_dc_ptr( dc );
1336     return ret;
1337 }
1338
1339
1340 /***********************************************************************
1341  *              GetOutlineTextMetricsA (GDI32.@)
1342  * Gets metrics for TrueType fonts.
1343  *
1344  * NOTES
1345  *    If the supplied buffer isn't big enough Windows partially fills it up to
1346  *    its given length and returns that length.
1347  *
1348  * RETURNS
1349  *    Success: Non-zero or size of required buffer
1350  *    Failure: 0
1351  */
1352 UINT WINAPI GetOutlineTextMetricsA(
1353     HDC hdc,    /* [in]  Handle of device context */
1354     UINT cbData, /* [in]  Size of metric data array */
1355     LPOUTLINETEXTMETRICA lpOTM)  /* [out] Address of metric data array */
1356 {
1357     char buf[512], *ptr;
1358     UINT ret, needed;
1359     OUTLINETEXTMETRICW *lpOTMW = (OUTLINETEXTMETRICW *)buf;
1360     OUTLINETEXTMETRICA *output = lpOTM;
1361     INT left, len;
1362
1363     if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1364         return 0;
1365     if(ret > sizeof(buf))
1366         lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1367     GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1368
1369     needed = sizeof(OUTLINETEXTMETRICA);
1370     if(lpOTMW->otmpFamilyName)
1371         needed += WideCharToMultiByte(CP_ACP, 0,
1372            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1373                                       NULL, 0, NULL, NULL);
1374     if(lpOTMW->otmpFaceName)
1375         needed += WideCharToMultiByte(CP_ACP, 0,
1376            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1377                                       NULL, 0, NULL, NULL);
1378     if(lpOTMW->otmpStyleName)
1379         needed += WideCharToMultiByte(CP_ACP, 0,
1380            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1381                                       NULL, 0, NULL, NULL);
1382     if(lpOTMW->otmpFullName)
1383         needed += WideCharToMultiByte(CP_ACP, 0,
1384            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1385                                       NULL, 0, NULL, NULL);
1386
1387     if(!lpOTM) {
1388         ret = needed;
1389         goto end;
1390     }
1391
1392     TRACE("needed = %d\n", needed);
1393     if(needed > cbData)
1394         /* Since the supplied buffer isn't big enough, we'll alloc one
1395            that is and memcpy the first cbData bytes into the lpOTM at
1396            the end. */
1397         output = HeapAlloc(GetProcessHeap(), 0, needed);
1398
1399     ret = output->otmSize = min(needed, cbData);
1400     FONT_TextMetricWToA( &lpOTMW->otmTextMetrics, &output->otmTextMetrics );
1401     output->otmFiller = 0;
1402     output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1403     output->otmfsSelection = lpOTMW->otmfsSelection;
1404     output->otmfsType = lpOTMW->otmfsType;
1405     output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1406     output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1407     output->otmItalicAngle = lpOTMW->otmItalicAngle;
1408     output->otmEMSquare = lpOTMW->otmEMSquare;
1409     output->otmAscent = lpOTMW->otmAscent;
1410     output->otmDescent = lpOTMW->otmDescent;
1411     output->otmLineGap = lpOTMW->otmLineGap;
1412     output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1413     output->otmsXHeight = lpOTMW->otmsXHeight;
1414     output->otmrcFontBox = lpOTMW->otmrcFontBox;
1415     output->otmMacAscent = lpOTMW->otmMacAscent;
1416     output->otmMacDescent = lpOTMW->otmMacDescent;
1417     output->otmMacLineGap = lpOTMW->otmMacLineGap;
1418     output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1419     output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1420     output->otmptSubscriptOffset = lpOTMW->otmptSubscriptOffset;
1421     output->otmptSuperscriptSize = lpOTMW->otmptSuperscriptSize;
1422     output->otmptSuperscriptOffset = lpOTMW->otmptSuperscriptOffset;
1423     output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1424     output->otmsStrikeoutPosition = lpOTMW->otmsStrikeoutPosition;
1425     output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1426     output->otmsUnderscorePosition = lpOTMW->otmsUnderscorePosition;
1427
1428
1429     ptr = (char*)(output + 1);
1430     left = needed - sizeof(*output);
1431
1432     if(lpOTMW->otmpFamilyName) {
1433         output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1434         len = WideCharToMultiByte(CP_ACP, 0,
1435              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1436                                   ptr, left, NULL, NULL);
1437         left -= len;
1438         ptr += len;
1439     } else
1440         output->otmpFamilyName = 0;
1441
1442     if(lpOTMW->otmpFaceName) {
1443         output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1444         len = WideCharToMultiByte(CP_ACP, 0,
1445              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1446                                   ptr, left, NULL, NULL);
1447         left -= len;
1448         ptr += len;
1449     } else
1450         output->otmpFaceName = 0;
1451
1452     if(lpOTMW->otmpStyleName) {
1453         output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1454         len = WideCharToMultiByte(CP_ACP, 0,
1455              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1456                                   ptr, left, NULL, NULL);
1457         left -= len;
1458         ptr += len;
1459     } else
1460         output->otmpStyleName = 0;
1461
1462     if(lpOTMW->otmpFullName) {
1463         output->otmpFullName = (LPSTR)(ptr - (char*)output);
1464         len = WideCharToMultiByte(CP_ACP, 0,
1465              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1466                                   ptr, left, NULL, NULL);
1467         left -= len;
1468     } else
1469         output->otmpFullName = 0;
1470
1471     assert(left == 0);
1472
1473     if(output != lpOTM) {
1474         memcpy(lpOTM, output, cbData);
1475         HeapFree(GetProcessHeap(), 0, output);
1476
1477         /* check if the string offsets really fit into the provided size */
1478         /* FIXME: should we check string length as well? */
1479         /* make sure that we don't read/write beyond the provided buffer */
1480         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFamilyName) + sizeof(LPSTR))
1481         {
1482             if ((UINT_PTR)lpOTM->otmpFamilyName >= lpOTM->otmSize)
1483                 lpOTM->otmpFamilyName = 0; /* doesn't fit */
1484         }
1485
1486         /* make sure that we don't read/write beyond the provided buffer */
1487         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFaceName) + sizeof(LPSTR))
1488         {
1489             if ((UINT_PTR)lpOTM->otmpFaceName >= lpOTM->otmSize)
1490                 lpOTM->otmpFaceName = 0; /* doesn't fit */
1491         }
1492
1493             /* make sure that we don't read/write beyond the provided buffer */
1494         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpStyleName) + sizeof(LPSTR))
1495         {
1496             if ((UINT_PTR)lpOTM->otmpStyleName >= lpOTM->otmSize)
1497                 lpOTM->otmpStyleName = 0; /* doesn't fit */
1498         }
1499
1500         /* make sure that we don't read/write beyond the provided buffer */
1501         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFullName) + sizeof(LPSTR))
1502         {
1503             if ((UINT_PTR)lpOTM->otmpFullName >= lpOTM->otmSize)
1504                 lpOTM->otmpFullName = 0; /* doesn't fit */
1505         }
1506     }
1507
1508 end:
1509     if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1510         HeapFree(GetProcessHeap(), 0, lpOTMW);
1511
1512     return ret;
1513 }
1514
1515
1516 /***********************************************************************
1517  *           GetOutlineTextMetricsW [GDI32.@]
1518  */
1519 UINT WINAPI GetOutlineTextMetricsW(
1520     HDC hdc,    /* [in]  Handle of device context */
1521     UINT cbData, /* [in]  Size of metric data array */
1522     LPOUTLINETEXTMETRICW lpOTM)  /* [out] Address of metric data array */
1523 {
1524     DC *dc = get_dc_ptr( hdc );
1525     OUTLINETEXTMETRICW *output = lpOTM;
1526     PHYSDEV dev;
1527     UINT ret;
1528
1529     TRACE("(%p,%d,%p)\n", hdc, cbData, lpOTM);
1530     if(!dc) return 0;
1531
1532     dev = GET_DC_PHYSDEV( dc, pGetOutlineTextMetrics );
1533     ret = dev->funcs->pGetOutlineTextMetrics( dev, cbData, output );
1534
1535     if (lpOTM && ret > cbData)
1536     {
1537         output = HeapAlloc(GetProcessHeap(), 0, ret);
1538         ret = dev->funcs->pGetOutlineTextMetrics( dev, ret, output );
1539     }
1540
1541     if (lpOTM && ret)
1542     {
1543         output->otmTextMetrics.tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
1544         output->otmTextMetrics.tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
1545
1546 #define WDPTOLP(x) ((x<0)?                                      \
1547                 (-abs(INTERNAL_XDSTOWS(dc, (x)))):              \
1548                 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1549 #define HDPTOLP(y) ((y<0)?                                      \
1550                 (-abs(INTERNAL_YDSTOWS(dc, (y)))):              \
1551                 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1552
1553         output->otmTextMetrics.tmHeight           = HDPTOLP(output->otmTextMetrics.tmHeight);
1554         output->otmTextMetrics.tmAscent           = HDPTOLP(output->otmTextMetrics.tmAscent);
1555         output->otmTextMetrics.tmDescent          = HDPTOLP(output->otmTextMetrics.tmDescent);
1556         output->otmTextMetrics.tmInternalLeading  = HDPTOLP(output->otmTextMetrics.tmInternalLeading);
1557         output->otmTextMetrics.tmExternalLeading  = HDPTOLP(output->otmTextMetrics.tmExternalLeading);
1558         output->otmTextMetrics.tmAveCharWidth     = WDPTOLP(output->otmTextMetrics.tmAveCharWidth);
1559         output->otmTextMetrics.tmMaxCharWidth     = WDPTOLP(output->otmTextMetrics.tmMaxCharWidth);
1560         output->otmTextMetrics.tmOverhang         = WDPTOLP(output->otmTextMetrics.tmOverhang);
1561         output->otmAscent = HDPTOLP(output->otmAscent);
1562         output->otmDescent = HDPTOLP(output->otmDescent);
1563         output->otmLineGap = abs(INTERNAL_YDSTOWS(dc,output->otmLineGap));
1564         output->otmsCapEmHeight = abs(INTERNAL_YDSTOWS(dc,output->otmsCapEmHeight));
1565         output->otmsXHeight = abs(INTERNAL_YDSTOWS(dc,output->otmsXHeight));
1566         output->otmrcFontBox.top = HDPTOLP(output->otmrcFontBox.top);
1567         output->otmrcFontBox.bottom = HDPTOLP(output->otmrcFontBox.bottom);
1568         output->otmrcFontBox.left = WDPTOLP(output->otmrcFontBox.left);
1569         output->otmrcFontBox.right = WDPTOLP(output->otmrcFontBox.right);
1570         output->otmMacAscent = HDPTOLP(output->otmMacAscent);
1571         output->otmMacDescent = HDPTOLP(output->otmMacDescent);
1572         output->otmMacLineGap = abs(INTERNAL_YDSTOWS(dc,output->otmMacLineGap));
1573         output->otmptSubscriptSize.x = WDPTOLP(output->otmptSubscriptSize.x);
1574         output->otmptSubscriptSize.y = HDPTOLP(output->otmptSubscriptSize.y);
1575         output->otmptSubscriptOffset.x = WDPTOLP(output->otmptSubscriptOffset.x);
1576         output->otmptSubscriptOffset.y = HDPTOLP(output->otmptSubscriptOffset.y);
1577         output->otmptSuperscriptSize.x = WDPTOLP(output->otmptSuperscriptSize.x);
1578         output->otmptSuperscriptSize.y = HDPTOLP(output->otmptSuperscriptSize.y);
1579         output->otmptSuperscriptOffset.x = WDPTOLP(output->otmptSuperscriptOffset.x);
1580         output->otmptSuperscriptOffset.y = HDPTOLP(output->otmptSuperscriptOffset.y);
1581         output->otmsStrikeoutSize = abs(INTERNAL_YDSTOWS(dc,output->otmsStrikeoutSize));
1582         output->otmsStrikeoutPosition = HDPTOLP(output->otmsStrikeoutPosition);
1583         output->otmsUnderscoreSize = HDPTOLP(output->otmsUnderscoreSize);
1584         output->otmsUnderscorePosition = HDPTOLP(output->otmsUnderscorePosition);
1585 #undef WDPTOLP
1586 #undef HDPTOLP
1587         if(output != lpOTM)
1588         {
1589             memcpy(lpOTM, output, cbData);
1590             HeapFree(GetProcessHeap(), 0, output);
1591             ret = cbData;
1592         }
1593     }
1594     release_dc_ptr(dc);
1595     return ret;
1596 }
1597
1598 static LPSTR FONT_GetCharsByRangeA(HDC hdc, UINT firstChar, UINT lastChar, PINT pByteLen)
1599 {
1600     INT i, count = lastChar - firstChar + 1;
1601     UINT mbcp;
1602     UINT c;
1603     LPSTR str;
1604
1605     if (count <= 0)
1606         return NULL;
1607
1608     mbcp = GdiGetCodePage(hdc);
1609     switch (mbcp)
1610     {
1611     case 932:
1612     case 936:
1613     case 949:
1614     case 950:
1615     case 1361:
1616         if (lastChar > 0xffff)
1617             return NULL;
1618         if ((firstChar ^ lastChar) > 0xff)
1619             return NULL;
1620         break;
1621     default:
1622         if (lastChar > 0xff)
1623             return NULL;
1624         mbcp = 0;
1625         break;
1626     }
1627
1628     str = HeapAlloc(GetProcessHeap(), 0, count * 2 + 1);
1629     if (str == NULL)
1630         return NULL;
1631
1632     for(i = 0, c = firstChar; c <= lastChar; i++, c++)
1633     {
1634         if (mbcp) {
1635             if (c > 0xff)
1636                 str[i++] = (BYTE)(c >> 8);
1637             if (c <= 0xff && IsDBCSLeadByteEx(mbcp, c))
1638                 str[i] = 0x1f; /* FIXME: use default character */
1639             else
1640                 str[i] = (BYTE)c;
1641         }
1642         else
1643             str[i] = (BYTE)c;
1644     }
1645     str[i] = '\0';
1646
1647     *pByteLen = i;
1648
1649     return str;
1650 }
1651
1652 /***********************************************************************
1653  *           GetCharWidthW      (GDI32.@)
1654  *           GetCharWidth32W    (GDI32.@)
1655  */
1656 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1657                                LPINT buffer )
1658 {
1659     UINT i;
1660     BOOL ret;
1661     PHYSDEV dev;
1662     DC * dc = get_dc_ptr( hdc );
1663
1664     if (!dc) return FALSE;
1665
1666     dev = GET_DC_PHYSDEV( dc, pGetCharWidth );
1667     ret = dev->funcs->pGetCharWidth( dev, firstChar, lastChar, buffer );
1668
1669     if (ret)
1670     {
1671         /* convert device units to logical */
1672         for( i = firstChar; i <= lastChar; i++, buffer++ )
1673             *buffer = INTERNAL_XDSTOWS(dc, *buffer);
1674     }
1675     release_dc_ptr( dc );
1676     return ret;
1677 }
1678
1679
1680 /***********************************************************************
1681  *           GetCharWidthA      (GDI32.@)
1682  *           GetCharWidth32A    (GDI32.@)
1683  */
1684 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1685                                LPINT buffer )
1686 {
1687     INT i, wlen;
1688     LPSTR str;
1689     LPWSTR wstr;
1690     BOOL ret = TRUE;
1691
1692     str = FONT_GetCharsByRangeA(hdc, firstChar, lastChar, &i);
1693     if(str == NULL)
1694         return FALSE;
1695
1696     wstr = FONT_mbtowc(hdc, str, i, &wlen, NULL);
1697
1698     for(i = 0; i < wlen; i++)
1699     {
1700         if(!GetCharWidth32W(hdc, wstr[i], wstr[i], buffer))
1701         {
1702             ret = FALSE;
1703             break;
1704         }
1705         buffer++;
1706     }
1707
1708     HeapFree(GetProcessHeap(), 0, str);
1709     HeapFree(GetProcessHeap(), 0, wstr);
1710
1711     return ret;
1712 }
1713
1714
1715 /* helper for nulldrv_ExtTextOut */
1716 static DWORD get_glyph_bitmap( HDC hdc, UINT index, UINT aa_flags,
1717                                GLYPHMETRICS *metrics, struct gdi_image_bits *image )
1718 {
1719     UINT ggo_flags = aa_flags | GGO_GLYPH_INDEX;
1720     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
1721     UINT indices[3] = {0, 0, 0x20};
1722     int i;
1723     DWORD ret, size;
1724     int stride;
1725
1726     indices[0] = index;
1727
1728     for (i = 0; i < sizeof(indices) / sizeof(indices[0]); i++)
1729     {
1730         index = indices[i];
1731         ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, 0, NULL, &identity );
1732         if (ret != GDI_ERROR) break;
1733     }
1734
1735     if (ret == GDI_ERROR) return ERROR_NOT_FOUND;
1736     if (!image) return ERROR_SUCCESS;
1737
1738     image->ptr = NULL;
1739     image->free = NULL;
1740     if (!ret) return ERROR_SUCCESS; /* empty glyph */
1741
1742     stride = get_dib_stride( metrics->gmBlackBoxX, 1 );
1743     size = metrics->gmBlackBoxY * stride;
1744
1745     if (!(image->ptr = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_OUTOFMEMORY;
1746     image->is_copy = TRUE;
1747     image->free = free_heap_bits;
1748
1749     ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, size, image->ptr, &identity );
1750     if (ret == GDI_ERROR)
1751     {
1752         HeapFree( GetProcessHeap(), 0, image->ptr );
1753         return ERROR_NOT_FOUND;
1754     }
1755     return ERROR_SUCCESS;
1756 }
1757
1758 /* helper for nulldrv_ExtTextOut */
1759 static RECT get_total_extents( HDC hdc, INT x, INT y, UINT flags, UINT aa_flags,
1760                                LPCWSTR str, UINT count, const INT *dx )
1761 {
1762     int i;
1763     RECT rect, bounds;
1764
1765     reset_bounds( &bounds );
1766     for (i = 0; i < count; i++)
1767     {
1768         GLYPHMETRICS metrics;
1769
1770         if (get_glyph_bitmap( hdc, (UINT)str[i], aa_flags, &metrics, NULL )) continue;
1771
1772         rect.left   = x + metrics.gmptGlyphOrigin.x;
1773         rect.top    = y - metrics.gmptGlyphOrigin.y;
1774         rect.right  = rect.left + metrics.gmBlackBoxX;
1775         rect.bottom = rect.top  + metrics.gmBlackBoxY;
1776         add_bounds_rect( &bounds, &rect );
1777
1778         if (dx)
1779         {
1780             if (flags & ETO_PDY)
1781             {
1782                 x += dx[ i * 2 ];
1783                 y += dx[ i * 2 + 1];
1784             }
1785             else x += dx[ i ];
1786         }
1787         else
1788         {
1789             x += metrics.gmCellIncX;
1790             y += metrics.gmCellIncY;
1791         }
1792     }
1793     return bounds;
1794 }
1795
1796 /* helper for nulldrv_ExtTextOut */
1797 static void draw_glyph( HDC hdc, INT origin_x, INT origin_y, const GLYPHMETRICS *metrics,
1798                         const struct gdi_image_bits *image, const RECT *clip )
1799 {
1800     static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
1801     UINT x, y, i, count, max_count;
1802     BYTE *ptr = image->ptr;
1803     int stride = get_dib_stride( metrics->gmBlackBoxX, 1 );
1804     POINT *pts;
1805     RECT rect, clipped_rect;
1806
1807     rect.left   = origin_x  + metrics->gmptGlyphOrigin.x;
1808     rect.top    = origin_y  - metrics->gmptGlyphOrigin.y;
1809     rect.right  = rect.left + metrics->gmBlackBoxX;
1810     rect.bottom = rect.top  + metrics->gmBlackBoxY;
1811     if (!clip) clipped_rect = rect;
1812     else if (!intersect_rect( &clipped_rect, &rect, clip )) return;
1813
1814     max_count = (metrics->gmBlackBoxX + 1) * metrics->gmBlackBoxY;
1815     pts = HeapAlloc( GetProcessHeap(), 0, max_count * sizeof(*pts) );
1816     if (!pts) return;
1817
1818     count = 0;
1819     ptr += (clipped_rect.top - rect.top) * stride;
1820     for (y = clipped_rect.top; y < clipped_rect.bottom; y++, ptr += stride)
1821     {
1822         for (x = clipped_rect.left - rect.left; x < clipped_rect.right - rect.left; x++)
1823         {
1824             while (x < clipped_rect.right - rect.left && !(ptr[x / 8] & masks[x % 8])) x++;
1825             pts[count].x = rect.left + x;
1826             while (x < clipped_rect.right - rect.left && (ptr[x / 8] & masks[x % 8])) x++;
1827             pts[count + 1].x = rect.left + x;
1828             if (pts[count + 1].x > pts[count].x)
1829             {
1830                 pts[count].y = pts[count + 1].y = y;
1831                 count += 2;
1832             }
1833         }
1834     }
1835     assert( count <= max_count );
1836     DPtoLP( hdc, pts, count );
1837     for (i = 0; i < count; i += 2) Polyline( hdc, pts + i, 2 );
1838     HeapFree( GetProcessHeap(), 0, pts );
1839 }
1840
1841 /***********************************************************************
1842  *           nulldrv_ExtTextOut
1843  */
1844 BOOL nulldrv_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *rect,
1845                          LPCWSTR str, UINT count, const INT *dx )
1846 {
1847     DC *dc = get_nulldrv_dc( dev );
1848     UINT aa_flags, i;
1849     DWORD err;
1850     HGDIOBJ orig;
1851     HPEN pen;
1852
1853     if (flags & ETO_OPAQUE)
1854     {
1855         RECT rc = *rect;
1856         HBRUSH brush = CreateSolidBrush( GetNearestColor( dev->hdc, GetBkColor(dev->hdc) ));
1857
1858         if (brush)
1859         {
1860             orig = SelectObject( dev->hdc, brush );
1861             DPtoLP( dev->hdc, (POINT *)&rc, 2 );
1862             PatBlt( dev->hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY );
1863             SelectObject( dev->hdc, orig );
1864             DeleteObject( brush );
1865         }
1866     }
1867
1868     if (!count) return TRUE;
1869
1870     aa_flags = get_font_aa_flags( dev->hdc );
1871
1872     if (aa_flags != GGO_BITMAP)
1873     {
1874         char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1875         BITMAPINFO *info = (BITMAPINFO *)buffer;
1876         struct gdi_image_bits bits;
1877         struct bitblt_coords src, dst;
1878         PHYSDEV dst_dev;
1879
1880         dst_dev = GET_DC_PHYSDEV( dc, pPutImage );
1881         src.visrect = get_total_extents( dev->hdc, x, y, flags, aa_flags, str, count, dx );
1882         if (flags & ETO_CLIPPED) intersect_rect( &src.visrect, &src.visrect, rect );
1883         if (!clip_visrect( dc, &src.visrect, &src.visrect )) return TRUE;
1884
1885         /* FIXME: check for ETO_OPAQUE and avoid GetImage */
1886         src.x = src.visrect.left;
1887         src.y = src.visrect.top;
1888         src.width = src.visrect.right - src.visrect.left;
1889         src.height = src.visrect.bottom - src.visrect.top;
1890         dst = src;
1891         if ((flags & ETO_OPAQUE) && (src.visrect.left >= rect->left) && (src.visrect.top >= rect->top) &&
1892             (src.visrect.right <= rect->right) && (src.visrect.bottom <= rect->bottom))
1893         {
1894             /* we can avoid the GetImage, just query the needed format */
1895             memset( &info->bmiHeader, 0, sizeof(info->bmiHeader) );
1896             info->bmiHeader.biSize   = sizeof(info->bmiHeader);
1897             info->bmiHeader.biWidth  = src.width;
1898             info->bmiHeader.biHeight = -src.height;
1899             err = dst_dev->funcs->pPutImage( dst_dev, 0, info, NULL, NULL, NULL, 0 );
1900             if (!err || err == ERROR_BAD_FORMAT)
1901             {
1902                 /* make the source rectangle relative to the source bits */
1903                 src.x = src.y = 0;
1904                 src.visrect.left = src.visrect.top = 0;
1905                 src.visrect.right = src.width;
1906                 src.visrect.bottom = src.height;
1907
1908                 bits.ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( info ));
1909                 if (!bits.ptr) return ERROR_OUTOFMEMORY;
1910                 bits.is_copy = TRUE;
1911                 bits.free = free_heap_bits;
1912                 err = ERROR_SUCCESS;
1913             }
1914         }
1915         else
1916         {
1917             PHYSDEV src_dev = GET_DC_PHYSDEV( dc, pGetImage );
1918             err = src_dev->funcs->pGetImage( src_dev, info, &bits, &src );
1919             if (!err && !bits.is_copy)
1920             {
1921                 void *ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( info ));
1922                 if (!ptr)
1923                 {
1924                     if (bits.free) bits.free( &bits );
1925                     return ERROR_OUTOFMEMORY;
1926                 }
1927                 memcpy( ptr, bits.ptr, get_dib_image_size( info ));
1928                 if (bits.free) bits.free( &bits );
1929                 bits.ptr = ptr;
1930                 bits.is_copy = TRUE;
1931                 bits.free = free_heap_bits;
1932             }
1933         }
1934         if (!err)
1935         {
1936             /* make x,y relative to the image bits */
1937             x += src.visrect.left - dst.visrect.left;
1938             y += src.visrect.top - dst.visrect.top;
1939             render_aa_text_bitmapinfo( dev->hdc, info, &bits, &src, x, y, flags,
1940                                        aa_flags, str, count, dx );
1941             err = dst_dev->funcs->pPutImage( dst_dev, 0, info, &bits, &src, &dst, SRCCOPY );
1942             if (bits.free) bits.free( &bits );
1943             return !err;
1944         }
1945     }
1946
1947     pen = CreatePen( PS_SOLID, 1, GetTextColor(dev->hdc) );
1948     orig = SelectObject( dev->hdc, pen );
1949
1950     for (i = 0; i < count; i++)
1951     {
1952         GLYPHMETRICS metrics;
1953         struct gdi_image_bits image;
1954
1955         err = get_glyph_bitmap( dev->hdc, (UINT)str[i], GGO_BITMAP, &metrics, &image );
1956         if (err) continue;
1957
1958         if (image.ptr) draw_glyph( dev->hdc, x, y, &metrics, &image, (flags & ETO_CLIPPED) ? rect : NULL );
1959         if (image.free) image.free( &image );
1960
1961         if (dx)
1962         {
1963             if (flags & ETO_PDY)
1964             {
1965                 x += dx[ i * 2 ];
1966                 y += dx[ i * 2 + 1];
1967             }
1968             else x += dx[ i ];
1969         }
1970         else
1971         {
1972             x += metrics.gmCellIncX;
1973             y += metrics.gmCellIncY;
1974         }
1975     }
1976
1977     SelectObject( dev->hdc, orig );
1978     DeleteObject( pen );
1979     return TRUE;
1980 }
1981
1982
1983 /***********************************************************************
1984  *           ExtTextOutA    (GDI32.@)
1985  *
1986  * See ExtTextOutW.
1987  */
1988 BOOL WINAPI ExtTextOutA( HDC hdc, INT x, INT y, UINT flags,
1989                          const RECT *lprect, LPCSTR str, UINT count, const INT *lpDx )
1990 {
1991     INT wlen;
1992     UINT codepage;
1993     LPWSTR p;
1994     BOOL ret;
1995     LPINT lpDxW = NULL;
1996
1997     if (flags & ETO_GLYPH_INDEX)
1998         return ExtTextOutW( hdc, x, y, flags, lprect, (LPCWSTR)str, count, lpDx );
1999
2000     p = FONT_mbtowc(hdc, str, count, &wlen, &codepage);
2001
2002     if (lpDx) {
2003         unsigned int i = 0, j = 0;
2004
2005         /* allocate enough for a ETO_PDY */
2006         lpDxW = HeapAlloc( GetProcessHeap(), 0, 2*wlen*sizeof(INT));
2007         while(i < count) {
2008             if(IsDBCSLeadByteEx(codepage, str[i]))
2009             {
2010                 if(flags & ETO_PDY)
2011                 {
2012                     lpDxW[j++] = lpDx[i * 2]     + lpDx[(i + 1) * 2];
2013                     lpDxW[j++] = lpDx[i * 2 + 1] + lpDx[(i + 1) * 2 + 1];
2014                 }
2015                 else
2016                     lpDxW[j++] = lpDx[i] + lpDx[i + 1];
2017                 i = i + 2;
2018             }
2019             else
2020             {
2021                 if(flags & ETO_PDY)
2022                 {
2023                     lpDxW[j++] = lpDx[i * 2];
2024                     lpDxW[j++] = lpDx[i * 2 + 1];
2025                 }
2026                 else
2027                     lpDxW[j++] = lpDx[i];
2028                 i = i + 1;
2029             }
2030         }
2031     }
2032
2033     ret = ExtTextOutW( hdc, x, y, flags, lprect, p, wlen, lpDxW );
2034
2035     HeapFree( GetProcessHeap(), 0, p );
2036     HeapFree( GetProcessHeap(), 0, lpDxW );
2037     return ret;
2038 }
2039
2040
2041 /***********************************************************************
2042  *           ExtTextOutW    (GDI32.@)
2043  *
2044  * Draws text using the currently selected font, background color, and text color.
2045  *
2046  *
2047  * PARAMS
2048  *    x,y    [I] coordinates of string
2049  *    flags  [I]
2050  *        ETO_GRAYED - undocumented on MSDN
2051  *        ETO_OPAQUE - use background color for fill the rectangle
2052  *        ETO_CLIPPED - clipping text to the rectangle
2053  *        ETO_GLYPH_INDEX - Buffer is of glyph locations in fonts rather
2054  *                          than encoded characters. Implies ETO_IGNORELANGUAGE
2055  *        ETO_RTLREADING - Paragraph is basically a right-to-left paragraph.
2056  *                         Affects BiDi ordering
2057  *        ETO_IGNORELANGUAGE - Undocumented in MSDN - instructs ExtTextOut not to do BiDi reordering
2058  *        ETO_PDY - unimplemented
2059  *        ETO_NUMERICSLATIN - unimplemented always assumed -
2060  *                            do not translate numbers into locale representations
2061  *        ETO_NUMERICSLOCAL - unimplemented - Numerals in Arabic/Farsi context should assume local form
2062  *    lprect [I] dimensions for clipping or/and opaquing
2063  *    str    [I] text string
2064  *    count  [I] number of symbols in string
2065  *    lpDx   [I] optional parameter with distance between drawing characters
2066  *
2067  * RETURNS
2068  *    Success: TRUE
2069  *    Failure: FALSE
2070  */
2071 BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags,
2072                          const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx )
2073 {
2074     BOOL ret = FALSE;
2075     LPWSTR reordered_str = (LPWSTR)str;
2076     WORD *glyphs = NULL;
2077     UINT align = GetTextAlign( hdc );
2078     DWORD layout = GetLayout( hdc );
2079     POINT pt;
2080     TEXTMETRICW tm;
2081     LOGFONTW lf;
2082     double cosEsc, sinEsc;
2083     INT char_extra;
2084     SIZE sz;
2085     RECT rc;
2086     BOOL done_extents = FALSE;
2087     POINT *deltas = NULL, width = {0, 0};
2088     DWORD type;
2089     DC * dc = get_dc_ptr( hdc );
2090     PHYSDEV physdev;
2091     INT breakRem;
2092     static int quietfixme = 0;
2093
2094     if (!dc) return FALSE;
2095
2096     breakRem = dc->breakRem;
2097
2098     if (quietfixme == 0 && flags & (ETO_NUMERICSLOCAL | ETO_NUMERICSLATIN))
2099     {
2100         FIXME("flags ETO_NUMERICSLOCAL | ETO_NUMERICSLATIN unimplemented\n");
2101         quietfixme = 1;
2102     }
2103
2104     update_dc( dc );
2105     physdev = GET_DC_PHYSDEV( dc, pExtTextOut );
2106     type = GetObjectType(hdc);
2107     if(type == OBJ_METADC || type == OBJ_ENHMETADC)
2108     {
2109         ret = physdev->funcs->pExtTextOut( physdev, x, y, flags, lprect, str, count, lpDx );
2110         release_dc_ptr( dc );
2111         return ret;
2112     }
2113
2114     if (!lprect)
2115         flags &= ~ETO_CLIPPED;
2116
2117     if (flags & ETO_RTLREADING) align |= TA_RTLREADING;
2118     if (layout & LAYOUT_RTL)
2119     {
2120         if ((align & TA_CENTER) != TA_CENTER) align ^= TA_RIGHT;
2121         align ^= TA_RTLREADING;
2122     }
2123
2124     if( !(flags & (ETO_GLYPH_INDEX | ETO_IGNORELANGUAGE)) && count > 0 )
2125     {
2126         INT cGlyphs;
2127         reordered_str = HeapAlloc(GetProcessHeap(), 0, count*sizeof(WCHAR));
2128
2129         BIDI_Reorder( hdc, str, count, GCP_REORDER,
2130                       (align & TA_RTLREADING) ? WINE_GCPW_FORCE_RTL : WINE_GCPW_FORCE_LTR,
2131                       reordered_str, count, NULL, &glyphs, &cGlyphs);
2132
2133         flags |= ETO_IGNORELANGUAGE;
2134         if (glyphs)
2135         {
2136             flags |= ETO_GLYPH_INDEX;
2137             if (cGlyphs != count)
2138                 count = cGlyphs;
2139         }
2140     }
2141     else if(flags & ETO_GLYPH_INDEX)
2142         glyphs = reordered_str;
2143
2144     TRACE("%p, %d, %d, %08x, %s, %s, %d, %p)\n", hdc, x, y, flags,
2145           wine_dbgstr_rect(lprect), debugstr_wn(str, count), count, lpDx);
2146     TRACE("align = %x bkmode = %x mapmode = %x\n", align, GetBkMode(hdc), GetMapMode(hdc));
2147
2148     if(align & TA_UPDATECP)
2149     {
2150         GetCurrentPositionEx( hdc, &pt );
2151         x = pt.x;
2152         y = pt.y;
2153     }
2154
2155     GetTextMetricsW(hdc, &tm);
2156     GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf);
2157
2158     if(!(tm.tmPitchAndFamily & TMPF_VECTOR)) /* Non-scalable fonts shouldn't be rotated */
2159         lf.lfEscapement = 0;
2160
2161     if ((dc->GraphicsMode == GM_COMPATIBLE) &&
2162         (dc->vport2WorldValid && dc->xformWorld2Vport.eM11 * dc->xformWorld2Vport.eM22 < 0))
2163     {
2164         lf.lfEscapement = -lf.lfEscapement;
2165     }
2166
2167     if(lf.lfEscapement != 0)
2168     {
2169         cosEsc = cos(lf.lfEscapement * M_PI / 1800);
2170         sinEsc = sin(lf.lfEscapement * M_PI / 1800);
2171     }
2172     else
2173     {
2174         cosEsc = 1;
2175         sinEsc = 0;
2176     }
2177
2178     if(flags & (ETO_CLIPPED | ETO_OPAQUE))
2179     {
2180         if(!lprect)
2181         {
2182             if(flags & ETO_GLYPH_INDEX)
2183                 GetTextExtentPointI(hdc, glyphs, count, &sz);
2184             else
2185                 GetTextExtentPointW(hdc, reordered_str, count, &sz);
2186
2187             done_extents = TRUE;
2188             rc.left = x;
2189             rc.top = y;
2190             rc.right = x + sz.cx;
2191             rc.bottom = y + sz.cy;
2192         }
2193         else
2194         {
2195             rc = *lprect;
2196         }
2197
2198         LPtoDP(hdc, (POINT*)&rc, 2);
2199
2200         if(rc.left > rc.right) {INT tmp = rc.left; rc.left = rc.right; rc.right = tmp;}
2201         if(rc.top > rc.bottom) {INT tmp = rc.top; rc.top = rc.bottom; rc.bottom = tmp;}
2202     }
2203
2204     if (lprect && (flags & ETO_OPAQUE))
2205         physdev->funcs->pExtTextOut( physdev, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL );
2206
2207     if(count == 0)
2208     {
2209         ret = TRUE;
2210         goto done;
2211     }
2212
2213     pt.x = x;
2214     pt.y = y;
2215     LPtoDP(hdc, &pt, 1);
2216     x = pt.x;
2217     y = pt.y;
2218
2219     char_extra = GetTextCharacterExtra(hdc);
2220     if(char_extra || dc->breakExtra || breakRem || lpDx || lf.lfEscapement != 0)
2221     {
2222         UINT i;
2223         SIZE tmpsz;
2224         POINT total = {0, 0}, desired[2];
2225
2226         deltas = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*deltas));
2227         for(i = 0; i < count; i++)
2228         {
2229             if(lpDx)
2230             {
2231                 if(flags & ETO_PDY)
2232                 {
2233                     deltas[i].x = lpDx[i * 2] + char_extra;
2234                     deltas[i].y = -lpDx[i * 2 + 1];
2235                 }
2236                 else
2237                 {
2238                     deltas[i].x = lpDx[i] + char_extra;
2239                     deltas[i].y = 0;
2240                 }
2241
2242             }
2243             else
2244             {
2245                 if(flags & ETO_GLYPH_INDEX)
2246                     GetTextExtentPointI(hdc, glyphs + i, 1, &tmpsz);
2247                 else
2248                     GetTextExtentPointW(hdc, reordered_str + i, 1, &tmpsz);
2249
2250                 deltas[i].x = tmpsz.cx;
2251                 deltas[i].y = 0;
2252             }
2253
2254             if (!(flags & ETO_GLYPH_INDEX) && (dc->breakExtra || breakRem) && reordered_str[i] == tm.tmBreakChar)
2255             {
2256                 deltas[i].x = deltas[i].x + dc->breakExtra;
2257                 if (breakRem > 0)
2258                 {
2259                     breakRem--;
2260                     deltas[i].x++;
2261                 }
2262             }
2263             total.x += deltas[i].x;
2264             total.y += deltas[i].y;
2265
2266             desired[0].x = desired[0].y = 0;
2267
2268             desired[1].x =  cosEsc * total.x + sinEsc * total.y;
2269             desired[1].y = -sinEsc * total.x + cosEsc * total.y;
2270
2271             LPtoDP(hdc, desired, 2);
2272             desired[1].x -= desired[0].x;
2273             desired[1].y -= desired[0].y;
2274
2275             if (dc->GraphicsMode == GM_COMPATIBLE)
2276             {
2277                 if (dc->vport2WorldValid && dc->xformWorld2Vport.eM11 < 0)
2278                     desired[1].x = -desired[1].x;
2279                 if (dc->vport2WorldValid && dc->xformWorld2Vport.eM22 < 0)
2280                     desired[1].y = -desired[1].y;
2281             }
2282             else
2283             {
2284                 if (layout & LAYOUT_RTL) desired[1].x = -desired[1].x;
2285             }
2286
2287             deltas[i].x = desired[1].x - width.x;
2288             deltas[i].y = desired[1].y - width.y;
2289
2290             width = desired[1];
2291         }
2292         flags |= ETO_PDY;
2293     }
2294     else
2295     {
2296         if(!done_extents)
2297         {
2298             if(flags & ETO_GLYPH_INDEX)
2299                 GetTextExtentPointI(hdc, glyphs, count, &sz);
2300             else
2301                 GetTextExtentPointW(hdc, reordered_str, count, &sz);
2302             done_extents = TRUE;
2303         }
2304         width.x = abs(INTERNAL_XWSTODS(dc, sz.cx));
2305         width.y = 0;
2306     }
2307
2308     tm.tmAscent = abs(INTERNAL_YWSTODS(dc, tm.tmAscent));
2309     tm.tmDescent = abs(INTERNAL_YWSTODS(dc, tm.tmDescent));
2310     switch( align & (TA_LEFT | TA_RIGHT | TA_CENTER) )
2311     {
2312     case TA_LEFT:
2313         if (align & TA_UPDATECP)
2314         {
2315             pt.x = x + width.x;
2316             pt.y = y + width.y;
2317             DPtoLP(hdc, &pt, 1);
2318             MoveToEx(hdc, pt.x, pt.y, NULL);
2319         }
2320         break;
2321
2322     case TA_CENTER:
2323         x -= width.x / 2;
2324         y -= width.y / 2;
2325         break;
2326
2327     case TA_RIGHT:
2328         x -= width.x;
2329         y -= width.y;
2330         if (align & TA_UPDATECP)
2331         {
2332             pt.x = x;
2333             pt.y = y;
2334             DPtoLP(hdc, &pt, 1);
2335             MoveToEx(hdc, pt.x, pt.y, NULL);
2336         }
2337         break;
2338     }
2339
2340     switch( align & (TA_TOP | TA_BOTTOM | TA_BASELINE) )
2341     {
2342     case TA_TOP:
2343         y += tm.tmAscent * cosEsc;
2344         x += tm.tmAscent * sinEsc;
2345         break;
2346
2347     case TA_BOTTOM:
2348         y -= tm.tmDescent * cosEsc;
2349         x -= tm.tmDescent * sinEsc;
2350         break;
2351
2352     case TA_BASELINE:
2353         break;
2354     }
2355
2356     if (GetBkMode(hdc) != TRANSPARENT)
2357     {
2358         if(!((flags & ETO_CLIPPED) && (flags & ETO_OPAQUE)))
2359         {
2360             if(!(flags & ETO_OPAQUE) || !lprect ||
2361                x < rc.left || x + width.x >= rc.right ||
2362                y - tm.tmAscent < rc.top || y + tm.tmDescent >= rc.bottom)
2363             {
2364                 RECT text_box;
2365                 text_box.left = x;
2366                 text_box.right = x + width.x;
2367                 text_box.top = y - tm.tmAscent;
2368                 text_box.bottom = y + tm.tmDescent;
2369
2370                 if (flags & ETO_CLIPPED) intersect_rect( &text_box, &text_box, &rc );
2371                 if (!is_rect_empty( &text_box ))
2372                     physdev->funcs->pExtTextOut( physdev, 0, 0, ETO_OPAQUE, &text_box, NULL, 0, NULL );
2373             }
2374         }
2375     }
2376
2377     if(FontIsLinked(hdc) && !(flags & ETO_GLYPH_INDEX))
2378     {
2379         HFONT orig_font = dc->hFont, cur_font;
2380         UINT glyph;
2381         INT span = 0;
2382         POINT *offsets = NULL;
2383         unsigned int i;
2384
2385         glyphs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WORD));
2386         for(i = 0; i < count; i++)
2387         {
2388             WineEngGetLinkedHFont(dc, reordered_str[i], &cur_font, &glyph);
2389             if(cur_font != dc->hFont)
2390             {
2391                 if(!offsets)
2392                 {
2393                     unsigned int j;
2394                     offsets = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*deltas));
2395                     offsets[0].x = offsets[0].y = 0;
2396
2397                     if(!deltas)
2398                     {
2399                         SIZE tmpsz;
2400                         for(j = 1; j < count; j++)
2401                         {
2402                             GetTextExtentPointW(hdc, reordered_str + j - 1, 1, &tmpsz);
2403                             offsets[j].x = offsets[j - 1].x + abs(INTERNAL_XWSTODS(dc, tmpsz.cx));
2404                             offsets[j].y = 0;
2405                         }
2406                     }
2407                     else
2408                     {
2409                         for(j = 1; j < count; j++)
2410                         {
2411                             offsets[j].x = offsets[j - 1].x + deltas[j].x;
2412                             offsets[j].y = offsets[j - 1].y + deltas[j].y;
2413                         }
2414                     }
2415                 }
2416                 if(span)
2417                 {
2418                     physdev->funcs->pExtTextOut( physdev, x + offsets[i - span].x,
2419                                                  y + offsets[i - span].y,
2420                                                  (flags & ~ETO_OPAQUE) | ETO_GLYPH_INDEX, &rc, glyphs,
2421                                                  span, deltas ? (INT*)(deltas + (i - span)) : NULL);
2422                     span = 0;
2423                 }
2424                 SelectObject(hdc, cur_font);
2425             }
2426             glyphs[span++] = glyph;
2427
2428             if(i == count - 1)
2429             {
2430                 ret = physdev->funcs->pExtTextOut(physdev, x + (offsets ? offsets[count - span].x : 0),
2431                                                   y + (offsets ? offsets[count - span].y : 0),
2432                                                   (flags & ~ETO_OPAQUE) | ETO_GLYPH_INDEX, &rc, glyphs,
2433                                                   span, deltas ? (INT*)(deltas + (count - span)) : NULL);
2434                 SelectObject(hdc, orig_font);
2435                 HeapFree(GetProcessHeap(), 0, offsets);
2436            }
2437         }
2438     }
2439     else
2440     {
2441         if(!(flags & ETO_GLYPH_INDEX) && dc->gdiFont)
2442         {
2443             glyphs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WORD));
2444             GetGlyphIndicesW(hdc, reordered_str, count, glyphs, 0);
2445             flags |= ETO_GLYPH_INDEX;
2446         }
2447         ret = physdev->funcs->pExtTextOut( physdev, x, y, (flags & ~ETO_OPAQUE), &rc,
2448                                            glyphs ? glyphs : reordered_str, count, (INT*)deltas );
2449     }
2450
2451 done:
2452     HeapFree(GetProcessHeap(), 0, deltas);
2453     if(glyphs != reordered_str)
2454         HeapFree(GetProcessHeap(), 0, glyphs);
2455     if(reordered_str != str)
2456         HeapFree(GetProcessHeap(), 0, reordered_str);
2457
2458     release_dc_ptr( dc );
2459
2460     if (ret && (lf.lfUnderline || lf.lfStrikeOut))
2461     {
2462         int underlinePos, strikeoutPos;
2463         int underlineWidth, strikeoutWidth;
2464         UINT size = GetOutlineTextMetricsW(hdc, 0, NULL);
2465         OUTLINETEXTMETRICW* otm = NULL;
2466         POINT pts[5];
2467         HPEN hpen = SelectObject(hdc, GetStockObject(NULL_PEN));
2468         HBRUSH hbrush = CreateSolidBrush(GetTextColor(hdc));
2469
2470         hbrush = SelectObject(hdc, hbrush);
2471
2472         if(!size)
2473         {
2474             underlinePos = 0;
2475             underlineWidth = tm.tmAscent / 20 + 1;
2476             strikeoutPos = tm.tmAscent / 2;
2477             strikeoutWidth = underlineWidth;
2478         }
2479         else
2480         {
2481             otm = HeapAlloc(GetProcessHeap(), 0, size);
2482             GetOutlineTextMetricsW(hdc, size, otm);
2483             underlinePos = abs( INTERNAL_YWSTODS( dc, otm->otmsUnderscorePosition ));
2484             if (otm->otmsUnderscorePosition < 0) underlinePos = -underlinePos;
2485             underlineWidth = abs( INTERNAL_YWSTODS( dc, otm->otmsUnderscoreSize ));
2486             if (otm->otmsUnderscoreSize < 0) underlineWidth = -underlineWidth;
2487             strikeoutPos = abs( INTERNAL_YWSTODS( dc, otm->otmsStrikeoutPosition ));
2488             if (otm->otmsStrikeoutPosition < 0) strikeoutPos = -strikeoutPos;
2489             strikeoutWidth = abs( INTERNAL_YWSTODS( dc, otm->otmsStrikeoutSize ));
2490             HeapFree(GetProcessHeap(), 0, otm);
2491         }
2492
2493
2494         if (lf.lfUnderline)
2495         {
2496             pts[0].x = x - (underlinePos + underlineWidth / 2) * sinEsc;
2497             pts[0].y = y - (underlinePos + underlineWidth / 2) * cosEsc;
2498             pts[1].x = x + width.x - (underlinePos + underlineWidth / 2) * sinEsc;
2499             pts[1].y = y + width.y - (underlinePos + underlineWidth / 2) * cosEsc;
2500             pts[2].x = pts[1].x + underlineWidth * sinEsc;
2501             pts[2].y = pts[1].y + underlineWidth * cosEsc;
2502             pts[3].x = pts[0].x + underlineWidth * sinEsc;
2503             pts[3].y = pts[0].y + underlineWidth * cosEsc;
2504             pts[4].x = pts[0].x;
2505             pts[4].y = pts[0].y;
2506             DPtoLP(hdc, pts, 5);
2507             Polygon(hdc, pts, 5);
2508         }
2509
2510         if (lf.lfStrikeOut)
2511         {
2512             pts[0].x = x - (strikeoutPos + strikeoutWidth / 2) * sinEsc;
2513             pts[0].y = y - (strikeoutPos + strikeoutWidth / 2) * cosEsc;
2514             pts[1].x = x + width.x - (strikeoutPos + strikeoutWidth / 2) * sinEsc;
2515             pts[1].y = y + width.y - (strikeoutPos + strikeoutWidth / 2) * cosEsc;
2516             pts[2].x = pts[1].x + strikeoutWidth * sinEsc;
2517             pts[2].y = pts[1].y + strikeoutWidth * cosEsc;
2518             pts[3].x = pts[0].x + strikeoutWidth * sinEsc;
2519             pts[3].y = pts[0].y + strikeoutWidth * cosEsc;
2520             pts[4].x = pts[0].x;
2521             pts[4].y = pts[0].y;
2522             DPtoLP(hdc, pts, 5);
2523             Polygon(hdc, pts, 5);
2524         }
2525
2526         SelectObject(hdc, hpen);
2527         hbrush = SelectObject(hdc, hbrush);
2528         DeleteObject(hbrush);
2529     }
2530
2531     return ret;
2532 }
2533
2534
2535 /***********************************************************************
2536  *           TextOutA    (GDI32.@)
2537  */
2538 BOOL WINAPI TextOutA( HDC hdc, INT x, INT y, LPCSTR str, INT count )
2539 {
2540     return ExtTextOutA( hdc, x, y, 0, NULL, str, count, NULL );
2541 }
2542
2543
2544 /***********************************************************************
2545  *           TextOutW    (GDI32.@)
2546  */
2547 BOOL WINAPI TextOutW(HDC hdc, INT x, INT y, LPCWSTR str, INT count)
2548 {
2549     return ExtTextOutW( hdc, x, y, 0, NULL, str, count, NULL );
2550 }
2551
2552
2553 /***********************************************************************
2554  *              PolyTextOutA (GDI32.@)
2555  *
2556  * See PolyTextOutW.
2557  */
2558 BOOL WINAPI PolyTextOutA( HDC hdc, const POLYTEXTA *pptxt, INT cStrings )
2559 {
2560     for (; cStrings>0; cStrings--, pptxt++)
2561         if (!ExtTextOutA( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
2562             return FALSE;
2563     return TRUE;
2564 }
2565
2566
2567
2568 /***********************************************************************
2569  *              PolyTextOutW (GDI32.@)
2570  *
2571  * Draw several Strings
2572  *
2573  * RETURNS
2574  *  TRUE:  Success.
2575  *  FALSE: Failure.
2576  */
2577 BOOL WINAPI PolyTextOutW( HDC hdc, const POLYTEXTW *pptxt, INT cStrings )
2578 {
2579     for (; cStrings>0; cStrings--, pptxt++)
2580         if (!ExtTextOutW( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
2581             return FALSE;
2582     return TRUE;
2583 }
2584
2585
2586 /***********************************************************************
2587  *           SetMapperFlags    (GDI32.@)
2588  */
2589 DWORD WINAPI SetMapperFlags( HDC hdc, DWORD flags )
2590 {
2591     DC *dc = get_dc_ptr( hdc );
2592     DWORD ret = GDI_ERROR;
2593
2594     if (dc)
2595     {
2596         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetMapperFlags );
2597         flags = physdev->funcs->pSetMapperFlags( physdev, flags );
2598         if (flags != GDI_ERROR)
2599         {
2600             ret = dc->mapperFlags;
2601             dc->mapperFlags = flags;
2602         }
2603         release_dc_ptr( dc );
2604     }
2605     return ret;
2606 }
2607
2608 /***********************************************************************
2609  *          GetAspectRatioFilterEx  (GDI32.@)
2610  */
2611 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
2612 {
2613   FIXME("(%p, %p): -- Empty Stub !\n", hdc, pAspectRatio);
2614   return FALSE;
2615 }
2616
2617
2618 /***********************************************************************
2619  *           GetCharABCWidthsA   (GDI32.@)
2620  *
2621  * See GetCharABCWidthsW.
2622  */
2623 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
2624                                   LPABC abc )
2625 {
2626     INT i, wlen;
2627     LPSTR str;
2628     LPWSTR wstr;
2629     BOOL ret = TRUE;
2630
2631     str = FONT_GetCharsByRangeA(hdc, firstChar, lastChar, &i);
2632     if (str == NULL)
2633         return FALSE;
2634
2635     wstr = FONT_mbtowc(hdc, str, i, &wlen, NULL);
2636     if (wstr == NULL)
2637     {
2638         HeapFree(GetProcessHeap(), 0, str);
2639         return FALSE;
2640     }
2641
2642     for(i = 0; i < wlen; i++)
2643     {
2644         if(!GetCharABCWidthsW(hdc, wstr[i], wstr[i], abc))
2645         {
2646             ret = FALSE;
2647             break;
2648         }
2649         abc++;
2650     }
2651
2652     HeapFree(GetProcessHeap(), 0, str);
2653     HeapFree(GetProcessHeap(), 0, wstr);
2654
2655     return ret;
2656 }
2657
2658
2659 /******************************************************************************
2660  * GetCharABCWidthsW [GDI32.@]
2661  *
2662  * Retrieves widths of characters in range.
2663  *
2664  * PARAMS
2665  *    hdc       [I] Handle of device context
2666  *    firstChar [I] First character in range to query
2667  *    lastChar  [I] Last character in range to query
2668  *    abc       [O] Address of character-width structure
2669  *
2670  * NOTES
2671  *    Only works with TrueType fonts
2672  *
2673  * RETURNS
2674  *    Success: TRUE
2675  *    Failure: FALSE
2676  */
2677 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
2678                                    LPABC abc )
2679 {
2680     DC *dc = get_dc_ptr(hdc);
2681     PHYSDEV dev;
2682     unsigned int i;
2683     BOOL ret;
2684     TEXTMETRICW tm;
2685
2686     if (!dc) return FALSE;
2687
2688     if (!abc)
2689     {
2690         release_dc_ptr( dc );
2691         return FALSE;
2692     }
2693
2694     /* unlike GetCharABCWidthsFloatW, this one is supposed to fail on non-scalable fonts */
2695     dev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
2696     if (!dev->funcs->pGetTextMetrics( dev, &tm ) || !(tm.tmPitchAndFamily & TMPF_VECTOR))
2697     {
2698         release_dc_ptr( dc );
2699         return FALSE;
2700     }
2701
2702     dev = GET_DC_PHYSDEV( dc, pGetCharABCWidths );
2703     ret = dev->funcs->pGetCharABCWidths( dev, firstChar, lastChar, abc );
2704     if (ret)
2705     {
2706         /* convert device units to logical */
2707         for( i = firstChar; i <= lastChar; i++, abc++ ) {
2708             abc->abcA = INTERNAL_XDSTOWS(dc, abc->abcA);
2709             abc->abcB = INTERNAL_XDSTOWS(dc, abc->abcB);
2710             abc->abcC = INTERNAL_XDSTOWS(dc, abc->abcC);
2711         }
2712     }
2713
2714     release_dc_ptr( dc );
2715     return ret;
2716 }
2717
2718
2719 /******************************************************************************
2720  * GetCharABCWidthsI [GDI32.@]
2721  *
2722  * Retrieves widths of characters in range.
2723  *
2724  * PARAMS
2725  *    hdc       [I] Handle of device context
2726  *    firstChar [I] First glyphs in range to query
2727  *    count     [I] Last glyphs in range to query
2728  *    pgi       [i] Array of glyphs to query
2729  *    abc       [O] Address of character-width structure
2730  *
2731  * NOTES
2732  *    Only works with TrueType fonts
2733  *
2734  * RETURNS
2735  *    Success: TRUE
2736  *    Failure: FALSE
2737  */
2738 BOOL WINAPI GetCharABCWidthsI( HDC hdc, UINT firstChar, UINT count,
2739                                LPWORD pgi, LPABC abc)
2740 {
2741     DC *dc = get_dc_ptr(hdc);
2742     PHYSDEV dev;
2743     unsigned int i;
2744     BOOL ret;
2745
2746     if (!dc) return FALSE;
2747
2748     if (!abc)
2749     {
2750         release_dc_ptr( dc );
2751         return FALSE;
2752     }
2753
2754     dev = GET_DC_PHYSDEV( dc, pGetCharABCWidthsI );
2755     ret = dev->funcs->pGetCharABCWidthsI( dev, firstChar, count, pgi, abc );
2756     if (ret)
2757     {
2758         /* convert device units to logical */
2759         for( i = 0; i < count; i++, abc++ ) {
2760             abc->abcA = INTERNAL_XDSTOWS(dc, abc->abcA);
2761             abc->abcB = INTERNAL_XDSTOWS(dc, abc->abcB);
2762             abc->abcC = INTERNAL_XDSTOWS(dc, abc->abcC);
2763         }
2764     }
2765
2766     release_dc_ptr( dc );
2767     return ret;
2768 }
2769
2770
2771 /***********************************************************************
2772  *           GetGlyphOutlineA    (GDI32.@)
2773  */
2774 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
2775                                  LPGLYPHMETRICS lpgm, DWORD cbBuffer,
2776                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
2777 {
2778     if (!lpmat2) return GDI_ERROR;
2779
2780     if(!(fuFormat & GGO_GLYPH_INDEX)) {
2781         UINT cp;
2782         int len;
2783         char mbchs[2];
2784
2785         cp = GdiGetCodePage(hdc);
2786         if (IsDBCSLeadByteEx(cp, uChar >> 8)) {
2787             len = 2;
2788             mbchs[0] = (uChar & 0xff00) >> 8;
2789             mbchs[1] = (uChar & 0xff);
2790         } else {
2791             len = 1;
2792             mbchs[0] = (uChar & 0xff);
2793         }
2794         uChar = 0;
2795         MultiByteToWideChar(cp, 0, mbchs, len, (LPWSTR)&uChar, 1);
2796     }
2797
2798     return GetGlyphOutlineW(hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer,
2799                             lpmat2);
2800 }
2801
2802 /***********************************************************************
2803  *           GetGlyphOutlineW    (GDI32.@)
2804  */
2805 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
2806                                  LPGLYPHMETRICS lpgm, DWORD cbBuffer,
2807                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
2808 {
2809     DC *dc;
2810     DWORD ret;
2811     PHYSDEV dev;
2812
2813     TRACE("(%p, %04x, %04x, %p, %d, %p, %p)\n",
2814           hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
2815
2816     if (!lpmat2) return GDI_ERROR;
2817
2818     dc = get_dc_ptr(hdc);
2819     if(!dc) return GDI_ERROR;
2820
2821     dev = GET_DC_PHYSDEV( dc, pGetGlyphOutline );
2822     ret = dev->funcs->pGetGlyphOutline( dev, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
2823     release_dc_ptr( dc );
2824     return ret;
2825 }
2826
2827
2828 /***********************************************************************
2829  *           CreateScalableFontResourceA   (GDI32.@)
2830  */
2831 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
2832                                              LPCSTR lpszResourceFile,
2833                                              LPCSTR lpszFontFile,
2834                                              LPCSTR lpszCurrentPath )
2835 {
2836     LPWSTR lpszResourceFileW = NULL;
2837     LPWSTR lpszFontFileW = NULL;
2838     LPWSTR lpszCurrentPathW = NULL;
2839     int len;
2840     BOOL ret;
2841
2842     if (lpszResourceFile)
2843     {
2844         len = MultiByteToWideChar(CP_ACP, 0, lpszResourceFile, -1, NULL, 0);
2845         lpszResourceFileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2846         MultiByteToWideChar(CP_ACP, 0, lpszResourceFile, -1, lpszResourceFileW, len);
2847     }
2848
2849     if (lpszFontFile)
2850     {
2851         len = MultiByteToWideChar(CP_ACP, 0, lpszFontFile, -1, NULL, 0);
2852         lpszFontFileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2853         MultiByteToWideChar(CP_ACP, 0, lpszFontFile, -1, lpszFontFileW, len);
2854     }
2855
2856     if (lpszCurrentPath)
2857     {
2858         len = MultiByteToWideChar(CP_ACP, 0, lpszCurrentPath, -1, NULL, 0);
2859         lpszCurrentPathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2860         MultiByteToWideChar(CP_ACP, 0, lpszCurrentPath, -1, lpszCurrentPathW, len);
2861     }
2862
2863     ret = CreateScalableFontResourceW(fHidden, lpszResourceFileW,
2864             lpszFontFileW, lpszCurrentPathW);
2865
2866     HeapFree(GetProcessHeap(), 0, lpszResourceFileW);
2867     HeapFree(GetProcessHeap(), 0, lpszFontFileW);
2868     HeapFree(GetProcessHeap(), 0, lpszCurrentPathW);
2869
2870     return ret;
2871 }
2872
2873 /***********************************************************************
2874  *           CreateScalableFontResourceW   (GDI32.@)
2875  */
2876 BOOL WINAPI CreateScalableFontResourceW( DWORD hidden, LPCWSTR resource_file,
2877                                          LPCWSTR font_file, LPCWSTR font_path )
2878 {
2879     TRACE("(%d, %s, %s, %s)\n", hidden, debugstr_w(resource_file),
2880           debugstr_w(font_file), debugstr_w(font_path) );
2881
2882     return WineEngCreateScalableFontResource( hidden, resource_file,
2883                                               font_file, font_path );
2884 }
2885
2886 /*************************************************************************
2887  *             GetKerningPairsA   (GDI32.@)
2888  */
2889 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
2890                                LPKERNINGPAIR kern_pairA )
2891 {
2892     UINT cp;
2893     CPINFO cpi;
2894     DWORD i, total_kern_pairs, kern_pairs_copied = 0;
2895     KERNINGPAIR *kern_pairW;
2896
2897     if (!cPairs && kern_pairA)
2898     {
2899         SetLastError(ERROR_INVALID_PARAMETER);
2900         return 0;
2901     }
2902
2903     cp = GdiGetCodePage(hDC);
2904
2905     /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
2906      * to fail on an invalid character for CP_SYMBOL.
2907      */
2908     cpi.DefaultChar[0] = 0;
2909     if (cp != CP_SYMBOL && !GetCPInfo(cp, &cpi))
2910     {
2911         FIXME("Can't find codepage %u info\n", cp);
2912         return 0;
2913     }
2914
2915     total_kern_pairs = GetKerningPairsW(hDC, 0, NULL);
2916     if (!total_kern_pairs) return 0;
2917
2918     kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
2919     GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
2920
2921     for (i = 0; i < total_kern_pairs; i++)
2922     {
2923         char first, second;
2924
2925         if (!WideCharToMultiByte(cp, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
2926             continue;
2927
2928         if (!WideCharToMultiByte(cp, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
2929             continue;
2930
2931         if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
2932             continue;
2933
2934         if (kern_pairA)
2935         {
2936             if (kern_pairs_copied >= cPairs) break;
2937
2938             kern_pairA->wFirst = (BYTE)first;
2939             kern_pairA->wSecond = (BYTE)second;
2940             kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
2941             kern_pairA++;
2942         }
2943         kern_pairs_copied++;
2944     }
2945
2946     HeapFree(GetProcessHeap(), 0, kern_pairW);
2947
2948     return kern_pairs_copied;
2949 }
2950
2951 /*************************************************************************
2952  *             GetKerningPairsW   (GDI32.@)
2953  */
2954 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
2955                                  LPKERNINGPAIR lpKerningPairs )
2956 {
2957     DC *dc;
2958     DWORD ret;
2959     PHYSDEV dev;
2960
2961     TRACE("(%p,%d,%p)\n", hDC, cPairs, lpKerningPairs);
2962
2963     if (!cPairs && lpKerningPairs)
2964     {
2965         SetLastError(ERROR_INVALID_PARAMETER);
2966         return 0;
2967     }
2968
2969     dc = get_dc_ptr(hDC);
2970     if (!dc) return 0;
2971
2972     dev = GET_DC_PHYSDEV( dc, pGetKerningPairs );
2973     ret = dev->funcs->pGetKerningPairs( dev, cPairs, lpKerningPairs );
2974     release_dc_ptr( dc );
2975     return ret;
2976 }
2977
2978 /*************************************************************************
2979  * TranslateCharsetInfo [GDI32.@]
2980  *
2981  * Fills a CHARSETINFO structure for a character set, code page, or
2982  * font. This allows making the correspondence between different labels
2983  * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
2984  * of the same encoding.
2985  *
2986  * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
2987  * only one codepage should be set in *lpSrc.
2988  *
2989  * RETURNS
2990  *   TRUE on success, FALSE on failure.
2991  *
2992  */
2993 BOOL WINAPI TranslateCharsetInfo(
2994   LPDWORD lpSrc, /* [in]
2995        if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
2996        if flags == TCI_SRCCHARSET: a character set value
2997        if flags == TCI_SRCCODEPAGE: a code page value
2998                  */
2999   LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
3000   DWORD flags /* [in] determines interpretation of lpSrc */)
3001 {
3002     int index = 0;
3003     switch (flags) {
3004     case TCI_SRCFONTSIG:
3005       while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++;
3006       break;
3007     case TCI_SRCCODEPAGE:
3008       while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++;
3009       break;
3010     case TCI_SRCCHARSET:
3011       while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++;
3012       break;
3013     default:
3014       return FALSE;
3015     }
3016     if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
3017     *lpCs = FONT_tci[index];
3018     return TRUE;
3019 }
3020
3021 /*************************************************************************
3022  *             GetFontLanguageInfo   (GDI32.@)
3023  */
3024 DWORD WINAPI GetFontLanguageInfo(HDC hdc)
3025 {
3026         FONTSIGNATURE fontsig;
3027         static const DWORD GCP_DBCS_MASK=0x003F0000,
3028                 GCP_DIACRITIC_MASK=0x00000000,
3029                 FLI_GLYPHS_MASK=0x00000000,
3030                 GCP_GLYPHSHAPE_MASK=0x00000040,
3031                 GCP_KASHIDA_MASK=0x00000000,
3032                 GCP_LIGATE_MASK=0x00000000,
3033                 GCP_USEKERNING_MASK=0x00000000,
3034                 GCP_REORDER_MASK=0x00000060;
3035
3036         DWORD result=0;
3037
3038         GetTextCharsetInfo( hdc, &fontsig, 0 );
3039         /* We detect each flag we return using a bitmask on the Codepage Bitfields */
3040
3041         if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
3042                 result|=GCP_DBCS;
3043
3044         if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
3045                 result|=GCP_DIACRITIC;
3046
3047         if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
3048                 result|=FLI_GLYPHS;
3049
3050         if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
3051                 result|=GCP_GLYPHSHAPE;
3052
3053         if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
3054                 result|=GCP_KASHIDA;
3055
3056         if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
3057                 result|=GCP_LIGATE;
3058
3059         if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
3060                 result|=GCP_USEKERNING;
3061
3062         /* this might need a test for a HEBREW- or ARABIC_CHARSET as well */
3063         if( GetTextAlign( hdc) & TA_RTLREADING )
3064             if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
3065                     result|=GCP_REORDER;
3066
3067         return result;
3068 }
3069
3070
3071 /*************************************************************************
3072  * GetFontData [GDI32.@]
3073  *
3074  * Retrieve data for TrueType font.
3075  *
3076  * RETURNS
3077  *
3078  * success: Number of bytes returned
3079  * failure: GDI_ERROR
3080  *
3081  * NOTES
3082  *
3083  * Calls SetLastError()
3084  *
3085  */
3086 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
3087     LPVOID buffer, DWORD length)
3088 {
3089     DC *dc = get_dc_ptr(hdc);
3090     PHYSDEV dev;
3091     DWORD ret;
3092
3093     if(!dc) return GDI_ERROR;
3094
3095     dev = GET_DC_PHYSDEV( dc, pGetFontData );
3096     ret = dev->funcs->pGetFontData( dev, table, offset, buffer, length );
3097     release_dc_ptr( dc );
3098     return ret;
3099 }
3100
3101 /*************************************************************************
3102  * GetGlyphIndicesA [GDI32.@]
3103  */
3104 DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
3105                               LPWORD pgi, DWORD flags)
3106 {
3107     DWORD ret;
3108     WCHAR *lpstrW;
3109     INT countW;
3110
3111     TRACE("(%p, %s, %d, %p, 0x%x)\n",
3112           hdc, debugstr_an(lpstr, count), count, pgi, flags);
3113
3114     lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
3115     ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
3116     HeapFree(GetProcessHeap(), 0, lpstrW);
3117
3118     return ret;
3119 }
3120
3121 /*************************************************************************
3122  * GetGlyphIndicesW [GDI32.@]
3123  */
3124 DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
3125                               LPWORD pgi, DWORD flags)
3126 {
3127     DC *dc = get_dc_ptr(hdc);
3128     PHYSDEV dev;
3129     DWORD ret;
3130
3131     TRACE("(%p, %s, %d, %p, 0x%x)\n",
3132           hdc, debugstr_wn(lpstr, count), count, pgi, flags);
3133
3134     if(!dc) return GDI_ERROR;
3135
3136     dev = GET_DC_PHYSDEV( dc, pGetGlyphIndices );
3137     ret = dev->funcs->pGetGlyphIndices( dev, lpstr, count, pgi, flags );
3138     release_dc_ptr( dc );
3139     return ret;
3140 }
3141
3142 /*************************************************************************
3143  * GetCharacterPlacementA [GDI32.@]
3144  *
3145  * See GetCharacterPlacementW.
3146  *
3147  * NOTES:
3148  *  the web browser control of ie4 calls this with dwFlags=0
3149  */
3150 DWORD WINAPI
3151 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
3152                          INT nMaxExtent, GCP_RESULTSA *lpResults,
3153                          DWORD dwFlags)
3154 {
3155     WCHAR *lpStringW;
3156     INT uCountW;
3157     GCP_RESULTSW resultsW;
3158     DWORD ret;
3159     UINT font_cp;
3160
3161     TRACE("%s, %d, %d, 0x%08x\n",
3162           debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
3163
3164     /* both structs are equal in size */
3165     memcpy(&resultsW, lpResults, sizeof(resultsW));
3166
3167     lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
3168     if(lpResults->lpOutString)
3169         resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
3170
3171     ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
3172
3173     lpResults->nGlyphs = resultsW.nGlyphs;
3174     lpResults->nMaxFit = resultsW.nMaxFit;
3175
3176     if(lpResults->lpOutString) {
3177         WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
3178                             lpResults->lpOutString, uCount, NULL, NULL );
3179     }
3180
3181     HeapFree(GetProcessHeap(), 0, lpStringW);
3182     HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
3183
3184     return ret;
3185 }
3186
3187 /*************************************************************************
3188  * GetCharacterPlacementW [GDI32.@]
3189  *
3190  *   Retrieve information about a string. This includes the width, reordering,
3191  *   Glyphing and so on.
3192  *
3193  * RETURNS
3194  *
3195  *   The width and height of the string if successful, 0 if failed.
3196  *
3197  * BUGS
3198  *
3199  *   All flags except GCP_REORDER are not yet implemented.
3200  *   Reordering is not 100% compliant to the Windows BiDi method.
3201  *   Caret positioning is not yet implemented for BiDi.
3202  *   Classes are not yet implemented.
3203  *
3204  */
3205 DWORD WINAPI
3206 GetCharacterPlacementW(
3207                 HDC hdc,                /* [in] Device context for which the rendering is to be done */
3208                 LPCWSTR lpString,       /* [in] The string for which information is to be returned */
3209                 INT uCount,             /* [in] Number of WORDS in string. */
3210                 INT nMaxExtent,         /* [in] Maximum extent the string is to take (in HDC logical units) */
3211                 GCP_RESULTSW *lpResults,/* [in/out] A pointer to a GCP_RESULTSW struct */
3212                 DWORD dwFlags           /* [in] Flags specifying how to process the string */
3213                 )
3214 {
3215     DWORD ret=0;
3216     SIZE size;
3217     UINT i, nSet;
3218
3219     TRACE("%s, %d, %d, 0x%08x\n",
3220           debugstr_wn(lpString, uCount), uCount, nMaxExtent, dwFlags);
3221
3222     TRACE("lStructSize=%d, lpOutString=%p, lpOrder=%p, lpDx=%p, lpCaretPos=%p\n"
3223           "lpClass=%p, lpGlyphs=%p, nGlyphs=%u, nMaxFit=%d\n",
3224             lpResults->lStructSize, lpResults->lpOutString, lpResults->lpOrder,
3225             lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
3226             lpResults->lpGlyphs, lpResults->nGlyphs, lpResults->nMaxFit);
3227
3228     if(dwFlags&(~GCP_REORDER))                  FIXME("flags 0x%08x ignored\n", dwFlags);
3229     if(lpResults->lpClass)      FIXME("classes not implemented\n");
3230     if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER))
3231         FIXME("Caret positions for complex scripts not implemented\n");
3232
3233         nSet = (UINT)uCount;
3234         if(nSet > lpResults->nGlyphs)
3235                 nSet = lpResults->nGlyphs;
3236
3237         /* return number of initialized fields */
3238         lpResults->nGlyphs = nSet;
3239
3240         if((dwFlags&GCP_REORDER)==0 )
3241         {
3242                 /* Treat the case where no special handling was requested in a fastpath way */
3243                 /* copy will do if the GCP_REORDER flag is not set */
3244                 if(lpResults->lpOutString)
3245                     memcpy( lpResults->lpOutString, lpString, nSet * sizeof(WCHAR));
3246
3247                 if(lpResults->lpOrder)
3248                 {
3249                         for(i = 0; i < nSet; i++)
3250                                 lpResults->lpOrder[i] = i;
3251                 }
3252         } else
3253         {
3254             BIDI_Reorder(NULL, lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
3255                           nSet, lpResults->lpOrder, NULL, NULL );
3256         }
3257
3258         /* FIXME: Will use the placement chars */
3259         if (lpResults->lpDx)
3260         {
3261                 int c;
3262                 for (i = 0; i < nSet; i++)
3263                 {
3264                         if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
3265                                 lpResults->lpDx[i]= c;
3266                 }
3267         }
3268
3269     if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
3270     {
3271         int pos = 0;
3272
3273         lpResults->lpCaretPos[0] = 0;
3274         for (i = 1; i < nSet; i++)
3275             if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
3276                 lpResults->lpCaretPos[i] = (pos += size.cx);
3277     }
3278
3279     if(lpResults->lpGlyphs)
3280         GetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
3281
3282     if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
3283       ret = MAKELONG(size.cx, size.cy);
3284
3285     return ret;
3286 }
3287
3288 /*************************************************************************
3289  *      GetCharABCWidthsFloatA [GDI32.@]
3290  *
3291  * See GetCharABCWidthsFloatW.
3292  */
3293 BOOL WINAPI GetCharABCWidthsFloatA( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
3294 {
3295     INT i, wlen;
3296     LPSTR str;
3297     LPWSTR wstr;
3298     BOOL ret = TRUE;
3299
3300     str = FONT_GetCharsByRangeA(hdc, first, last, &i);
3301     if (str == NULL)
3302         return FALSE;
3303
3304     wstr = FONT_mbtowc( hdc, str, i, &wlen, NULL );
3305
3306     for (i = 0; i < wlen; i++)
3307     {
3308         if (!GetCharABCWidthsFloatW( hdc, wstr[i], wstr[i], abcf ))
3309         {
3310             ret = FALSE;
3311             break;
3312         }
3313         abcf++;
3314     }
3315
3316     HeapFree( GetProcessHeap(), 0, str );
3317     HeapFree( GetProcessHeap(), 0, wstr );
3318
3319     return ret;
3320 }
3321
3322 /*************************************************************************
3323  *      GetCharABCWidthsFloatW [GDI32.@]
3324  *
3325  * Retrieves widths of a range of characters.
3326  *
3327  * PARAMS
3328  *    hdc   [I] Handle to device context.
3329  *    first [I] First character in range to query.
3330  *    last  [I] Last character in range to query.
3331  *    abcf  [O] Array of LPABCFLOAT structures.
3332  *
3333  * RETURNS
3334  *    Success: TRUE
3335  *    Failure: FALSE
3336  */
3337 BOOL WINAPI GetCharABCWidthsFloatW( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
3338 {
3339     UINT i;
3340     ABC *abc;
3341     PHYSDEV dev;
3342     BOOL ret = FALSE;
3343     DC *dc = get_dc_ptr( hdc );
3344
3345     TRACE("%p, %d, %d, %p\n", hdc, first, last, abcf);
3346
3347     if (!dc) return FALSE;
3348
3349     if (!abcf) goto done;
3350     if (!(abc = HeapAlloc( GetProcessHeap(), 0, (last - first + 1) * sizeof(*abc) ))) goto done;
3351
3352     dev = GET_DC_PHYSDEV( dc, pGetCharABCWidths );
3353     ret = dev->funcs->pGetCharABCWidths( dev, first, last, abc );
3354     if (ret)
3355     {
3356         /* convert device units to logical */
3357         for (i = first; i <= last; i++, abcf++)
3358         {
3359             abcf->abcfA = abc[i - first].abcA * dc->xformVport2World.eM11;
3360             abcf->abcfB = abc[i - first].abcB * dc->xformVport2World.eM11;
3361             abcf->abcfC = abc[i - first].abcC * dc->xformVport2World.eM11;
3362         }
3363     }
3364     HeapFree( GetProcessHeap(), 0, abc );
3365
3366 done:
3367     release_dc_ptr( dc );
3368     return ret;
3369 }
3370
3371 /*************************************************************************
3372  *      GetCharWidthFloatA [GDI32.@]
3373  */
3374 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
3375                                     UINT iLastChar, PFLOAT pxBuffer)
3376 {
3377     FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
3378     return 0;
3379 }
3380
3381 /*************************************************************************
3382  *      GetCharWidthFloatW [GDI32.@]
3383  */
3384 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
3385                                     UINT iLastChar, PFLOAT pxBuffer)
3386 {
3387     FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
3388     return 0;
3389 }
3390
3391
3392 /***********************************************************************
3393  *                                                                     *
3394  *           Font Resource API                                         *
3395  *                                                                     *
3396  ***********************************************************************/
3397
3398 /***********************************************************************
3399  *           AddFontResourceA    (GDI32.@)
3400  */
3401 INT WINAPI AddFontResourceA( LPCSTR str )
3402 {
3403     return AddFontResourceExA( str, 0, NULL);
3404 }
3405
3406 /***********************************************************************
3407  *           AddFontResourceW    (GDI32.@)
3408  */
3409 INT WINAPI AddFontResourceW( LPCWSTR str )
3410 {
3411     return AddFontResourceExW(str, 0, NULL);
3412 }
3413
3414
3415 /***********************************************************************
3416  *           AddFontResourceExA    (GDI32.@)
3417  */
3418 INT WINAPI AddFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3419 {
3420     DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3421     LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3422     INT ret;
3423
3424     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3425     ret = AddFontResourceExW(strW, fl, pdv);
3426     HeapFree(GetProcessHeap(), 0, strW);
3427     return ret;
3428 }
3429
3430 static BOOL CALLBACK load_enumed_resource(HMODULE hModule, LPCWSTR type, LPWSTR name, LONG_PTR lParam)
3431 {
3432     HRSRC rsrc = FindResourceW(hModule, name, type);
3433     HGLOBAL hMem = LoadResource(hModule, rsrc);
3434     LPVOID *pMem = LockResource(hMem);
3435     int *num_total = (int *)lParam;
3436     DWORD num_in_res;
3437
3438     TRACE("Found resource %s - trying to load\n", wine_dbgstr_w(type));
3439     if (!AddFontMemResourceEx(pMem, SizeofResource(hModule, rsrc), NULL, &num_in_res))
3440     {
3441         ERR("Failed to load PE font resource mod=%p ptr=%p\n", hModule, hMem);
3442         return FALSE;
3443     }
3444
3445     *num_total += num_in_res;
3446     return TRUE;
3447 }
3448
3449 static void *map_file( const WCHAR *filename, LARGE_INTEGER *size )
3450 {
3451     HANDLE file, mapping;
3452     void *ptr;
3453
3454     file = CreateFileW( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
3455     if (file == INVALID_HANDLE_VALUE) return NULL;
3456
3457     if (!GetFileSizeEx( file, size ) || size->u.HighPart)
3458     {
3459         CloseHandle( file );
3460         return NULL;
3461     }
3462
3463     mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, 0, NULL );
3464     CloseHandle( file );
3465     if (!mapping) return NULL;
3466
3467     ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
3468     CloseHandle( mapping );
3469
3470     return ptr;
3471 }
3472
3473 static WCHAR *get_scalable_filename( const WCHAR *res )
3474 {
3475     LARGE_INTEGER size;
3476     BYTE *ptr = map_file( res, &size );
3477     const IMAGE_DOS_HEADER *dos;
3478     const IMAGE_OS2_HEADER *ne;
3479     WCHAR *name = NULL;
3480     WORD rsrc_off, align, type_id, count;
3481     DWORD res_off, res_len, i;
3482     int len;
3483
3484     if (!ptr) return NULL;
3485
3486     if (size.u.LowPart < sizeof( *dos )) goto fail;
3487     dos = (const IMAGE_DOS_HEADER *)ptr;
3488     if (dos->e_magic != IMAGE_DOS_SIGNATURE) goto fail;
3489     if (size.u.LowPart < dos->e_lfanew + sizeof( *ne )) goto fail;
3490     ne = (const IMAGE_OS2_HEADER *)(ptr + dos->e_lfanew);
3491     rsrc_off = dos->e_lfanew + ne->ne_rsrctab;
3492     if (size.u.LowPart < rsrc_off + 10) goto fail;
3493     align = *(WORD *)(ptr + rsrc_off);
3494     rsrc_off += 2;
3495     type_id = *(WORD *)(ptr + rsrc_off);
3496     while (type_id && type_id != 0x80cc)
3497     {
3498         count = *(WORD *)(ptr + rsrc_off + 2);
3499         rsrc_off += 8 + count * 12;
3500         if (size.u.LowPart < rsrc_off + 8) goto fail;
3501         type_id = *(WORD *)(ptr + rsrc_off);
3502     }
3503     if (!type_id) goto fail;
3504     count = *(WORD *)(ptr + rsrc_off + 2);
3505     if (size.u.LowPart < rsrc_off + 8 + count * 12) goto fail;
3506
3507     res_off = *(WORD *)(ptr + rsrc_off + 8) << align;
3508     res_len = *(WORD *)(ptr + rsrc_off + 10) << align;
3509     if (size.u.LowPart < res_off + res_len) goto fail;
3510
3511     for (i = 0; i < res_len; i++)
3512         if (ptr[ res_off + i ] == 0) break;
3513     if (i == res_len) goto fail;
3514
3515     len = MultiByteToWideChar( CP_ACP, 0, (char *)ptr + res_off, -1, NULL, 0 );
3516     name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3517     if (name) MultiByteToWideChar( CP_ACP, 0, (char *)ptr + res_off, -1, name, len );
3518
3519 fail:
3520     UnmapViewOfFile( ptr );
3521     return name;
3522 }
3523
3524 /***********************************************************************
3525  *           AddFontResourceExW    (GDI32.@)
3526  */
3527 INT WINAPI AddFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3528 {
3529     int ret = WineEngAddFontResourceEx(str, fl, pdv);
3530     WCHAR *filename;
3531
3532     if (ret == 0)
3533     {
3534         /* FreeType <2.3.5 has problems reading resources wrapped in PE files. */
3535         HMODULE hModule = LoadLibraryExW(str, NULL, LOAD_LIBRARY_AS_DATAFILE);
3536         if (hModule != NULL)
3537         {
3538             int num_resources = 0;
3539             LPWSTR rt_font = (LPWSTR)((ULONG_PTR)8);  /* we don't want to include winuser.h */
3540
3541             TRACE("WineEngAddFontResourceEx failed on PE file %s - trying to load resources manually\n",
3542                 wine_dbgstr_w(str));
3543             if (EnumResourceNamesW(hModule, rt_font, load_enumed_resource, (LONG_PTR)&num_resources))
3544                 ret = num_resources;
3545             FreeLibrary(hModule);
3546         }
3547         else if ((filename = get_scalable_filename( str )) != NULL)
3548         {
3549             ret = WineEngAddFontResourceEx( filename, fl, pdv );
3550             HeapFree( GetProcessHeap(), 0, filename );
3551         }
3552     }
3553     return ret;
3554 }
3555
3556 /***********************************************************************
3557  *           RemoveFontResourceA    (GDI32.@)
3558  */
3559 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
3560 {
3561     return RemoveFontResourceExA(str, 0, 0);
3562 }
3563
3564 /***********************************************************************
3565  *           RemoveFontResourceW    (GDI32.@)
3566  */
3567 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
3568 {
3569     return RemoveFontResourceExW(str, 0, 0);
3570 }
3571
3572 /***********************************************************************
3573  *           AddFontMemResourceEx    (GDI32.@)
3574  */
3575 HANDLE WINAPI AddFontMemResourceEx( PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
3576 {
3577     HANDLE ret;
3578     DWORD num_fonts;
3579
3580     if (!pbFont || !cbFont || !pcFonts)
3581     {
3582         SetLastError(ERROR_INVALID_PARAMETER);
3583         return NULL;
3584     }
3585
3586     ret = WineEngAddFontMemResourceEx(pbFont, cbFont, pdv, &num_fonts);
3587     if (ret)
3588     {
3589         __TRY
3590         {
3591             *pcFonts = num_fonts;
3592         }
3593         __EXCEPT_PAGE_FAULT
3594         {
3595             WARN("page fault while writing to *pcFonts (%p)\n", pcFonts);
3596             RemoveFontMemResourceEx(ret);
3597             ret = 0;
3598         }
3599         __ENDTRY
3600     }
3601     return ret;
3602 }
3603
3604 /***********************************************************************
3605  *           RemoveFontMemResourceEx    (GDI32.@)
3606  */
3607 BOOL WINAPI RemoveFontMemResourceEx( HANDLE fh )
3608 {
3609     FIXME("(%p) stub\n", fh);
3610     return TRUE;
3611 }
3612
3613 /***********************************************************************
3614  *           RemoveFontResourceExA    (GDI32.@)
3615  */
3616 BOOL WINAPI RemoveFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3617 {
3618     DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3619     LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3620     INT ret;
3621
3622     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3623     ret = RemoveFontResourceExW(strW, fl, pdv);
3624     HeapFree(GetProcessHeap(), 0, strW);
3625     return ret;
3626 }
3627
3628 /***********************************************************************
3629  *           RemoveFontResourceExW    (GDI32.@)
3630  */
3631 BOOL WINAPI RemoveFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3632 {
3633     return WineEngRemoveFontResourceEx(str, fl, pdv);
3634 }
3635
3636 /***********************************************************************
3637  *           GetTextCharset    (GDI32.@)
3638  */
3639 UINT WINAPI GetTextCharset(HDC hdc)
3640 {
3641     /* MSDN docs say this is equivalent */
3642     return GetTextCharsetInfo(hdc, NULL, 0);
3643 }
3644
3645 /***********************************************************************
3646  *           GetTextCharsetInfo    (GDI32.@)
3647  */
3648 UINT WINAPI GetTextCharsetInfo(HDC hdc, LPFONTSIGNATURE fs, DWORD flags)
3649 {
3650     UINT ret = DEFAULT_CHARSET;
3651     DC *dc = get_dc_ptr(hdc);
3652     PHYSDEV dev;
3653
3654     if (dc)
3655     {
3656         dev = GET_DC_PHYSDEV( dc, pGetTextCharsetInfo );
3657         ret = dev->funcs->pGetTextCharsetInfo( dev, fs, flags );
3658         release_dc_ptr( dc );
3659     }
3660
3661     if (ret == DEFAULT_CHARSET && fs)
3662         memset(fs, 0, sizeof(FONTSIGNATURE));
3663     return ret;
3664 }
3665
3666 /***********************************************************************
3667  *           GdiGetCharDimensions    (GDI32.@)
3668  *
3669  * Gets the average width of the characters in the English alphabet.
3670  *
3671  * PARAMS
3672  *  hdc    [I] Handle to the device context to measure on.
3673  *  lptm   [O] Pointer to memory to store the text metrics into.
3674  *  height [O] On exit, the maximum height of characters in the English alphabet.
3675  *
3676  * RETURNS
3677  *  The average width of characters in the English alphabet.
3678  *
3679  * NOTES
3680  *  This function is used by the dialog manager to get the size of a dialog
3681  *  unit. It should also be used by other pieces of code that need to know
3682  *  the size of a dialog unit in logical units without having access to the
3683  *  window handle of the dialog.
3684  *  Windows caches the font metrics from this function, but we don't and
3685  *  there doesn't appear to be an immediate advantage to do so.
3686  *
3687  * SEE ALSO
3688  *  GetTextExtentPointW, GetTextMetricsW, MapDialogRect.
3689  */
3690 LONG WINAPI GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height)
3691 {
3692     SIZE sz;
3693     static const WCHAR alphabet[] = {
3694         'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
3695         'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
3696         'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
3697
3698     if(lptm && !GetTextMetricsW(hdc, lptm)) return 0;
3699
3700     if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
3701
3702     if (height) *height = sz.cy;
3703     return (sz.cx / 26 + 1) / 2;
3704 }
3705
3706 BOOL WINAPI EnableEUDC(BOOL fEnableEUDC)
3707 {
3708     FIXME("(%d): stub\n", fEnableEUDC);
3709     return FALSE;
3710 }
3711
3712 /***********************************************************************
3713  *           GetCharWidthI    (GDI32.@)
3714  *
3715  * Retrieve widths of characters.
3716  *
3717  * PARAMS
3718  *  hdc    [I] Handle to a device context.
3719  *  first  [I] First glyph in range to query.
3720  *  count  [I] Number of glyph indices to query.
3721  *  glyphs [I] Array of glyphs to query.
3722  *  buffer [O] Buffer to receive character widths.
3723  *
3724  * NOTES
3725  *  Only works with TrueType fonts.
3726  *
3727  * RETURNS
3728  *  Success: TRUE
3729  *  Failure: FALSE
3730  */
3731 BOOL WINAPI GetCharWidthI(HDC hdc, UINT first, UINT count, LPWORD glyphs, LPINT buffer)
3732 {
3733     ABC *abc;
3734     unsigned int i;
3735
3736     TRACE("(%p, %d, %d, %p, %p)\n", hdc, first, count, glyphs, buffer);
3737
3738     if (!(abc = HeapAlloc(GetProcessHeap(), 0, count * sizeof(ABC))))
3739         return FALSE;
3740
3741     if (!GetCharABCWidthsI(hdc, first, count, glyphs, abc))
3742     {
3743         HeapFree(GetProcessHeap(), 0, abc);
3744         return FALSE;
3745     }
3746
3747     for (i = 0; i < count; i++)
3748         buffer[i] = abc->abcA + abc->abcB + abc->abcC;
3749
3750     HeapFree(GetProcessHeap(), 0, abc);
3751     return TRUE;
3752 }
3753
3754 /***********************************************************************
3755  *           GetFontUnicodeRanges    (GDI32.@)
3756  *
3757  *  Retrieve a list of supported Unicode characters in a font.
3758  *
3759  *  PARAMS
3760  *   hdc  [I] Handle to a device context.
3761  *   lpgs [O] GLYPHSET structure specifying supported character ranges.
3762  *
3763  *  RETURNS
3764  *   Success: Number of bytes written to the buffer pointed to by lpgs.
3765  *   Failure: 0
3766  *
3767  */
3768 DWORD WINAPI GetFontUnicodeRanges(HDC hdc, LPGLYPHSET lpgs)
3769 {
3770     DWORD ret;
3771     PHYSDEV dev;
3772     DC *dc = get_dc_ptr(hdc);
3773
3774     TRACE("(%p, %p)\n", hdc, lpgs);
3775
3776     if (!dc) return 0;
3777
3778     dev = GET_DC_PHYSDEV( dc, pGetFontUnicodeRanges );
3779     ret = dev->funcs->pGetFontUnicodeRanges( dev, lpgs );
3780     release_dc_ptr(dc);
3781     return ret;
3782 }
3783
3784
3785 /*************************************************************
3786  *           FontIsLinked    (GDI32.@)
3787  */
3788 BOOL WINAPI FontIsLinked(HDC hdc)
3789 {
3790     DC *dc = get_dc_ptr(hdc);
3791     PHYSDEV dev;
3792     BOOL ret;
3793
3794     if (!dc) return FALSE;
3795     dev = GET_DC_PHYSDEV( dc, pFontIsLinked );
3796     ret = dev->funcs->pFontIsLinked( dev );
3797     release_dc_ptr(dc);
3798     TRACE("returning %d\n", ret);
3799     return ret;
3800 }
3801
3802 /*************************************************************
3803  *           GdiRealizationInfo    (GDI32.@)
3804  *
3805  * Returns a structure that contains some font information.
3806  */
3807 BOOL WINAPI GdiRealizationInfo(HDC hdc, realization_info_t *info)
3808 {
3809     DC *dc = get_dc_ptr(hdc);
3810     PHYSDEV dev;
3811     BOOL ret;
3812
3813     if (!dc) return FALSE;
3814     dev = GET_DC_PHYSDEV( dc, pGdiRealizationInfo );
3815     ret = dev->funcs->pGdiRealizationInfo( dev, info );
3816     release_dc_ptr(dc);
3817     return ret;
3818 }