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     GDIOBJHDR   header;
 114     LOGFONTW    logfont;
 115 } FONTOBJ;
 116
 117 struct font_enum
 118 {
 119   LPLOGFONTW          lpLogFontParam;
 120   FONTENUMPROCW       lpEnumFunc;
 121   LPARAM              lpData;
 122   BOOL                unicode;
 123   HDC                 hdc;
 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->header, 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     }
 725     return ret;
 726 }
 727
 728 /***********************************************************************
 729  *              FONT_EnumFontFamiliesEx
 730  */
 731 static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf, FONTENUMPROCW efproc,
 732                                     LPARAM lParam, BOOL unicode )
 733 {
 734     INT ret = 0;
 735     DC *dc = get_dc_ptr( hDC );
 736     struct font_enum fe;
 737
 738     if (dc)
 739     {
 740         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pEnumFonts );
 741
 742         if (plf) TRACE("lfFaceName = %s lfCharset = %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
 743         fe.lpLogFontParam = plf;
 744         fe.lpEnumFunc = efproc;
 745         fe.lpData = lParam;
 746         fe.unicode = unicode;
 747         fe.hdc = hDC;
 748         ret = physdev->funcs->pEnumFonts( physdev, plf, FONT_EnumInstance, (LPARAM)&fe );
 749         release_dc_ptr( dc );
 750     }
 751     return ret;
 752 }
 753
 754 /***********************************************************************
 755  *              EnumFontFamiliesExW     (GDI32.@)
 756  */
 757 INT WINAPI EnumFontFamiliesExW( HDC hDC, LPLOGFONTW plf,
 758                                     FONTENUMPROCW efproc,
 759                                     LPARAM lParam, DWORD dwFlags )
 760 {
 761     return FONT_EnumFontFamiliesEx( hDC, plf, efproc, lParam, TRUE );
 762 }
 763
 764 /***********************************************************************
 765  *              EnumFontFamiliesExA     (GDI32.@)
 766  */
 767 INT WINAPI EnumFontFamiliesExA( HDC hDC, LPLOGFONTA plf,
 768                                     FONTENUMPROCA efproc,
 769                                     LPARAM lParam, DWORD dwFlags)
 770 {
 771     LOGFONTW lfW, *plfW;
 772
 773     if (plf)
 774     {
 775         FONT_LogFontAToW( plf, &lfW );
 776         plfW = &lfW;
 777     }
 778     else plfW = NULL;
 779
 780     return FONT_EnumFontFamiliesEx( hDC, plfW, (FONTENUMPROCW)efproc, lParam, FALSE );
 781 }
 782
 783 /***********************************************************************
 784  *              EnumFontFamiliesA       (GDI32.@)
 785  */
 786 INT WINAPI EnumFontFamiliesA( HDC hDC, LPCSTR lpFamily,
 787                                   FONTENUMPROCA efproc, LPARAM lpData )
 788 {
 789     LOGFONTA lf, *plf;
 790
 791     if (lpFamily)
 792     {
 793         if (!*lpFamily) return 1;
 794         lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
 795         lf.lfCharSet = DEFAULT_CHARSET;
 796         lf.lfPitchAndFamily = 0;
 797         plf = &lf;
 798     }
 799     else plf = NULL;
 800
 801     return EnumFontFamiliesExA( hDC, plf, efproc, lpData, 0 );
 802 }
 803
 804 /***********************************************************************
 805  *              EnumFontFamiliesW       (GDI32.@)
 806  */
 807 INT WINAPI EnumFontFamiliesW( HDC hDC, LPCWSTR lpFamily,
 808                                   FONTENUMPROCW efproc, LPARAM lpData )
 809 {
 810     LOGFONTW lf, *plf;
 811
 812     if (lpFamily)
 813     {
 814         if (!*lpFamily) return 1;
 815         lstrcpynW( lf.lfFaceName, lpFamily, LF_FACESIZE );
 816         lf.lfCharSet = DEFAULT_CHARSET;
 817         lf.lfPitchAndFamily = 0;
 818         plf = &lf;
 819     }
 820     else plf = NULL;
 821
 822     return EnumFontFamiliesExW( hDC, plf, efproc, lpData, 0 );
 823 }
 824
 825 /***********************************************************************
 826  *              EnumFontsA              (GDI32.@)
 827  */
 828 INT WINAPI EnumFontsA( HDC hDC, LPCSTR lpName, FONTENUMPROCA efproc,
 829                            LPARAM lpData )
 830 {
 831     return EnumFontFamiliesA( hDC, lpName, efproc, lpData );
 832 }
 833
 834 /***********************************************************************
 835  *              EnumFontsW              (GDI32.@)
 836  */
 837 INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
 838                            LPARAM lpData )
 839 {
 840     return EnumFontFamiliesW( hDC, lpName, efproc, lpData );
 841 }
 842
 843
 844 /***********************************************************************
 845  *           GetTextCharacterExtra    (GDI32.@)
 846  */
 847 INT WINAPI GetTextCharacterExtra( HDC hdc )
 848 {
 849     INT ret;
 850     DC *dc = get_dc_ptr( hdc );
 851     if (!dc) return 0x80000000;
 852     ret = dc->charExtra;
 853     release_dc_ptr( dc );
 854     return ret;
 855 }
 856
 857
 858 /***********************************************************************
 859  *           SetTextCharacterExtra    (GDI32.@)
 860  */
 861 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
 862 {
 863     INT ret = 0x80000000;
 864     DC * dc = get_dc_ptr( hdc );
 865
 866     if (dc)
 867     {
 868         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextCharacterExtra );
 869         extra = physdev->funcs->pSetTextCharacterExtra( physdev, extra );
 870         if (extra != 0x80000000)
 871         {
 872             ret = dc->charExtra;
 873             dc->charExtra = extra;
 874         }
 875         release_dc_ptr( dc );
 876     }
 877     return ret;
 878 }
 879
 880
 881 /***********************************************************************
 882  *           SetTextJustification    (GDI32.@)
 883  */
 884 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
 885 {
 886     BOOL ret;
 887     PHYSDEV physdev;
 888     DC * dc = get_dc_ptr( hdc );
 889
 890     if (!dc) return FALSE;
 891
 892     physdev = GET_DC_PHYSDEV( dc, pSetTextJustification );
 893     ret = physdev->funcs->pSetTextJustification( physdev, extra, breaks );
 894     if (ret)
 895     {
 896         extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
 897         if (!extra) breaks = 0;
 898         if (breaks)
 899         {
 900             dc->breakExtra = extra / breaks;
 901             dc->breakRem   = extra - (breaks * dc->breakExtra);
 902         }
 903         else
 904         {
 905             dc->breakExtra = 0;
 906             dc->breakRem   = 0;
 907         }
 908     }
 909     release_dc_ptr( dc );
 910     return ret;
 911 }
 912
 913
 914 /***********************************************************************
 915  *           GetTextFaceA    (GDI32.@)
 916  */
 917 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
 918 {
 919     INT res = GetTextFaceW(hdc, 0, NULL);
 920     LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, res * 2 );
 921     GetTextFaceW( hdc, res, nameW );
 922
 923     if (name)
 924     {
 925         if (count)
 926         {
 927             res = WideCharToMultiByte(CP_ACP, 0, nameW, -1, name, count, NULL, NULL);
 928             if (res == 0)
 929                 res = count;
 930             name[count-1] = 0;
 931             /* GetTextFaceA does NOT include the nul byte in the return count.  */
 932             res--;
 933         }
 934         else
 935             res = 0;
 936     }
 937     else
 938         res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL);
 939     HeapFree( GetProcessHeap(), 0, nameW );
 940     return res;
 941 }
 942
 943 /***********************************************************************
 944  *           GetTextFaceW    (GDI32.@)
 945  */
 946 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
 947 {
 948     PHYSDEV dev;
 949     INT ret;
 950
 951     DC * dc = get_dc_ptr( hdc );
 952     if (!dc) return 0;
 953
 954     dev = GET_DC_PHYSDEV( dc, pGetTextFace );
 955     ret = dev->funcs->pGetTextFace( dev, count, name );
 956     release_dc_ptr( dc );
 957     return ret;
 958 }
 959
 960
 961 /***********************************************************************
 962  *           GetTextExtentPoint32A    (GDI32.@)
 963  *
 964  * See GetTextExtentPoint32W.
 965  */
 966 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
 967                                      LPSIZE size )
 968 {
 969     BOOL ret = FALSE;
 970     INT wlen;
 971     LPWSTR p;
 972
 973     if (count < 0) return FALSE;
 974
 975     p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
 976
 977     if (p)
 978     {
 979         ret = GetTextExtentPoint32W( hdc, p, wlen, size );
 980         HeapFree( GetProcessHeap(), 0, p );
 981     }
 982
 983     TRACE("(%p %s %d %p): returning %d x %d\n",
 984           hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
 985     return ret;
 986 }
 987
 988
 989 /***********************************************************************
 990  * GetTextExtentPoint32W [GDI32.@]
 991  *
 992  * Computes width/height for a string.
 993  *
 994  * Computes width and height of the specified string.
 995  *
 996  * RETURNS
 997  *    Success: TRUE
 998  *    Failure: FALSE
 999  */
1000 BOOL WINAPI GetTextExtentPoint32W(
1001     HDC hdc,     /* [in]  Handle of device context */
1002     LPCWSTR str,   /* [in]  Address of text string */
1003     INT count,   /* [in]  Number of characters in string */
1004     LPSIZE size) /* [out] Address of structure for string size */
1005 {
1006     return GetTextExtentExPointW(hdc, str, count, 0, NULL, NULL, size);
1007 }
1008
1009 /***********************************************************************
1010  * GetTextExtentExPointI [GDI32.@]
1011  *
1012  * Computes width and height of the array of glyph indices.
1013  *
1014  * PARAMS
1015  *    hdc     [I] Handle of device context.
1016  *    indices [I] Glyph index array.
1017  *    count   [I] Number of glyphs in array.
1018  *    max_ext [I] Maximum width in glyphs.
1019  *    nfit    [O] Maximum number of characters.
1020  *    dxs     [O] Partial string widths.
1021  *    size    [O] Returned string size.
1022  *
1023  * RETURNS
1024  *    Success: TRUE
1025  *    Failure: FALSE
1026  */
1027 BOOL WINAPI GetTextExtentExPointI( HDC hdc, const WORD *indices, INT count, INT max_ext,
1028                                    LPINT nfit, LPINT dxs, LPSIZE size )
1029 {
1030     PHYSDEV dev;
1031     BOOL ret;
1032     DC *dc;
1033
1034     if (count < 0) return FALSE;
1035
1036     dc = get_dc_ptr( hdc );
1037     if (!dc) return FALSE;
1038
1039     dev = GET_DC_PHYSDEV( dc, pGetTextExtentExPointI );
1040     ret = dev->funcs->pGetTextExtentExPointI( dev, indices, count, max_ext, nfit, dxs, size );
1041     size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1042     size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1043     size->cx += count * dc->charExtra;
1044     release_dc_ptr( dc );
1045
1046     TRACE("(%p %p %d %p): returning %d x %d\n",
1047           hdc, indices, count, size, size->cx, size->cy );
1048     return ret;
1049 }
1050
1051 /***********************************************************************
1052  * GetTextExtentPointI [GDI32.@]
1053  *
1054  * Computes width and height of the array of glyph indices.
1055  *
1056  * PARAMS
1057  *    hdc     [I] Handle of device context.
1058  *    indices [I] Glyph index array.
1059  *    count   [I] Number of glyphs in array.
1060  *    size    [O] Returned string size.
1061  *
1062  * RETURNS
1063  *    Success: TRUE
1064  *    Failure: FALSE
1065  */
1066 BOOL WINAPI GetTextExtentPointI( HDC hdc, const WORD *indices, INT count, LPSIZE size )
1067 {
1068     return GetTextExtentExPointI( hdc, indices, count, 0, NULL, NULL, size );
1069 }
1070
1071
1072 /***********************************************************************
1073  *           GetTextExtentPointA    (GDI32.@)
1074  */
1075 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
1076                                           LPSIZE size )
1077 {
1078     TRACE("not bug compatible.\n");
1079     return GetTextExtentPoint32A( hdc, str, count, size );
1080 }
1081
1082 /***********************************************************************
1083  *           GetTextExtentPointW   (GDI32.@)
1084  */
1085 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
1086                                           LPSIZE size )
1087 {
1088     TRACE("not bug compatible.\n");
1089     return GetTextExtentPoint32W( hdc, str, count, size );
1090 }
1091
1092
1093 /***********************************************************************
1094  *           GetTextExtentExPointA    (GDI32.@)
1095  */
1096 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
1097                                    INT maxExt, LPINT lpnFit,
1098                                    LPINT alpDx, LPSIZE size )
1099 {
1100     BOOL ret;
1101     INT wlen;
1102     INT *walpDx = NULL;
1103     LPWSTR p = NULL;
1104
1105     if (count < 0) return FALSE;
1106
1107     if (alpDx)
1108     {
1109         walpDx = HeapAlloc( GetProcessHeap(), 0, count * sizeof(INT) );
1110         if (!walpDx) return FALSE;
1111     }
1112
1113     p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1114     ret = GetTextExtentExPointW( hdc, p, wlen, maxExt, lpnFit, walpDx, size);
1115     if (walpDx)
1116     {
1117         INT n = lpnFit ? *lpnFit : wlen;
1118         INT i, j;
1119         for(i = 0, j = 0; i < n; i++, j++)
1120         {
1121             alpDx[j] = walpDx[i];
1122             if (IsDBCSLeadByte(str[j])) alpDx[++j] = walpDx[i];
1123         }
1124     }
1125     if (lpnFit) *lpnFit = WideCharToMultiByte(CP_ACP,0,p,*lpnFit,NULL,0,NULL,NULL);
1126     HeapFree( GetProcessHeap(), 0, p );
1127     HeapFree( GetProcessHeap(), 0, walpDx );
1128     return ret;
1129 }
1130
1131
1132 /***********************************************************************
1133  *           GetTextExtentExPointW    (GDI32.@)
1134  *
1135  * Return the size of the string as it would be if it was output properly by
1136  * e.g. TextOut.
1137  *
1138  * This should include
1139  * - Intercharacter spacing
1140  * - justification spacing (not yet done)
1141  * - kerning? see below
1142  *
1143  * Kerning.  Since kerning would be carried out by the rendering code it should
1144  * be done by the driver.  However they don't support it yet.  Also I am not
1145  * yet persuaded that (certainly under Win95) any kerning is actually done.
1146  *
1147  * str: According to MSDN this should be null-terminated.  That is not true; a
1148  *      null will not terminate it early.
1149  * size: Certainly under Win95 this appears buggy or weird if *lpnFit is less
1150  *       than count.  I have seen it be either the size of the full string or
1151  *       1 less than the size of the full string.  I have not seen it bear any
1152  *       resemblance to the portion that would fit.
1153  * lpnFit: What exactly is fitting?  Stupidly, in my opinion, it includes the
1154  *         trailing intercharacter spacing and any trailing justification.
1155  *
1156  * FIXME
1157  * Currently we do this by measuring each character etc.  We should do it by
1158  * passing the request to the driver, perhaps by extending the
1159  * pGetTextExtentPoint function to take the alpDx argument.  That would avoid
1160  * thinking about kerning issues and rounding issues in the justification.
1161  */
1162
1163 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
1164                                    INT maxExt, LPINT lpnFit,
1165                                    LPINT alpDx, LPSIZE size )
1166 {
1167     INT nFit = 0;
1168     LPINT dxs = NULL;
1169     DC *dc;
1170     BOOL ret = FALSE;
1171     TEXTMETRICW tm;
1172     PHYSDEV dev;
1173
1174     TRACE("(%p, %s, %d)\n",hdc,debugstr_wn(str,count),maxExt);
1175
1176     if (count < 0) return FALSE;
1177
1178     dc = get_dc_ptr(hdc);
1179     if (!dc) return FALSE;
1180
1181     GetTextMetricsW(hdc, &tm);
1182
1183     /* If we need to calculate nFit, then we need the partial extents even if
1184        the user hasn't provided us with an array.  */
1185     if (lpnFit)
1186     {
1187         dxs = alpDx ? alpDx : HeapAlloc(GetProcessHeap(), 0, count * sizeof alpDx[0]);
1188         if (! dxs)
1189         {
1190             release_dc_ptr(dc);
1191             SetLastError(ERROR_OUTOFMEMORY);
1192             return FALSE;
1193         }
1194     }
1195     else
1196         dxs = alpDx;
1197
1198     dev = GET_DC_PHYSDEV( dc, pGetTextExtentExPoint );
1199     ret = dev->funcs->pGetTextExtentExPoint(dev, str, count, 0, NULL, dxs, size);
1200
1201     /* Perform device size to world size transformations.  */
1202     if (ret)
1203     {
1204         INT extra      = dc->charExtra,
1205         breakExtra = dc->breakExtra,
1206         breakRem   = dc->breakRem,
1207         i;
1208
1209         if (dxs)
1210         {
1211             for (i = 0; i < count; ++i)
1212             {
1213                 dxs[i] = abs(INTERNAL_XDSTOWS(dc, dxs[i]));
1214                 dxs[i] += (i+1) * extra;
1215                 if (count > 1 && (breakExtra || breakRem) && str[i] == tm.tmBreakChar)
1216                 {
1217                     dxs[i] += breakExtra;
1218                     if (breakRem > 0)
1219                     {
1220                         breakRem--;
1221                         dxs[i]++;
1222                     }
1223                 }
1224                 if (dxs[i] <= maxExt)
1225                     ++nFit;
1226             }
1227             breakRem = dc->breakRem;
1228         }
1229         size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1230         size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1231
1232         if (!dxs && count > 1 && (breakExtra || breakRem))
1233         {
1234             for (i = 0; i < count; i++)
1235             {
1236                 if (str[i] == tm.tmBreakChar)
1237                 {
1238                     size->cx += breakExtra;
1239                     if (breakRem > 0)
1240                     {
1241                         breakRem--;
1242                         (size->cx)++;
1243                     }
1244                 }
1245             }
1246         }
1247     }
1248
1249     if (lpnFit)
1250         *lpnFit = nFit;
1251
1252     if (! alpDx)
1253         HeapFree(GetProcessHeap(), 0, dxs);
1254
1255     release_dc_ptr( dc );
1256
1257     TRACE("returning %d %d x %d\n",nFit,size->cx,size->cy);
1258     return ret;
1259 }
1260
1261 /***********************************************************************
1262  *           GetTextMetricsA    (GDI32.@)
1263  */
1264 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
1265 {
1266     TEXTMETRICW tm32;
1267
1268     if (!GetTextMetricsW( hdc, &tm32 )) return FALSE;
1269     FONT_TextMetricWToA( &tm32, metrics );
1270     return TRUE;
1271 }
1272
1273 /***********************************************************************
1274  *           GetTextMetricsW    (GDI32.@)
1275  */
1276 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1277 {
1278     PHYSDEV physdev;
1279     BOOL ret = FALSE;
1280     DC * dc = get_dc_ptr( hdc );
1281     if (!dc) return FALSE;
1282
1283     physdev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
1284     ret = physdev->funcs->pGetTextMetrics( physdev, metrics );
1285
1286     if (ret)
1287     {
1288     /* device layer returns values in device units
1289      * therefore we have to convert them to logical */
1290
1291         metrics->tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
1292         metrics->tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
1293
1294 #define WDPTOLP(x) ((x<0)?                                      \
1295                 (-abs(INTERNAL_XDSTOWS(dc, (x)))):              \
1296                 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1297 #define HDPTOLP(y) ((y<0)?                                      \
1298                 (-abs(INTERNAL_YDSTOWS(dc, (y)))):              \
1299                 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1300
1301         metrics->tmHeight           = HDPTOLP(metrics->tmHeight);
1302         metrics->tmAscent           = HDPTOLP(metrics->tmAscent);
1303         metrics->tmDescent          = HDPTOLP(metrics->tmDescent);
1304         metrics->tmInternalLeading  = HDPTOLP(metrics->tmInternalLeading);
1305         metrics->tmExternalLeading  = HDPTOLP(metrics->tmExternalLeading);
1306         metrics->tmAveCharWidth     = WDPTOLP(metrics->tmAveCharWidth);
1307         metrics->tmMaxCharWidth     = WDPTOLP(metrics->tmMaxCharWidth);
1308         metrics->tmOverhang         = WDPTOLP(metrics->tmOverhang);
1309         ret = TRUE;
1310 #undef WDPTOLP
1311 #undef HDPTOLP
1312     TRACE("text metrics:\n"
1313           "    Weight = %03i\t FirstChar = %i\t AveCharWidth = %i\n"
1314           "    Italic = % 3i\t LastChar = %i\t\t MaxCharWidth = %i\n"
1315           "    UnderLined = %01i\t DefaultChar = %i\t Overhang = %i\n"
1316           "    StruckOut = %01i\t BreakChar = %i\t CharSet = %i\n"
1317           "    PitchAndFamily = %02x\n"
1318           "    --------------------\n"
1319           "    InternalLeading = %i\n"
1320           "    Ascent = %i\n"
1321           "    Descent = %i\n"
1322           "    Height = %i\n",
1323           metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1324           metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1325           metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1326           metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1327           metrics->tmPitchAndFamily,
1328           metrics->tmInternalLeading,
1329           metrics->tmAscent,
1330           metrics->tmDescent,
1331           metrics->tmHeight );
1332     }
1333     release_dc_ptr( dc );
1334     return ret;
1335 }
1336
1337
1338 /***********************************************************************
1339  *              GetOutlineTextMetricsA (GDI32.@)
1340  * Gets metrics for TrueType fonts.
1341  *
1342  * NOTES
1343  *    If the supplied buffer isn't big enough Windows partially fills it up to
1344  *    its given length and returns that length.
1345  *
1346  * RETURNS
1347  *    Success: Non-zero or size of required buffer
1348  *    Failure: 0
1349  */
1350 UINT WINAPI GetOutlineTextMetricsA(
1351     HDC hdc,    /* [in]  Handle of device context */
1352     UINT cbData, /* [in]  Size of metric data array */
1353     LPOUTLINETEXTMETRICA lpOTM)  /* [out] Address of metric data array */
1354 {
1355     char buf[512], *ptr;
1356     UINT ret, needed;
1357     OUTLINETEXTMETRICW *lpOTMW = (OUTLINETEXTMETRICW *)buf;
1358     OUTLINETEXTMETRICA *output = lpOTM;
1359     INT left, len;
1360
1361     if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1362         return 0;
1363     if(ret > sizeof(buf))
1364         lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1365     GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1366
1367     needed = sizeof(OUTLINETEXTMETRICA);
1368     if(lpOTMW->otmpFamilyName)
1369         needed += WideCharToMultiByte(CP_ACP, 0,
1370            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1371                                       NULL, 0, NULL, NULL);
1372     if(lpOTMW->otmpFaceName)
1373         needed += WideCharToMultiByte(CP_ACP, 0,
1374            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1375                                       NULL, 0, NULL, NULL);
1376     if(lpOTMW->otmpStyleName)
1377         needed += WideCharToMultiByte(CP_ACP, 0,
1378            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1379                                       NULL, 0, NULL, NULL);
1380     if(lpOTMW->otmpFullName)
1381         needed += WideCharToMultiByte(CP_ACP, 0,
1382            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1383                                       NULL, 0, NULL, NULL);
1384
1385     if(!lpOTM) {
1386         ret = needed;
1387         goto end;
1388     }
1389
1390     TRACE("needed = %d\n", needed);
1391     if(needed > cbData)
1392         /* Since the supplied buffer isn't big enough, we'll alloc one
1393            that is and memcpy the first cbData bytes into the lpOTM at
1394            the end. */
1395         output = HeapAlloc(GetProcessHeap(), 0, needed);
1396
1397     ret = output->otmSize = min(needed, cbData);
1398     FONT_TextMetricWToA( &lpOTMW->otmTextMetrics, &output->otmTextMetrics );
1399     output->otmFiller = 0;
1400     output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1401     output->otmfsSelection = lpOTMW->otmfsSelection;
1402     output->otmfsType = lpOTMW->otmfsType;
1403     output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1404     output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1405     output->otmItalicAngle = lpOTMW->otmItalicAngle;
1406     output->otmEMSquare = lpOTMW->otmEMSquare;
1407     output->otmAscent = lpOTMW->otmAscent;
1408     output->otmDescent = lpOTMW->otmDescent;
1409     output->otmLineGap = lpOTMW->otmLineGap;
1410     output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1411     output->otmsXHeight = lpOTMW->otmsXHeight;
1412     output->otmrcFontBox = lpOTMW->otmrcFontBox;
1413     output->otmMacAscent = lpOTMW->otmMacAscent;
1414     output->otmMacDescent = lpOTMW->otmMacDescent;
1415     output->otmMacLineGap = lpOTMW->otmMacLineGap;
1416     output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1417     output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1418     output->otmptSubscriptOffset = lpOTMW->otmptSubscriptOffset;
1419     output->otmptSuperscriptSize = lpOTMW->otmptSuperscriptSize;
1420     output->otmptSuperscriptOffset = lpOTMW->otmptSuperscriptOffset;
1421     output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1422     output->otmsStrikeoutPosition = lpOTMW->otmsStrikeoutPosition;
1423     output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1424     output->otmsUnderscorePosition = lpOTMW->otmsUnderscorePosition;
1425
1426
1427     ptr = (char*)(output + 1);
1428     left = needed - sizeof(*output);
1429
1430     if(lpOTMW->otmpFamilyName) {
1431         output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1432         len = WideCharToMultiByte(CP_ACP, 0,
1433              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1434                                   ptr, left, NULL, NULL);
1435         left -= len;
1436         ptr += len;
1437     } else
1438         output->otmpFamilyName = 0;
1439
1440     if(lpOTMW->otmpFaceName) {
1441         output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1442         len = WideCharToMultiByte(CP_ACP, 0,
1443              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1444                                   ptr, left, NULL, NULL);
1445         left -= len;
1446         ptr += len;
1447     } else
1448         output->otmpFaceName = 0;
1449
1450     if(lpOTMW->otmpStyleName) {
1451         output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1452         len = WideCharToMultiByte(CP_ACP, 0,
1453              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1454                                   ptr, left, NULL, NULL);
1455         left -= len;
1456         ptr += len;
1457     } else
1458         output->otmpStyleName = 0;
1459
1460     if(lpOTMW->otmpFullName) {
1461         output->otmpFullName = (LPSTR)(ptr - (char*)output);
1462         len = WideCharToMultiByte(CP_ACP, 0,
1463              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1464                                   ptr, left, NULL, NULL);
1465         left -= len;
1466     } else
1467         output->otmpFullName = 0;
1468
1469     assert(left == 0);
1470
1471     if(output != lpOTM) {
1472         memcpy(lpOTM, output, cbData);
1473         HeapFree(GetProcessHeap(), 0, output);
1474
1475         /* check if the string offsets really fit into the provided size */
1476         /* FIXME: should we check string length as well? */
1477         /* make sure that we don't read/write beyond the provided buffer */
1478         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFamilyName) + sizeof(LPSTR))
1479         {
1480             if ((UINT_PTR)lpOTM->otmpFamilyName >= lpOTM->otmSize)
1481                 lpOTM->otmpFamilyName = 0; /* doesn't fit */
1482         }
1483
1484         /* make sure that we don't read/write beyond the provided buffer */
1485         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFaceName) + sizeof(LPSTR))
1486         {
1487             if ((UINT_PTR)lpOTM->otmpFaceName >= lpOTM->otmSize)
1488                 lpOTM->otmpFaceName = 0; /* doesn't fit */
1489         }
1490
1491             /* make sure that we don't read/write beyond the provided buffer */
1492         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpStyleName) + sizeof(LPSTR))
1493         {
1494             if ((UINT_PTR)lpOTM->otmpStyleName >= lpOTM->otmSize)
1495                 lpOTM->otmpStyleName = 0; /* doesn't fit */
1496         }
1497
1498         /* make sure that we don't read/write beyond the provided buffer */
1499         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFullName) + sizeof(LPSTR))
1500         {
1501             if ((UINT_PTR)lpOTM->otmpFullName >= lpOTM->otmSize)
1502                 lpOTM->otmpFullName = 0; /* doesn't fit */
1503         }
1504     }
1505
1506 end:
1507     if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1508         HeapFree(GetProcessHeap(), 0, lpOTMW);
1509
1510     return ret;
1511 }
1512
1513
1514 /***********************************************************************
1515  *           GetOutlineTextMetricsW [GDI32.@]
1516  */
1517 UINT WINAPI GetOutlineTextMetricsW(
1518     HDC hdc,    /* [in]  Handle of device context */
1519     UINT cbData, /* [in]  Size of metric data array */
1520     LPOUTLINETEXTMETRICW lpOTM)  /* [out] Address of metric data array */
1521 {
1522     DC *dc = get_dc_ptr( hdc );
1523     OUTLINETEXTMETRICW *output = lpOTM;
1524     PHYSDEV dev;
1525     UINT ret;
1526
1527     TRACE("(%p,%d,%p)\n", hdc, cbData, lpOTM);
1528     if(!dc) return 0;
1529
1530     dev = GET_DC_PHYSDEV( dc, pGetOutlineTextMetrics );
1531     ret = dev->funcs->pGetOutlineTextMetrics( dev, cbData, output );
1532
1533     if (lpOTM && ret > cbData)
1534     {
1535         output = HeapAlloc(GetProcessHeap(), 0, ret);
1536         ret = dev->funcs->pGetOutlineTextMetrics( dev, ret, output );
1537     }
1538
1539     if (lpOTM && ret)
1540     {
1541         output->otmTextMetrics.tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
1542         output->otmTextMetrics.tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
1543
1544 #define WDPTOLP(x) ((x<0)?                                      \
1545                 (-abs(INTERNAL_XDSTOWS(dc, (x)))):              \
1546                 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1547 #define HDPTOLP(y) ((y<0)?                                      \
1548                 (-abs(INTERNAL_YDSTOWS(dc, (y)))):              \
1549                 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1550
1551         output->otmTextMetrics.tmHeight           = HDPTOLP(output->otmTextMetrics.tmHeight);
1552         output->otmTextMetrics.tmAscent           = HDPTOLP(output->otmTextMetrics.tmAscent);
1553         output->otmTextMetrics.tmDescent          = HDPTOLP(output->otmTextMetrics.tmDescent);
1554         output->otmTextMetrics.tmInternalLeading  = HDPTOLP(output->otmTextMetrics.tmInternalLeading);
1555         output->otmTextMetrics.tmExternalLeading  = HDPTOLP(output->otmTextMetrics.tmExternalLeading);
1556         output->otmTextMetrics.tmAveCharWidth     = WDPTOLP(output->otmTextMetrics.tmAveCharWidth);
1557         output->otmTextMetrics.tmMaxCharWidth     = WDPTOLP(output->otmTextMetrics.tmMaxCharWidth);
1558         output->otmTextMetrics.tmOverhang         = WDPTOLP(output->otmTextMetrics.tmOverhang);
1559         output->otmAscent = HDPTOLP(output->otmAscent);
1560         output->otmDescent = HDPTOLP(output->otmDescent);
1561         output->otmLineGap = abs(INTERNAL_YDSTOWS(dc,output->otmLineGap));
1562         output->otmsCapEmHeight = abs(INTERNAL_YDSTOWS(dc,output->otmsCapEmHeight));
1563         output->otmsXHeight = abs(INTERNAL_YDSTOWS(dc,output->otmsXHeight));
1564         output->otmrcFontBox.top = HDPTOLP(output->otmrcFontBox.top);
1565         output->otmrcFontBox.bottom = HDPTOLP(output->otmrcFontBox.bottom);
1566         output->otmrcFontBox.left = WDPTOLP(output->otmrcFontBox.left);
1567         output->otmrcFontBox.right = WDPTOLP(output->otmrcFontBox.right);
1568         output->otmMacAscent = HDPTOLP(output->otmMacAscent);
1569         output->otmMacDescent = HDPTOLP(output->otmMacDescent);
1570         output->otmMacLineGap = abs(INTERNAL_YDSTOWS(dc,output->otmMacLineGap));
1571         output->otmptSubscriptSize.x = WDPTOLP(output->otmptSubscriptSize.x);
1572         output->otmptSubscriptSize.y = HDPTOLP(output->otmptSubscriptSize.y);
1573         output->otmptSubscriptOffset.x = WDPTOLP(output->otmptSubscriptOffset.x);
1574         output->otmptSubscriptOffset.y = HDPTOLP(output->otmptSubscriptOffset.y);
1575         output->otmptSuperscriptSize.x = WDPTOLP(output->otmptSuperscriptSize.x);
1576         output->otmptSuperscriptSize.y = HDPTOLP(output->otmptSuperscriptSize.y);
1577         output->otmptSuperscriptOffset.x = WDPTOLP(output->otmptSuperscriptOffset.x);
1578         output->otmptSuperscriptOffset.y = HDPTOLP(output->otmptSuperscriptOffset.y);
1579         output->otmsStrikeoutSize = abs(INTERNAL_YDSTOWS(dc,output->otmsStrikeoutSize));
1580         output->otmsStrikeoutPosition = HDPTOLP(output->otmsStrikeoutPosition);
1581         output->otmsUnderscoreSize = HDPTOLP(output->otmsUnderscoreSize);
1582         output->otmsUnderscorePosition = HDPTOLP(output->otmsUnderscorePosition);
1583 #undef WDPTOLP
1584 #undef HDPTOLP
1585         if(output != lpOTM)
1586         {
1587             memcpy(lpOTM, output, cbData);
1588             HeapFree(GetProcessHeap(), 0, output);
1589             ret = cbData;
1590         }
1591     }
1592     release_dc_ptr(dc);
1593     return ret;
1594 }
1595
1596 static LPSTR FONT_GetCharsByRangeA(HDC hdc, UINT firstChar, UINT lastChar, PINT pByteLen)
1597 {
1598     INT i, count = lastChar - firstChar + 1;
1599     UINT mbcp;
1600     UINT c;
1601     LPSTR str;
1602
1603     if (count <= 0)
1604         return NULL;
1605
1606     mbcp = GdiGetCodePage(hdc);
1607     switch (mbcp)
1608     {
1609     case 932:
1610     case 936:
1611     case 949:
1612     case 950:
1613     case 1361:
1614         if (lastChar > 0xffff)
1615             return NULL;
1616         if ((firstChar ^ lastChar) > 0xff)
1617             return NULL;
1618         break;
1619     default:
1620         if (lastChar > 0xff)
1621             return NULL;
1622         mbcp = 0;
1623         break;
1624     }
1625
1626     str = HeapAlloc(GetProcessHeap(), 0, count * 2 + 1);
1627     if (str == NULL)
1628         return NULL;
1629
1630     for(i = 0, c = firstChar; c <= lastChar; i++, c++)
1631     {
1632         if (mbcp) {
1633             if (c > 0xff)
1634                 str[i++] = (BYTE)(c >> 8);
1635             if (c <= 0xff && IsDBCSLeadByteEx(mbcp, c))
1636                 str[i] = 0x1f; /* FIXME: use default character */
1637             else
1638                 str[i] = (BYTE)c;
1639         }
1640         else
1641             str[i] = (BYTE)c;
1642     }
1643     str[i] = '\0';
1644
1645     *pByteLen = i;
1646
1647     return str;
1648 }
1649
1650 /***********************************************************************
1651  *           GetCharWidthW      (GDI32.@)
1652  *           GetCharWidth32W    (GDI32.@)
1653  */
1654 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1655                                LPINT buffer )
1656 {
1657     UINT i;
1658     BOOL ret;
1659     PHYSDEV dev;
1660     DC * dc = get_dc_ptr( hdc );
1661
1662     if (!dc) return FALSE;
1663
1664     dev = GET_DC_PHYSDEV( dc, pGetCharWidth );
1665     ret = dev->funcs->pGetCharWidth( dev, firstChar, lastChar, buffer );
1666
1667     if (ret)
1668     {
1669         /* convert device units to logical */
1670         for( i = firstChar; i <= lastChar; i++, buffer++ )
1671             *buffer = INTERNAL_XDSTOWS(dc, *buffer);
1672     }
1673     release_dc_ptr( dc );
1674     return ret;
1675 }
1676
1677
1678 /***********************************************************************
1679  *           GetCharWidthA      (GDI32.@)
1680  *           GetCharWidth32A    (GDI32.@)
1681  */
1682 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1683                                LPINT buffer )
1684 {
1685     INT i, wlen;
1686     LPSTR str;
1687     LPWSTR wstr;
1688     BOOL ret = TRUE;
1689
1690     str = FONT_GetCharsByRangeA(hdc, firstChar, lastChar, &i);
1691     if(str == NULL)
1692         return FALSE;
1693
1694     wstr = FONT_mbtowc(hdc, str, i, &wlen, NULL);
1695
1696     for(i = 0; i < wlen; i++)
1697     {
1698         if(!GetCharWidth32W(hdc, wstr[i], wstr[i], buffer))
1699         {
1700             ret = FALSE;
1701             break;
1702         }
1703         buffer++;
1704     }
1705
1706     HeapFree(GetProcessHeap(), 0, str);
1707     HeapFree(GetProcessHeap(), 0, wstr);
1708
1709     return ret;
1710 }
1711
1712
1713 /* helper for nulldrv_ExtTextOut */
1714 static DWORD get_glyph_bitmap( HDC hdc, UINT index, UINT aa_flags,
1715                                GLYPHMETRICS *metrics, struct gdi_image_bits *image )
1716 {
1717     UINT ggo_flags = aa_flags | GGO_GLYPH_INDEX;
1718     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
1719     UINT indices[3] = {0, 0, 0x20};
1720     int i;
1721     DWORD ret, size;
1722     int stride;
1723
1724     indices[0] = index;
1725
1726     for (i = 0; i < sizeof(indices) / sizeof(indices[0]); i++)
1727     {
1728         index = indices[i];
1729         ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, 0, NULL, &identity );
1730         if (ret != GDI_ERROR) break;
1731     }
1732
1733     if (ret == GDI_ERROR) return ERROR_NOT_FOUND;
1734     if (!image) return ERROR_SUCCESS;
1735
1736     image->ptr = NULL;
1737     image->free = NULL;
1738     if (!ret) return ERROR_SUCCESS; /* empty glyph */
1739
1740     stride = get_dib_stride( metrics->gmBlackBoxX, 1 );
1741     size = metrics->gmBlackBoxY * stride;
1742
1743     if (!(image->ptr = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_OUTOFMEMORY;
1744     image->is_copy = TRUE;
1745     image->free = free_heap_bits;
1746
1747     ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, size, image->ptr, &identity );
1748     if (ret == GDI_ERROR)
1749     {
1750         HeapFree( GetProcessHeap(), 0, image->ptr );
1751         return ERROR_NOT_FOUND;
1752     }
1753     return ERROR_SUCCESS;
1754 }
1755
1756 /* helper for nulldrv_ExtTextOut */
1757 static RECT get_total_extents( HDC hdc, INT x, INT y, UINT flags, UINT aa_flags,
1758                                LPCWSTR str, UINT count, const INT *dx )
1759 {
1760     int i;
1761     RECT rect;
1762
1763     rect.left = rect.top = INT_MAX;
1764     rect.right = rect.bottom = INT_MIN;
1765     for (i = 0; i < count; i++)
1766     {
1767         GLYPHMETRICS metrics;
1768
1769         if (get_glyph_bitmap( hdc, (UINT)str[i], aa_flags, &metrics, NULL )) continue;
1770
1771         rect.left = min( rect.left, x + metrics.gmptGlyphOrigin.x );
1772         rect.top = min( rect.top, y - metrics.gmptGlyphOrigin.y );
1773         rect.right = max( rect.right, x + metrics.gmptGlyphOrigin.x + (int)metrics.gmBlackBoxX );
1774         rect.bottom = max( rect.bottom, y - metrics.gmptGlyphOrigin.y + (int)metrics.gmBlackBoxY );
1775
1776         if (dx)
1777         {
1778             if (flags & ETO_PDY)
1779             {
1780                 x += dx[ i * 2 ];
1781                 y += dx[ i * 2 + 1];
1782             }
1783             else x += dx[ i ];
1784         }
1785         else
1786         {
1787             x += metrics.gmCellIncX;
1788             y += metrics.gmCellIncY;
1789         }
1790     }
1791     return rect;
1792 }
1793
1794 /* helper for nulldrv_ExtTextOut */
1795 static void draw_glyph( HDC hdc, INT origin_x, INT origin_y, const GLYPHMETRICS *metrics,
1796                         const struct gdi_image_bits *image, const RECT *clip )
1797 {
1798     static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
1799     UINT x, y, i, count;
1800     BYTE *ptr = image->ptr;
1801     int stride = get_dib_stride( metrics->gmBlackBoxX, 1 );
1802     POINT *pts;
1803     RECT rect, clipped_rect;
1804
1805     rect.left   = origin_x  + metrics->gmptGlyphOrigin.x;
1806     rect.top    = origin_y  - metrics->gmptGlyphOrigin.y;
1807     rect.right  = rect.left + metrics->gmBlackBoxX;
1808     rect.bottom = rect.top  + metrics->gmBlackBoxY;
1809     if (!clip) clipped_rect = rect;
1810     else if (!intersect_rect( &clipped_rect, &rect, clip )) return;
1811
1812     pts = HeapAlloc( GetProcessHeap(), 0,
1813                      max(2,metrics->gmBlackBoxX) * metrics->gmBlackBoxY * sizeof(*pts) );
1814     if (!pts) return;
1815
1816     count = 0;
1817     ptr += (clipped_rect.top - rect.top) * stride;
1818     for (y = clipped_rect.top; y < clipped_rect.bottom; y++, ptr += stride)
1819     {
1820         for (x = clipped_rect.left - rect.left; x < clipped_rect.right - rect.left; x++)
1821         {
1822             while (x < clipped_rect.right - rect.left && !(ptr[x / 8] & masks[x % 8])) x++;
1823             pts[count].x = rect.left + x;
1824             while (x < clipped_rect.right - rect.left && (ptr[x / 8] & masks[x % 8])) x++;
1825             pts[count + 1].x = rect.left + x;
1826             if (pts[count + 1].x > pts[count].x)
1827             {
1828                 pts[count].y = pts[count + 1].y = y;
1829                 count += 2;
1830             }
1831         }
1832     }
1833     DPtoLP( hdc, pts, count );
1834     for (i = 0; i < count; i += 2) Polyline( hdc, pts + i, 2 );
1835     HeapFree( GetProcessHeap(), 0, pts );
1836 }
1837
1838 /***********************************************************************
1839  *           nulldrv_ExtTextOut
1840  */
1841 BOOL nulldrv_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *rect,
1842                          LPCWSTR str, UINT count, const INT *dx )
1843 {
1844     DC *dc = get_nulldrv_dc( dev );
1845     UINT aa_flags, i;
1846     DWORD err;
1847     HGDIOBJ orig;
1848     HPEN pen;
1849
1850     if (flags & ETO_OPAQUE)
1851     {
1852         RECT rc = *rect;
1853         HBRUSH brush = CreateSolidBrush( GetNearestColor( dev->hdc, GetBkColor(dev->hdc) ));
1854
1855         if (brush)
1856         {
1857             orig = SelectObject( dev->hdc, brush );
1858             DPtoLP( dev->hdc, (POINT *)&rc, 2 );
1859             PatBlt( dev->hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY );
1860             SelectObject( dev->hdc, orig );
1861             DeleteObject( brush );
1862         }
1863     }
1864
1865     if (!count) return TRUE;
1866
1867     aa_flags = get_font_aa_flags( dev->hdc );
1868
1869     if (aa_flags != GGO_BITMAP)
1870     {
1871         char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1872         BITMAPINFO *info = (BITMAPINFO *)buffer;
1873         struct gdi_image_bits bits;
1874         struct bitblt_coords src, dst;
1875         PHYSDEV dst_dev;
1876
1877         dst_dev = GET_DC_PHYSDEV( dc, pPutImage );
1878         src.visrect = get_total_extents( dev->hdc, x, y, flags, aa_flags, str, count, dx );
1879         if (flags & ETO_CLIPPED) intersect_rect( &src.visrect, &src.visrect, rect );
1880         if (!clip_visrect( dc, &src.visrect, &src.visrect )) return TRUE;
1881
1882         /* FIXME: check for ETO_OPAQUE and avoid GetImage */
1883         src.x = src.visrect.left;
1884         src.y = src.visrect.top;
1885         src.width = src.visrect.right - src.visrect.left;
1886         src.height = src.visrect.bottom - src.visrect.top;
1887         dst = src;
1888         if ((flags & ETO_OPAQUE) && (src.visrect.left >= rect->left) && (src.visrect.top >= rect->top) &&
1889             (src.visrect.right <= rect->right) && (src.visrect.bottom <= rect->bottom))
1890         {
1891             /* we can avoid the GetImage, just query the needed format */
1892             memset( &info->bmiHeader, 0, sizeof(info->bmiHeader) );
1893             info->bmiHeader.biSize   = sizeof(info->bmiHeader);
1894             info->bmiHeader.biWidth  = src.width;
1895             info->bmiHeader.biHeight = -src.height;
1896             err = dst_dev->funcs->pPutImage( dst_dev, 0, 0, info, NULL, NULL, NULL, 0 );
1897             if (!err || err == ERROR_BAD_FORMAT)
1898             {
1899                 /* make the source rectangle relative to the source bits */
1900                 src.x = src.y = 0;
1901                 src.visrect.left = src.visrect.top = 0;
1902                 src.visrect.right = src.width;
1903                 src.visrect.bottom = src.height;
1904
1905                 bits.ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( info ));
1906                 if (!bits.ptr) return ERROR_OUTOFMEMORY;
1907                 bits.is_copy = TRUE;
1908                 bits.free = free_heap_bits;
1909                 err = ERROR_SUCCESS;
1910             }
1911         }
1912         else
1913         {
1914             PHYSDEV src_dev = GET_DC_PHYSDEV( dc, pGetImage );
1915             err = src_dev->funcs->pGetImage( src_dev, 0, info, &bits, &src );
1916             if (!err && !bits.is_copy)
1917             {
1918                 void *ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( info ));
1919                 if (!ptr)
1920                 {
1921                     if (bits.free) bits.free( &bits );
1922                     return ERROR_OUTOFMEMORY;
1923                 }
1924                 memcpy( ptr, bits.ptr, get_dib_image_size( info ));
1925                 if (bits.free) bits.free( &bits );
1926                 bits.ptr = ptr;
1927                 bits.is_copy = TRUE;
1928                 bits.free = free_heap_bits;
1929             }
1930         }
1931         if (!err)
1932         {
1933             /* make x,y relative to the image bits */
1934             x += src.visrect.left - dst.visrect.left;
1935             y += src.visrect.top - dst.visrect.top;
1936             render_aa_text_bitmapinfo( dev->hdc, info, &bits, &src, x, y, flags,
1937                                        aa_flags, str, count, dx );
1938             err = dst_dev->funcs->pPutImage( dst_dev, 0, 0, info, &bits, &src, &dst, SRCCOPY );
1939             if (bits.free) bits.free( &bits );
1940             return !err;
1941         }
1942     }
1943
1944     pen = CreatePen( PS_SOLID, 1, GetTextColor(dev->hdc) );
1945     orig = SelectObject( dev->hdc, pen );
1946
1947     for (i = 0; i < count; i++)
1948     {
1949         GLYPHMETRICS metrics;
1950         struct gdi_image_bits image;
1951
1952         err = get_glyph_bitmap( dev->hdc, (UINT)str[i], GGO_BITMAP, &metrics, &image );
1953         if (err) continue;
1954
1955         if (image.ptr) draw_glyph( dev->hdc, x, y, &metrics, &image, (flags & ETO_CLIPPED) ? rect : NULL );
1956         if (image.free) image.free( &image );
1957
1958         if (dx)
1959         {
1960             if (flags & ETO_PDY)
1961             {
1962                 x += dx[ i * 2 ];
1963                 y += dx[ i * 2 + 1];
1964             }
1965             else x += dx[ i ];
1966         }
1967         else
1968         {
1969             x += metrics.gmCellIncX;
1970             y += metrics.gmCellIncY;
1971         }
1972     }
1973
1974     SelectObject( dev->hdc, orig );
1975     DeleteObject( pen );
1976     return TRUE;
1977 }
1978
1979
1980 /***********************************************************************
1981  *           ExtTextOutA    (GDI32.@)
1982  *
1983  * See ExtTextOutW.
1984  */
1985 BOOL WINAPI ExtTextOutA( HDC hdc, INT x, INT y, UINT flags,
1986                          const RECT *lprect, LPCSTR str, UINT count, const INT *lpDx )
1987 {
1988     INT wlen;
1989     UINT codepage;
1990     LPWSTR p;
1991     BOOL ret;
1992     LPINT lpDxW = NULL;
1993
1994     if (flags & ETO_GLYPH_INDEX)
1995         return ExtTextOutW( hdc, x, y, flags, lprect, (LPCWSTR)str, count, lpDx );
1996
1997     p = FONT_mbtowc(hdc, str, count, &wlen, &codepage);
1998
1999     if (lpDx) {
2000         unsigned int i = 0, j = 0;
2001
2002         /* allocate enough for a ETO_PDY */
2003         lpDxW = HeapAlloc( GetProcessHeap(), 0, 2*wlen*sizeof(INT));
2004         while(i < count) {
2005             if(IsDBCSLeadByteEx(codepage, str[i]))
2006             {
2007                 if(flags & ETO_PDY)
2008                 {
2009                     lpDxW[j++] = lpDx[i * 2]     + lpDx[(i + 1) * 2];
2010                     lpDxW[j++] = lpDx[i * 2 + 1] + lpDx[(i + 1) * 2 + 1];
2011                 }
2012                 else
2013                     lpDxW[j++] = lpDx[i] + lpDx[i + 1];
2014                 i = i + 2;
2015             }
2016             else
2017             {
2018                 if(flags & ETO_PDY)
2019                 {
2020                     lpDxW[j++] = lpDx[i * 2];
2021                     lpDxW[j++] = lpDx[i * 2 + 1];
2022                 }
2023                 else
2024                     lpDxW[j++] = lpDx[i];
2025                 i = i + 1;
2026             }
2027         }
2028     }
2029
2030     ret = ExtTextOutW( hdc, x, y, flags, lprect, p, wlen, lpDxW );
2031
2032     HeapFree( GetProcessHeap(), 0, p );
2033     HeapFree( GetProcessHeap(), 0, lpDxW );
2034     return ret;
2035 }
2036
2037
2038 /***********************************************************************
2039  *           ExtTextOutW    (GDI32.@)
2040  *
2041  * Draws text using the currently selected font, background color, and text color.
2042  *
2043  *
2044  * PARAMS
2045  *    x,y    [I] coordinates of string
2046  *    flags  [I]
2047  *        ETO_GRAYED - undocumented on MSDN
2048  *        ETO_OPAQUE - use background color for fill the rectangle
2049  *        ETO_CLIPPED - clipping text to the rectangle
2050  *        ETO_GLYPH_INDEX - Buffer is of glyph locations in fonts rather
2051  *                          than encoded characters. Implies ETO_IGNORELANGUAGE
2052  *        ETO_RTLREADING - Paragraph is basically a right-to-left paragraph.
2053  *                         Affects BiDi ordering
2054  *        ETO_IGNORELANGUAGE - Undocumented in MSDN - instructs ExtTextOut not to do BiDi reordering
2055  *        ETO_PDY - unimplemented
2056  *        ETO_NUMERICSLATIN - unimplemented always assumed -
2057  *                            do not translate numbers into locale representations
2058  *        ETO_NUMERICSLOCAL - unimplemented - Numerals in Arabic/Farsi context should assume local form
2059  *    lprect [I] dimensions for clipping or/and opaquing
2060  *    str    [I] text string
2061  *    count  [I] number of symbols in string
2062  *    lpDx   [I] optional parameter with distance between drawing characters
2063  *
2064  * RETURNS
2065  *    Success: TRUE
2066  *    Failure: FALSE
2067  */
2068 BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags,
2069                          const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx )
2070 {
2071     BOOL ret = FALSE;
2072     LPWSTR reordered_str = (LPWSTR)str;
2073     WORD *glyphs = NULL;
2074     UINT align = GetTextAlign( hdc );
2075     DWORD layout = GetLayout( hdc );
2076     POINT pt;
2077     TEXTMETRICW tm;
2078     LOGFONTW lf;
2079     double cosEsc, sinEsc;
2080     INT char_extra;
2081     SIZE sz;
2082     RECT rc;
2083     BOOL done_extents = FALSE;
2084     POINT *deltas = NULL, width = {0, 0};
2085     DWORD type;
2086     DC * dc = get_dc_ptr( hdc );
2087     PHYSDEV physdev;
2088     INT breakRem;
2089     static int quietfixme = 0;
2090
2091     if (!dc) return FALSE;
2092
2093     breakRem = dc->breakRem;
2094
2095     if (quietfixme == 0 && flags & (ETO_NUMERICSLOCAL | ETO_NUMERICSLATIN))
2096     {
2097         FIXME("flags ETO_NUMERICSLOCAL | ETO_NUMERICSLATIN unimplemented\n");
2098         quietfixme = 1;
2099     }
2100
2101     update_dc( dc );
2102     physdev = GET_DC_PHYSDEV( dc, pExtTextOut );
2103     type = GetObjectType(hdc);
2104     if(type == OBJ_METADC || type == OBJ_ENHMETADC)
2105     {
2106         ret = physdev->funcs->pExtTextOut( physdev, x, y, flags, lprect, str, count, lpDx );
2107         release_dc_ptr( dc );
2108         return ret;
2109     }
2110
2111     if (!lprect)
2112         flags &= ~ETO_CLIPPED;
2113
2114     if (flags & ETO_RTLREADING) align |= TA_RTLREADING;
2115     if (layout & LAYOUT_RTL)
2116     {
2117         if ((align & TA_CENTER) != TA_CENTER) align ^= TA_RIGHT;
2118         align ^= TA_RTLREADING;
2119     }
2120
2121     if( !(flags & (ETO_GLYPH_INDEX | ETO_IGNORELANGUAGE)) && count > 0 )
2122     {
2123         INT cGlyphs;
2124         reordered_str = HeapAlloc(GetProcessHeap(), 0, count*sizeof(WCHAR));
2125
2126         BIDI_Reorder( hdc, str, count, GCP_REORDER,
2127                       (align & TA_RTLREADING) ? WINE_GCPW_FORCE_RTL : WINE_GCPW_FORCE_LTR,
2128                       reordered_str, count, NULL, &glyphs, &cGlyphs);
2129
2130         flags |= ETO_IGNORELANGUAGE;
2131         if (glyphs)
2132         {
2133             flags |= ETO_GLYPH_INDEX;
2134             if (cGlyphs != count)
2135                 count = cGlyphs;
2136         }
2137     }
2138     else if(flags & ETO_GLYPH_INDEX)
2139         glyphs = reordered_str;
2140
2141     TRACE("%p, %d, %d, %08x, %s, %s, %d, %p)\n", hdc, x, y, flags,
2142           wine_dbgstr_rect(lprect), debugstr_wn(str, count), count, lpDx);
2143     TRACE("align = %x bkmode = %x mapmode = %x\n", align, GetBkMode(hdc), GetMapMode(hdc));
2144
2145     if(align & TA_UPDATECP)
2146     {
2147         GetCurrentPositionEx( hdc, &pt );
2148         x = pt.x;
2149         y = pt.y;
2150     }
2151
2152     GetTextMetricsW(hdc, &tm);
2153     GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf);
2154
2155     if(!(tm.tmPitchAndFamily & TMPF_VECTOR)) /* Non-scalable fonts shouldn't be rotated */
2156         lf.lfEscapement = 0;
2157
2158     if ((dc->GraphicsMode == GM_COMPATIBLE) &&
2159         (dc->vport2WorldValid && dc->xformWorld2Vport.eM11 * dc->xformWorld2Vport.eM22 < 0))
2160     {
2161         lf.lfEscapement = -lf.lfEscapement;
2162     }
2163
2164     if(lf.lfEscapement != 0)
2165     {
2166         cosEsc = cos(lf.lfEscapement * M_PI / 1800);
2167         sinEsc = sin(lf.lfEscapement * M_PI / 1800);
2168     }
2169     else
2170     {
2171         cosEsc = 1;
2172         sinEsc = 0;
2173     }
2174
2175     if(flags & (ETO_CLIPPED | ETO_OPAQUE))
2176     {
2177         if(!lprect)
2178         {
2179             if(flags & ETO_GLYPH_INDEX)
2180                 GetTextExtentPointI(hdc, glyphs, count, &sz);
2181             else
2182                 GetTextExtentPointW(hdc, reordered_str, count, &sz);
2183
2184             done_extents = TRUE;
2185             rc.left = x;
2186             rc.top = y;
2187             rc.right = x + sz.cx;
2188             rc.bottom = y + sz.cy;
2189         }
2190         else
2191         {
2192             rc = *lprect;
2193         }
2194
2195         LPtoDP(hdc, (POINT*)&rc, 2);
2196
2197         if(rc.left > rc.right) {INT tmp = rc.left; rc.left = rc.right; rc.right = tmp;}
2198         if(rc.top > rc.bottom) {INT tmp = rc.top; rc.top = rc.bottom; rc.bottom = tmp;}
2199     }
2200
2201     if (lprect && (flags & ETO_OPAQUE))
2202         physdev->funcs->pExtTextOut( physdev, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL );
2203
2204     if(count == 0)
2205     {
2206         ret = TRUE;
2207         goto done;
2208     }
2209
2210     pt.x = x;
2211     pt.y = y;
2212     LPtoDP(hdc, &pt, 1);
2213     x = pt.x;
2214     y = pt.y;
2215
2216     char_extra = GetTextCharacterExtra(hdc);
2217     if(char_extra || dc->breakExtra || breakRem || lpDx || lf.lfEscapement != 0)
2218     {
2219         UINT i;
2220         SIZE tmpsz;
2221         POINT total = {0, 0}, desired[2];
2222
2223         deltas = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*deltas));
2224         for(i = 0; i < count; i++)
2225         {
2226             if(lpDx)
2227             {
2228                 if(flags & ETO_PDY)
2229                 {
2230                     deltas[i].x = lpDx[i * 2] + char_extra;
2231                     deltas[i].y = -lpDx[i * 2 + 1];
2232                 }
2233                 else
2234                 {
2235                     deltas[i].x = lpDx[i] + char_extra;
2236                     deltas[i].y = 0;
2237                 }
2238
2239             }
2240             else
2241             {
2242                 if(flags & ETO_GLYPH_INDEX)
2243                     GetTextExtentPointI(hdc, glyphs + i, 1, &tmpsz);
2244                 else
2245                     GetTextExtentPointW(hdc, reordered_str + i, 1, &tmpsz);
2246
2247                 deltas[i].x = tmpsz.cx;
2248                 deltas[i].y = 0;
2249             }
2250
2251             if (!(flags & ETO_GLYPH_INDEX) && (dc->breakExtra || breakRem) && reordered_str[i] == tm.tmBreakChar)
2252             {
2253                 deltas[i].x = deltas[i].x + dc->breakExtra;
2254                 if (breakRem > 0)
2255                 {
2256                     breakRem--;
2257                     deltas[i].x++;
2258                 }
2259             }
2260             total.x += deltas[i].x;
2261             total.y += deltas[i].y;
2262
2263             desired[0].x = desired[0].y = 0;
2264
2265             desired[1].x =  cosEsc * total.x + sinEsc * total.y;
2266             desired[1].y = -sinEsc * total.x + cosEsc * total.y;
2267
2268             LPtoDP(hdc, desired, 2);
2269             desired[1].x -= desired[0].x;
2270             desired[1].y -= desired[0].y;
2271
2272             if (dc->GraphicsMode == GM_COMPATIBLE)
2273             {
2274                 if (dc->vport2WorldValid && dc->xformWorld2Vport.eM11 < 0)
2275                     desired[1].x = -desired[1].x;
2276                 if (dc->vport2WorldValid && dc->xformWorld2Vport.eM22 < 0)
2277                     desired[1].y = -desired[1].y;
2278             }
2279             else
2280             {
2281                 if (layout & LAYOUT_RTL) desired[1].x = -desired[1].x;
2282             }
2283
2284             deltas[i].x = desired[1].x - width.x;
2285             deltas[i].y = desired[1].y - width.y;
2286
2287             width = desired[1];
2288         }
2289         flags |= ETO_PDY;
2290     }
2291     else
2292     {
2293         if(!done_extents)
2294         {
2295             if(flags & ETO_GLYPH_INDEX)
2296                 GetTextExtentPointI(hdc, glyphs, count, &sz);
2297             else
2298                 GetTextExtentPointW(hdc, reordered_str, count, &sz);
2299             done_extents = TRUE;
2300         }
2301         width.x = abs(INTERNAL_XWSTODS(dc, sz.cx));
2302         width.y = 0;
2303     }
2304
2305     tm.tmAscent = abs(INTERNAL_YWSTODS(dc, tm.tmAscent));
2306     tm.tmDescent = abs(INTERNAL_YWSTODS(dc, tm.tmDescent));
2307     switch( align & (TA_LEFT | TA_RIGHT | TA_CENTER) )
2308     {
2309     case TA_LEFT:
2310         if (align & TA_UPDATECP)
2311         {
2312             pt.x = x + width.x;
2313             pt.y = y + width.y;
2314             DPtoLP(hdc, &pt, 1);
2315             MoveToEx(hdc, pt.x, pt.y, NULL);
2316         }
2317         break;
2318
2319     case TA_CENTER:
2320         x -= width.x / 2;
2321         y -= width.y / 2;
2322         break;
2323
2324     case TA_RIGHT:
2325         x -= width.x;
2326         y -= width.y;
2327         if (align & TA_UPDATECP)
2328         {
2329             pt.x = x;
2330             pt.y = y;
2331             DPtoLP(hdc, &pt, 1);
2332             MoveToEx(hdc, pt.x, pt.y, NULL);
2333         }
2334         break;
2335     }
2336
2337     switch( align & (TA_TOP | TA_BOTTOM | TA_BASELINE) )
2338     {
2339     case TA_TOP:
2340         y += tm.tmAscent * cosEsc;
2341         x += tm.tmAscent * sinEsc;
2342         break;
2343
2344     case TA_BOTTOM:
2345         y -= tm.tmDescent * cosEsc;
2346         x -= tm.tmDescent * sinEsc;
2347         break;
2348
2349     case TA_BASELINE:
2350         break;
2351     }
2352
2353     if (GetBkMode(hdc) != TRANSPARENT)
2354     {
2355         if(!((flags & ETO_CLIPPED) && (flags & ETO_OPAQUE)))
2356         {
2357             if(!(flags & ETO_OPAQUE) || !lprect ||
2358                x < rc.left || x + width.x >= rc.right ||
2359                y - tm.tmAscent < rc.top || y + tm.tmDescent >= rc.bottom)
2360             {
2361                 RECT text_box;
2362                 text_box.left = x;
2363                 text_box.right = x + width.x;
2364                 text_box.top = y - tm.tmAscent;
2365                 text_box.bottom = y + tm.tmDescent;
2366
2367                 if (flags & ETO_CLIPPED) intersect_rect( &text_box, &text_box, &rc );
2368                 if (!is_rect_empty( &text_box ))
2369                     physdev->funcs->pExtTextOut( physdev, 0, 0, ETO_OPAQUE, &text_box, NULL, 0, NULL );
2370             }
2371         }
2372     }
2373
2374     if(FontIsLinked(hdc) && !(flags & ETO_GLYPH_INDEX))
2375     {
2376         HFONT orig_font = dc->hFont, cur_font;
2377         UINT glyph;
2378         INT span = 0;
2379         POINT *offsets = NULL;
2380         unsigned int i;
2381
2382         glyphs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WORD));
2383         for(i = 0; i < count; i++)
2384         {
2385             WineEngGetLinkedHFont(dc, reordered_str[i], &cur_font, &glyph);
2386             if(cur_font != dc->hFont)
2387             {
2388                 if(!offsets)
2389                 {
2390                     unsigned int j;
2391                     offsets = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*deltas));
2392                     offsets[0].x = offsets[0].y = 0;
2393
2394                     if(!deltas)
2395                     {
2396                         SIZE tmpsz;
2397                         for(j = 1; j < count; j++)
2398                         {
2399                             GetTextExtentPointW(hdc, reordered_str + j - 1, 1, &tmpsz);
2400                             offsets[j].x = offsets[j - 1].x + abs(INTERNAL_XWSTODS(dc, tmpsz.cx));
2401                             offsets[j].y = 0;
2402                         }
2403                     }
2404                     else
2405                     {
2406                         for(j = 1; j < count; j++)
2407                         {
2408                             offsets[j].x = offsets[j - 1].x + deltas[j].x;
2409                             offsets[j].y = offsets[j - 1].y + deltas[j].y;
2410                         }
2411                     }
2412                 }
2413                 if(span)
2414                 {
2415                     physdev->funcs->pExtTextOut( physdev, x + offsets[i - span].x,
2416                                                  y + offsets[i - span].y,
2417                                                  (flags & ~ETO_OPAQUE) | ETO_GLYPH_INDEX, &rc, glyphs,
2418                                                  span, deltas ? (INT*)(deltas + (i - span)) : NULL);
2419                     span = 0;
2420                 }
2421                 SelectObject(hdc, cur_font);
2422             }
2423             glyphs[span++] = glyph;
2424
2425             if(i == count - 1)
2426             {
2427                 ret = physdev->funcs->pExtTextOut(physdev, x + (offsets ? offsets[count - span].x : 0),
2428                                                   y + (offsets ? offsets[count - span].y : 0),
2429                                                   (flags & ~ETO_OPAQUE) | ETO_GLYPH_INDEX, &rc, glyphs,
2430                                                   span, deltas ? (INT*)(deltas + (count - span)) : NULL);
2431                 SelectObject(hdc, orig_font);
2432                 HeapFree(GetProcessHeap(), 0, offsets);
2433            }
2434         }
2435     }
2436     else
2437     {
2438         if(!(flags & ETO_GLYPH_INDEX) && dc->gdiFont)
2439         {
2440             glyphs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WORD));
2441             GetGlyphIndicesW(hdc, reordered_str, count, glyphs, 0);
2442             flags |= ETO_GLYPH_INDEX;
2443         }
2444         ret = physdev->funcs->pExtTextOut( physdev, x, y, (flags & ~ETO_OPAQUE), &rc,
2445                                            glyphs ? glyphs : reordered_str, count, (INT*)deltas );
2446     }
2447
2448 done:
2449     HeapFree(GetProcessHeap(), 0, deltas);
2450     if(glyphs != reordered_str)
2451         HeapFree(GetProcessHeap(), 0, glyphs);
2452     if(reordered_str != str)
2453         HeapFree(GetProcessHeap(), 0, reordered_str);
2454
2455     release_dc_ptr( dc );
2456
2457     if (ret && (lf.lfUnderline || lf.lfStrikeOut))
2458     {
2459         int underlinePos, strikeoutPos;
2460         int underlineWidth, strikeoutWidth;
2461         UINT size = GetOutlineTextMetricsW(hdc, 0, NULL);
2462         OUTLINETEXTMETRICW* otm = NULL;
2463         POINT pts[5];
2464         HPEN hpen = SelectObject(hdc, GetStockObject(NULL_PEN));
2465         HBRUSH hbrush = CreateSolidBrush(GetTextColor(hdc));
2466
2467         hbrush = SelectObject(hdc, hbrush);
2468
2469         if(!size)
2470         {
2471             underlinePos = 0;
2472             underlineWidth = tm.tmAscent / 20 + 1;
2473             strikeoutPos = tm.tmAscent / 2;
2474             strikeoutWidth = underlineWidth;
2475         }
2476         else
2477         {
2478             otm = HeapAlloc(GetProcessHeap(), 0, size);
2479             GetOutlineTextMetricsW(hdc, size, otm);
2480             underlinePos = abs( INTERNAL_YWSTODS( dc, otm->otmsUnderscorePosition ));
2481             if (otm->otmsUnderscorePosition < 0) underlinePos = -underlinePos;
2482             underlineWidth = abs( INTERNAL_YWSTODS( dc, otm->otmsUnderscoreSize ));
2483             if (otm->otmsUnderscoreSize < 0) underlineWidth = -underlineWidth;
2484             strikeoutPos = abs( INTERNAL_YWSTODS( dc, otm->otmsStrikeoutPosition ));
2485             if (otm->otmsStrikeoutPosition < 0) strikeoutPos = -strikeoutPos;
2486             strikeoutWidth = abs( INTERNAL_YWSTODS( dc, otm->otmsStrikeoutSize ));
2487             HeapFree(GetProcessHeap(), 0, otm);
2488         }
2489
2490
2491         if (lf.lfUnderline)
2492         {
2493             pts[0].x = x - (underlinePos + underlineWidth / 2) * sinEsc;
2494             pts[0].y = y - (underlinePos + underlineWidth / 2) * cosEsc;
2495             pts[1].x = x + width.x - (underlinePos + underlineWidth / 2) * sinEsc;
2496             pts[1].y = y + width.y - (underlinePos + underlineWidth / 2) * cosEsc;
2497             pts[2].x = pts[1].x + underlineWidth * sinEsc;
2498             pts[2].y = pts[1].y + underlineWidth * cosEsc;
2499             pts[3].x = pts[0].x + underlineWidth * sinEsc;
2500             pts[3].y = pts[0].y + underlineWidth * cosEsc;
2501             pts[4].x = pts[0].x;
2502             pts[4].y = pts[0].y;
2503             DPtoLP(hdc, pts, 5);
2504             Polygon(hdc, pts, 5);
2505         }
2506
2507         if (lf.lfStrikeOut)
2508         {
2509             pts[0].x = x - (strikeoutPos + strikeoutWidth / 2) * sinEsc;
2510             pts[0].y = y - (strikeoutPos + strikeoutWidth / 2) * cosEsc;
2511             pts[1].x = x + width.x - (strikeoutPos + strikeoutWidth / 2) * sinEsc;
2512             pts[1].y = y + width.y - (strikeoutPos + strikeoutWidth / 2) * cosEsc;
2513             pts[2].x = pts[1].x + strikeoutWidth * sinEsc;
2514             pts[2].y = pts[1].y + strikeoutWidth * cosEsc;
2515             pts[3].x = pts[0].x + strikeoutWidth * sinEsc;
2516             pts[3].y = pts[0].y + strikeoutWidth * cosEsc;
2517             pts[4].x = pts[0].x;
2518             pts[4].y = pts[0].y;
2519             DPtoLP(hdc, pts, 5);
2520             Polygon(hdc, pts, 5);
2521         }
2522
2523         SelectObject(hdc, hpen);
2524         hbrush = SelectObject(hdc, hbrush);
2525         DeleteObject(hbrush);
2526     }
2527
2528     return ret;
2529 }
2530
2531
2532 /***********************************************************************
2533  *           TextOutA    (GDI32.@)
2534  */
2535 BOOL WINAPI TextOutA( HDC hdc, INT x, INT y, LPCSTR str, INT count )
2536 {
2537     return ExtTextOutA( hdc, x, y, 0, NULL, str, count, NULL );
2538 }
2539
2540
2541 /***********************************************************************
2542  *           TextOutW    (GDI32.@)
2543  */
2544 BOOL WINAPI TextOutW(HDC hdc, INT x, INT y, LPCWSTR str, INT count)
2545 {
2546     return ExtTextOutW( hdc, x, y, 0, NULL, str, count, NULL );
2547 }
2548
2549
2550 /***********************************************************************
2551  *              PolyTextOutA (GDI32.@)
2552  *
2553  * See PolyTextOutW.
2554  */
2555 BOOL WINAPI PolyTextOutA( HDC hdc, const POLYTEXTA *pptxt, INT cStrings )
2556 {
2557     for (; cStrings>0; cStrings--, pptxt++)
2558         if (!ExtTextOutA( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
2559             return FALSE;
2560     return TRUE;
2561 }
2562
2563
2564
2565 /***********************************************************************
2566  *              PolyTextOutW (GDI32.@)
2567  *
2568  * Draw several Strings
2569  *
2570  * RETURNS
2571  *  TRUE:  Success.
2572  *  FALSE: Failure.
2573  */
2574 BOOL WINAPI PolyTextOutW( HDC hdc, const POLYTEXTW *pptxt, INT cStrings )
2575 {
2576     for (; cStrings>0; cStrings--, pptxt++)
2577         if (!ExtTextOutW( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
2578             return FALSE;
2579     return TRUE;
2580 }
2581
2582
2583 /***********************************************************************
2584  *           SetMapperFlags    (GDI32.@)
2585  */
2586 DWORD WINAPI SetMapperFlags( HDC hdc, DWORD flags )
2587 {
2588     DC *dc = get_dc_ptr( hdc );
2589     DWORD ret = GDI_ERROR;
2590
2591     if (dc)
2592     {
2593         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetMapperFlags );
2594         flags = physdev->funcs->pSetMapperFlags( physdev, flags );
2595         if (flags != GDI_ERROR)
2596         {
2597             ret = dc->mapperFlags;
2598             dc->mapperFlags = flags;
2599         }
2600         release_dc_ptr( dc );
2601     }
2602     return ret;
2603 }
2604
2605 /***********************************************************************
2606  *          GetAspectRatioFilterEx  (GDI32.@)
2607  */
2608 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
2609 {
2610   FIXME("(%p, %p): -- Empty Stub !\n", hdc, pAspectRatio);
2611   return FALSE;
2612 }
2613
2614
2615 /***********************************************************************
2616  *           GetCharABCWidthsA   (GDI32.@)
2617  *
2618  * See GetCharABCWidthsW.
2619  */
2620 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
2621                                   LPABC abc )
2622 {
2623     INT i, wlen;
2624     LPSTR str;
2625     LPWSTR wstr;
2626     BOOL ret = TRUE;
2627
2628     str = FONT_GetCharsByRangeA(hdc, firstChar, lastChar, &i);
2629     if (str == NULL)
2630         return FALSE;
2631
2632     wstr = FONT_mbtowc(hdc, str, i, &wlen, NULL);
2633     if (wstr == NULL)
2634     {
2635         HeapFree(GetProcessHeap(), 0, str);
2636         return FALSE;
2637     }
2638
2639     for(i = 0; i < wlen; i++)
2640     {
2641         if(!GetCharABCWidthsW(hdc, wstr[i], wstr[i], abc))
2642         {
2643             ret = FALSE;
2644             break;
2645         }
2646         abc++;
2647     }
2648
2649     HeapFree(GetProcessHeap(), 0, str);
2650     HeapFree(GetProcessHeap(), 0, wstr);
2651
2652     return ret;
2653 }
2654
2655
2656 /******************************************************************************
2657  * GetCharABCWidthsW [GDI32.@]
2658  *
2659  * Retrieves widths of characters in range.
2660  *
2661  * PARAMS
2662  *    hdc       [I] Handle of device context
2663  *    firstChar [I] First character in range to query
2664  *    lastChar  [I] Last character in range to query
2665  *    abc       [O] Address of character-width structure
2666  *
2667  * NOTES
2668  *    Only works with TrueType fonts
2669  *
2670  * RETURNS
2671  *    Success: TRUE
2672  *    Failure: FALSE
2673  */
2674 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
2675                                    LPABC abc )
2676 {
2677     DC *dc = get_dc_ptr(hdc);
2678     PHYSDEV dev;
2679     unsigned int i;
2680     BOOL ret;
2681     TEXTMETRICW tm;
2682
2683     if (!dc) return FALSE;
2684
2685     if (!abc)
2686     {
2687         release_dc_ptr( dc );
2688         return FALSE;
2689     }
2690
2691     /* unlike GetCharABCWidthsFloatW, this one is supposed to fail on non-TrueType fonts */
2692     dev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
2693     if (!dev->funcs->pGetTextMetrics( dev, &tm ) || !(tm.tmPitchAndFamily & TMPF_TRUETYPE))
2694     {
2695         release_dc_ptr( dc );
2696         return FALSE;
2697     }
2698
2699     dev = GET_DC_PHYSDEV( dc, pGetCharABCWidths );
2700     ret = dev->funcs->pGetCharABCWidths( dev, firstChar, lastChar, abc );
2701     if (ret)
2702     {
2703         /* convert device units to logical */
2704         for( i = firstChar; i <= lastChar; i++, abc++ ) {
2705             abc->abcA = INTERNAL_XDSTOWS(dc, abc->abcA);
2706             abc->abcB = INTERNAL_XDSTOWS(dc, abc->abcB);
2707             abc->abcC = INTERNAL_XDSTOWS(dc, abc->abcC);
2708         }
2709     }
2710
2711     release_dc_ptr( dc );
2712     return ret;
2713 }
2714
2715
2716 /******************************************************************************
2717  * GetCharABCWidthsI [GDI32.@]
2718  *
2719  * Retrieves widths of characters in range.
2720  *
2721  * PARAMS
2722  *    hdc       [I] Handle of device context
2723  *    firstChar [I] First glyphs in range to query
2724  *    count     [I] Last glyphs in range to query
2725  *    pgi       [i] Array of glyphs to query
2726  *    abc       [O] Address of character-width structure
2727  *
2728  * NOTES
2729  *    Only works with TrueType fonts
2730  *
2731  * RETURNS
2732  *    Success: TRUE
2733  *    Failure: FALSE
2734  */
2735 BOOL WINAPI GetCharABCWidthsI( HDC hdc, UINT firstChar, UINT count,
2736                                LPWORD pgi, LPABC abc)
2737 {
2738     DC *dc = get_dc_ptr(hdc);
2739     PHYSDEV dev;
2740     unsigned int i;
2741     BOOL ret;
2742
2743     if (!dc) return FALSE;
2744
2745     if (!abc)
2746     {
2747         release_dc_ptr( dc );
2748         return FALSE;
2749     }
2750
2751     dev = GET_DC_PHYSDEV( dc, pGetCharABCWidthsI );
2752     ret = dev->funcs->pGetCharABCWidthsI( dev, firstChar, count, pgi, abc );
2753     if (ret)
2754     {
2755         /* convert device units to logical */
2756         for( i = 0; i < count; i++, abc++ ) {
2757             abc->abcA = INTERNAL_XDSTOWS(dc, abc->abcA);
2758             abc->abcB = INTERNAL_XDSTOWS(dc, abc->abcB);
2759             abc->abcC = INTERNAL_XDSTOWS(dc, abc->abcC);
2760         }
2761     }
2762
2763     release_dc_ptr( dc );
2764     return ret;
2765 }
2766
2767
2768 /***********************************************************************
2769  *           GetGlyphOutlineA    (GDI32.@)
2770  */
2771 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
2772                                  LPGLYPHMETRICS lpgm, DWORD cbBuffer,
2773                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
2774 {
2775     if (!lpmat2) return GDI_ERROR;
2776
2777     if(!(fuFormat & GGO_GLYPH_INDEX)) {
2778         UINT cp;
2779         int len;
2780         char mbchs[2];
2781
2782         cp = GdiGetCodePage(hdc);
2783         if (IsDBCSLeadByteEx(cp, uChar >> 8)) {
2784             len = 2;
2785             mbchs[0] = (uChar & 0xff00) >> 8;
2786             mbchs[1] = (uChar & 0xff);
2787         } else {
2788             len = 1;
2789             mbchs[0] = (uChar & 0xff);
2790         }
2791         uChar = 0;
2792         MultiByteToWideChar(cp, 0, mbchs, len, (LPWSTR)&uChar, 1);
2793     }
2794
2795     return GetGlyphOutlineW(hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer,
2796                             lpmat2);
2797 }
2798
2799 /***********************************************************************
2800  *           GetGlyphOutlineW    (GDI32.@)
2801  */
2802 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
2803                                  LPGLYPHMETRICS lpgm, DWORD cbBuffer,
2804                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
2805 {
2806     DC *dc;
2807     DWORD ret;
2808     PHYSDEV dev;
2809
2810     TRACE("(%p, %04x, %04x, %p, %d, %p, %p)\n",
2811           hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
2812
2813     if (!lpmat2) return GDI_ERROR;
2814
2815     dc = get_dc_ptr(hdc);
2816     if(!dc) return GDI_ERROR;
2817
2818     dev = GET_DC_PHYSDEV( dc, pGetGlyphOutline );
2819     ret = dev->funcs->pGetGlyphOutline( dev, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
2820     release_dc_ptr( dc );
2821     return ret;
2822 }
2823
2824
2825 /***********************************************************************
2826  *           CreateScalableFontResourceA   (GDI32.@)
2827  */
2828 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
2829                                              LPCSTR lpszResourceFile,
2830                                              LPCSTR lpszFontFile,
2831                                              LPCSTR lpszCurrentPath )
2832 {
2833     LPWSTR lpszResourceFileW = NULL;
2834     LPWSTR lpszFontFileW = NULL;
2835     LPWSTR lpszCurrentPathW = NULL;
2836     int len;
2837     BOOL ret;
2838
2839     if (lpszResourceFile)
2840     {
2841         len = MultiByteToWideChar(CP_ACP, 0, lpszResourceFile, -1, NULL, 0);
2842         lpszResourceFileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2843         MultiByteToWideChar(CP_ACP, 0, lpszResourceFile, -1, lpszResourceFileW, len);
2844     }
2845
2846     if (lpszFontFile)
2847     {
2848         len = MultiByteToWideChar(CP_ACP, 0, lpszFontFile, -1, NULL, 0);
2849         lpszFontFileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2850         MultiByteToWideChar(CP_ACP, 0, lpszFontFile, -1, lpszFontFileW, len);
2851     }
2852
2853     if (lpszCurrentPath)
2854     {
2855         len = MultiByteToWideChar(CP_ACP, 0, lpszCurrentPath, -1, NULL, 0);
2856         lpszCurrentPathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2857         MultiByteToWideChar(CP_ACP, 0, lpszCurrentPath, -1, lpszCurrentPathW, len);
2858     }
2859
2860     ret = CreateScalableFontResourceW(fHidden, lpszResourceFileW,
2861             lpszFontFileW, lpszCurrentPathW);
2862
2863     HeapFree(GetProcessHeap(), 0, lpszResourceFileW);
2864     HeapFree(GetProcessHeap(), 0, lpszFontFileW);
2865     HeapFree(GetProcessHeap(), 0, lpszCurrentPathW);
2866
2867     return ret;
2868 }
2869
2870 /***********************************************************************
2871  *           CreateScalableFontResourceW   (GDI32.@)
2872  */
2873 BOOL WINAPI CreateScalableFontResourceW( DWORD fHidden,
2874                                              LPCWSTR lpszResourceFile,
2875                                              LPCWSTR lpszFontFile,
2876                                              LPCWSTR lpszCurrentPath )
2877 {
2878     HANDLE f;
2879     FIXME("(%d,%s,%s,%s): stub\n",
2880           fHidden, debugstr_w(lpszResourceFile), debugstr_w(lpszFontFile),
2881           debugstr_w(lpszCurrentPath) );
2882
2883     /* fHidden=1 - only visible for the calling app, read-only, not
2884      * enumerated with EnumFonts/EnumFontFamilies
2885      * lpszCurrentPath can be NULL
2886      */
2887
2888     /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */
2889     if ((f = CreateFileW(lpszResourceFile, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE) {
2890         CloseHandle(f);
2891         SetLastError(ERROR_FILE_EXISTS);
2892         return FALSE;
2893     }
2894     return FALSE; /* create failed */
2895 }
2896
2897 /*************************************************************************
2898  *             GetKerningPairsA   (GDI32.@)
2899  */
2900 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
2901                                LPKERNINGPAIR kern_pairA )
2902 {
2903     UINT cp;
2904     CPINFO cpi;
2905     DWORD i, total_kern_pairs, kern_pairs_copied = 0;
2906     KERNINGPAIR *kern_pairW;
2907
2908     if (!cPairs && kern_pairA)
2909     {
2910         SetLastError(ERROR_INVALID_PARAMETER);
2911         return 0;
2912     }
2913
2914     cp = GdiGetCodePage(hDC);
2915
2916     /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
2917      * to fail on an invalid character for CP_SYMBOL.
2918      */
2919     cpi.DefaultChar[0] = 0;
2920     if (cp != CP_SYMBOL && !GetCPInfo(cp, &cpi))
2921     {
2922         FIXME("Can't find codepage %u info\n", cp);
2923         return 0;
2924     }
2925
2926     total_kern_pairs = GetKerningPairsW(hDC, 0, NULL);
2927     if (!total_kern_pairs) return 0;
2928
2929     kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
2930     GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
2931
2932     for (i = 0; i < total_kern_pairs; i++)
2933     {
2934         char first, second;
2935
2936         if (!WideCharToMultiByte(cp, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
2937             continue;
2938
2939         if (!WideCharToMultiByte(cp, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
2940             continue;
2941
2942         if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
2943             continue;
2944
2945         if (kern_pairA)
2946         {
2947             if (kern_pairs_copied >= cPairs) break;
2948
2949             kern_pairA->wFirst = (BYTE)first;
2950             kern_pairA->wSecond = (BYTE)second;
2951             kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
2952             kern_pairA++;
2953         }
2954         kern_pairs_copied++;
2955     }
2956
2957     HeapFree(GetProcessHeap(), 0, kern_pairW);
2958
2959     return kern_pairs_copied;
2960 }
2961
2962 /*************************************************************************
2963  *             GetKerningPairsW   (GDI32.@)
2964  */
2965 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
2966                                  LPKERNINGPAIR lpKerningPairs )
2967 {
2968     DC *dc;
2969     DWORD ret;
2970     PHYSDEV dev;
2971
2972     TRACE("(%p,%d,%p)\n", hDC, cPairs, lpKerningPairs);
2973
2974     if (!cPairs && lpKerningPairs)
2975     {
2976         SetLastError(ERROR_INVALID_PARAMETER);
2977         return 0;
2978     }
2979
2980     dc = get_dc_ptr(hDC);
2981     if (!dc) return 0;
2982
2983     dev = GET_DC_PHYSDEV( dc, pGetKerningPairs );
2984     ret = dev->funcs->pGetKerningPairs( dev, cPairs, lpKerningPairs );
2985     release_dc_ptr( dc );
2986     return ret;
2987 }
2988
2989 /*************************************************************************
2990  * TranslateCharsetInfo [GDI32.@]
2991  *
2992  * Fills a CHARSETINFO structure for a character set, code page, or
2993  * font. This allows making the correspondence between different labels
2994  * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
2995  * of the same encoding.
2996  *
2997  * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
2998  * only one codepage should be set in *lpSrc.
2999  *
3000  * RETURNS
3001  *   TRUE on success, FALSE on failure.
3002  *
3003  */
3004 BOOL WINAPI TranslateCharsetInfo(
3005   LPDWORD lpSrc, /* [in]
3006        if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
3007        if flags == TCI_SRCCHARSET: a character set value
3008        if flags == TCI_SRCCODEPAGE: a code page value
3009                  */
3010   LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
3011   DWORD flags /* [in] determines interpretation of lpSrc */)
3012 {
3013     int index = 0;
3014     switch (flags) {
3015     case TCI_SRCFONTSIG:
3016       while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++;
3017       break;
3018     case TCI_SRCCODEPAGE:
3019       while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++;
3020       break;
3021     case TCI_SRCCHARSET:
3022       while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++;
3023       break;
3024     default:
3025       return FALSE;
3026     }
3027     if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
3028     *lpCs = FONT_tci[index];
3029     return TRUE;
3030 }
3031
3032 /*************************************************************************
3033  *             GetFontLanguageInfo   (GDI32.@)
3034  */
3035 DWORD WINAPI GetFontLanguageInfo(HDC hdc)
3036 {
3037         FONTSIGNATURE fontsig;
3038         static const DWORD GCP_DBCS_MASK=0x003F0000,
3039                 GCP_DIACRITIC_MASK=0x00000000,
3040                 FLI_GLYPHS_MASK=0x00000000,
3041                 GCP_GLYPHSHAPE_MASK=0x00000040,
3042                 GCP_KASHIDA_MASK=0x00000000,
3043                 GCP_LIGATE_MASK=0x00000000,
3044                 GCP_USEKERNING_MASK=0x00000000,
3045                 GCP_REORDER_MASK=0x00000060;
3046
3047         DWORD result=0;
3048
3049         GetTextCharsetInfo( hdc, &fontsig, 0 );
3050         /* We detect each flag we return using a bitmask on the Codepage Bitfields */
3051
3052         if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
3053                 result|=GCP_DBCS;
3054
3055         if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
3056                 result|=GCP_DIACRITIC;
3057
3058         if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
3059                 result|=FLI_GLYPHS;
3060
3061         if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
3062                 result|=GCP_GLYPHSHAPE;
3063
3064         if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
3065                 result|=GCP_KASHIDA;
3066
3067         if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
3068                 result|=GCP_LIGATE;
3069
3070         if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
3071                 result|=GCP_USEKERNING;
3072
3073         /* this might need a test for a HEBREW- or ARABIC_CHARSET as well */
3074         if( GetTextAlign( hdc) & TA_RTLREADING )
3075             if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
3076                     result|=GCP_REORDER;
3077
3078         return result;
3079 }
3080
3081
3082 /*************************************************************************
3083  * GetFontData [GDI32.@]
3084  *
3085  * Retrieve data for TrueType font.
3086  *
3087  * RETURNS
3088  *
3089  * success: Number of bytes returned
3090  * failure: GDI_ERROR
3091  *
3092  * NOTES
3093  *
3094  * Calls SetLastError()
3095  *
3096  */
3097 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
3098     LPVOID buffer, DWORD length)
3099 {
3100     DC *dc = get_dc_ptr(hdc);
3101     PHYSDEV dev;
3102     DWORD ret;
3103
3104     if(!dc) return GDI_ERROR;
3105
3106     dev = GET_DC_PHYSDEV( dc, pGetFontData );
3107     ret = dev->funcs->pGetFontData( dev, table, offset, buffer, length );
3108     release_dc_ptr( dc );
3109     return ret;
3110 }
3111
3112 /*************************************************************************
3113  * GetGlyphIndicesA [GDI32.@]
3114  */
3115 DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
3116                               LPWORD pgi, DWORD flags)
3117 {
3118     DWORD ret;
3119     WCHAR *lpstrW;
3120     INT countW;
3121
3122     TRACE("(%p, %s, %d, %p, 0x%x)\n",
3123           hdc, debugstr_an(lpstr, count), count, pgi, flags);
3124
3125     lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
3126     ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
3127     HeapFree(GetProcessHeap(), 0, lpstrW);
3128
3129     return ret;
3130 }
3131
3132 /*************************************************************************
3133  * GetGlyphIndicesW [GDI32.@]
3134  */
3135 DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
3136                               LPWORD pgi, DWORD flags)
3137 {
3138     DC *dc = get_dc_ptr(hdc);
3139     PHYSDEV dev;
3140     DWORD ret;
3141
3142     TRACE("(%p, %s, %d, %p, 0x%x)\n",
3143           hdc, debugstr_wn(lpstr, count), count, pgi, flags);
3144
3145     if(!dc) return GDI_ERROR;
3146
3147     dev = GET_DC_PHYSDEV( dc, pGetGlyphIndices );
3148     ret = dev->funcs->pGetGlyphIndices( dev, lpstr, count, pgi, flags );
3149     release_dc_ptr( dc );
3150     return ret;
3151 }
3152
3153 /*************************************************************************
3154  * GetCharacterPlacementA [GDI32.@]
3155  *
3156  * See GetCharacterPlacementW.
3157  *
3158  * NOTES:
3159  *  the web browser control of ie4 calls this with dwFlags=0
3160  */
3161 DWORD WINAPI
3162 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
3163                          INT nMaxExtent, GCP_RESULTSA *lpResults,
3164                          DWORD dwFlags)
3165 {
3166     WCHAR *lpStringW;
3167     INT uCountW;
3168     GCP_RESULTSW resultsW;
3169     DWORD ret;
3170     UINT font_cp;
3171
3172     TRACE("%s, %d, %d, 0x%08x\n",
3173           debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
3174
3175     /* both structs are equal in size */
3176     memcpy(&resultsW, lpResults, sizeof(resultsW));
3177
3178     lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
3179     if(lpResults->lpOutString)
3180         resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
3181
3182     ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
3183
3184     lpResults->nGlyphs = resultsW.nGlyphs;
3185     lpResults->nMaxFit = resultsW.nMaxFit;
3186
3187     if(lpResults->lpOutString) {
3188         WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
3189                             lpResults->lpOutString, uCount, NULL, NULL );
3190     }
3191
3192     HeapFree(GetProcessHeap(), 0, lpStringW);
3193     HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
3194
3195     return ret;
3196 }
3197
3198 /*************************************************************************
3199  * GetCharacterPlacementW [GDI32.@]
3200  *
3201  *   Retrieve information about a string. This includes the width, reordering,
3202  *   Glyphing and so on.
3203  *
3204  * RETURNS
3205  *
3206  *   The width and height of the string if successful, 0 if failed.
3207  *
3208  * BUGS
3209  *
3210  *   All flags except GCP_REORDER are not yet implemented.
3211  *   Reordering is not 100% compliant to the Windows BiDi method.
3212  *   Caret positioning is not yet implemented for BiDi.
3213  *   Classes are not yet implemented.
3214  *
3215  */
3216 DWORD WINAPI
3217 GetCharacterPlacementW(
3218                 HDC hdc,                /* [in] Device context for which the rendering is to be done */
3219                 LPCWSTR lpString,       /* [in] The string for which information is to be returned */
3220                 INT uCount,             /* [in] Number of WORDS in string. */
3221                 INT nMaxExtent,         /* [in] Maximum extent the string is to take (in HDC logical units) */
3222                 GCP_RESULTSW *lpResults,/* [in/out] A pointer to a GCP_RESULTSW struct */
3223                 DWORD dwFlags           /* [in] Flags specifying how to process the string */
3224                 )
3225 {
3226     DWORD ret=0;
3227     SIZE size;
3228     UINT i, nSet;
3229
3230     TRACE("%s, %d, %d, 0x%08x\n",
3231           debugstr_wn(lpString, uCount), uCount, nMaxExtent, dwFlags);
3232
3233     TRACE("lStructSize=%d, lpOutString=%p, lpOrder=%p, lpDx=%p, lpCaretPos=%p\n"
3234           "lpClass=%p, lpGlyphs=%p, nGlyphs=%u, nMaxFit=%d\n",
3235             lpResults->lStructSize, lpResults->lpOutString, lpResults->lpOrder,
3236             lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
3237             lpResults->lpGlyphs, lpResults->nGlyphs, lpResults->nMaxFit);
3238
3239     if(dwFlags&(~GCP_REORDER))                  FIXME("flags 0x%08x ignored\n", dwFlags);
3240     if(lpResults->lpClass)      FIXME("classes not implemented\n");
3241     if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER))
3242         FIXME("Caret positions for complex scripts not implemented\n");
3243
3244         nSet = (UINT)uCount;
3245         if(nSet > lpResults->nGlyphs)
3246                 nSet = lpResults->nGlyphs;
3247
3248         /* return number of initialized fields */
3249         lpResults->nGlyphs = nSet;
3250
3251         if((dwFlags&GCP_REORDER)==0 )
3252         {
3253                 /* Treat the case where no special handling was requested in a fastpath way */
3254                 /* copy will do if the GCP_REORDER flag is not set */
3255                 if(lpResults->lpOutString)
3256                     memcpy( lpResults->lpOutString, lpString, nSet * sizeof(WCHAR));
3257
3258                 if(lpResults->lpOrder)
3259                 {
3260                         for(i = 0; i < nSet; i++)
3261                                 lpResults->lpOrder[i] = i;
3262                 }
3263         } else
3264         {
3265             BIDI_Reorder(NULL, lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
3266                           nSet, lpResults->lpOrder, NULL, NULL );
3267         }
3268
3269         /* FIXME: Will use the placement chars */
3270         if (lpResults->lpDx)
3271         {
3272                 int c;
3273                 for (i = 0; i < nSet; i++)
3274                 {
3275                         if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
3276                                 lpResults->lpDx[i]= c;
3277                 }
3278         }
3279
3280     if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
3281     {
3282         int pos = 0;
3283
3284         lpResults->lpCaretPos[0] = 0;
3285         for (i = 1; i < nSet; i++)
3286             if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
3287                 lpResults->lpCaretPos[i] = (pos += size.cx);
3288     }
3289
3290     if(lpResults->lpGlyphs)
3291         GetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
3292
3293     if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
3294       ret = MAKELONG(size.cx, size.cy);
3295
3296     return ret;
3297 }
3298
3299 /*************************************************************************
3300  *      GetCharABCWidthsFloatA [GDI32.@]
3301  *
3302  * See GetCharABCWidthsFloatW.
3303  */
3304 BOOL WINAPI GetCharABCWidthsFloatA( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
3305 {
3306     INT i, wlen;
3307     LPSTR str;
3308     LPWSTR wstr;
3309     BOOL ret = TRUE;
3310
3311     str = FONT_GetCharsByRangeA(hdc, first, last, &i);
3312     if (str == NULL)
3313         return FALSE;
3314
3315     wstr = FONT_mbtowc( hdc, str, i, &wlen, NULL );
3316
3317     for (i = 0; i < wlen; i++)
3318     {
3319         if (!GetCharABCWidthsFloatW( hdc, wstr[i], wstr[i], abcf ))
3320         {
3321             ret = FALSE;
3322             break;
3323         }
3324         abcf++;
3325     }
3326
3327     HeapFree( GetProcessHeap(), 0, str );
3328     HeapFree( GetProcessHeap(), 0, wstr );
3329
3330     return ret;
3331 }
3332
3333 /*************************************************************************
3334  *      GetCharABCWidthsFloatW [GDI32.@]
3335  *
3336  * Retrieves widths of a range of characters.
3337  *
3338  * PARAMS
3339  *    hdc   [I] Handle to device context.
3340  *    first [I] First character in range to query.
3341  *    last  [I] Last character in range to query.
3342  *    abcf  [O] Array of LPABCFLOAT structures.
3343  *
3344  * RETURNS
3345  *    Success: TRUE
3346  *    Failure: FALSE
3347  */
3348 BOOL WINAPI GetCharABCWidthsFloatW( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
3349 {
3350     UINT i;
3351     ABC *abc;
3352     PHYSDEV dev;
3353     BOOL ret = FALSE;
3354     DC *dc = get_dc_ptr( hdc );
3355
3356     TRACE("%p, %d, %d, %p\n", hdc, first, last, abcf);
3357
3358     if (!dc) return FALSE;
3359
3360     if (!abcf) goto done;
3361     if (!(abc = HeapAlloc( GetProcessHeap(), 0, (last - first + 1) * sizeof(*abc) ))) goto done;
3362
3363     dev = GET_DC_PHYSDEV( dc, pGetCharABCWidths );
3364     ret = dev->funcs->pGetCharABCWidths( dev, first, last, abc );
3365     if (ret)
3366     {
3367         /* convert device units to logical */
3368         for (i = first; i <= last; i++, abcf++)
3369         {
3370             abcf->abcfA = abc[i - first].abcA * dc->xformVport2World.eM11;
3371             abcf->abcfB = abc[i - first].abcB * dc->xformVport2World.eM11;
3372             abcf->abcfC = abc[i - first].abcC * dc->xformVport2World.eM11;
3373         }
3374     }
3375     HeapFree( GetProcessHeap(), 0, abc );
3376
3377 done:
3378     release_dc_ptr( dc );
3379     return ret;
3380 }
3381
3382 /*************************************************************************
3383  *      GetCharWidthFloatA [GDI32.@]
3384  */
3385 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
3386                                     UINT iLastChar, PFLOAT pxBuffer)
3387 {
3388     FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
3389     return 0;
3390 }
3391
3392 /*************************************************************************
3393  *      GetCharWidthFloatW [GDI32.@]
3394  */
3395 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
3396                                     UINT iLastChar, PFLOAT pxBuffer)
3397 {
3398     FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
3399     return 0;
3400 }
3401
3402
3403 /***********************************************************************
3404  *                                                                     *
3405  *           Font Resource API                                         *
3406  *                                                                     *
3407  ***********************************************************************/
3408
3409 /***********************************************************************
3410  *           AddFontResourceA    (GDI32.@)
3411  */
3412 INT WINAPI AddFontResourceA( LPCSTR str )
3413 {
3414     return AddFontResourceExA( str, 0, NULL);
3415 }
3416
3417 /***********************************************************************
3418  *           AddFontResourceW    (GDI32.@)
3419  */
3420 INT WINAPI AddFontResourceW( LPCWSTR str )
3421 {
3422     return AddFontResourceExW(str, 0, NULL);
3423 }
3424
3425
3426 /***********************************************************************
3427  *           AddFontResourceExA    (GDI32.@)
3428  */
3429 INT WINAPI AddFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3430 {
3431     DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3432     LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3433     INT ret;
3434
3435     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3436     ret = AddFontResourceExW(strW, fl, pdv);
3437     HeapFree(GetProcessHeap(), 0, strW);
3438     return ret;
3439 }
3440
3441 static BOOL CALLBACK load_enumed_resource(HMODULE hModule, LPCWSTR type, LPWSTR name, LONG_PTR lParam)
3442 {
3443     HRSRC rsrc = FindResourceW(hModule, name, type);
3444     HGLOBAL hMem = LoadResource(hModule, rsrc);
3445     LPVOID *pMem = LockResource(hMem);
3446     int *num_total = (int *)lParam;
3447     DWORD num_in_res;
3448
3449     TRACE("Found resource %s - trying to load\n", wine_dbgstr_w(type));
3450     if (!AddFontMemResourceEx(pMem, SizeofResource(hModule, rsrc), NULL, &num_in_res))
3451     {
3452         ERR("Failed to load PE font resource mod=%p ptr=%p\n", hModule, hMem);
3453         return FALSE;
3454     }
3455
3456     *num_total += num_in_res;
3457     return TRUE;
3458 }
3459
3460 /***********************************************************************
3461  *           AddFontResourceExW    (GDI32.@)
3462  */
3463 INT WINAPI AddFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3464 {
3465     int ret = WineEngAddFontResourceEx(str, fl, pdv);
3466     if (ret == 0)
3467     {
3468         /* FreeType <2.3.5 has problems reading resources wrapped in PE files. */
3469         HMODULE hModule = LoadLibraryExW(str, NULL, LOAD_LIBRARY_AS_DATAFILE);
3470         if (hModule != NULL)
3471         {
3472             int num_resources = 0;
3473             LPWSTR rt_font = (LPWSTR)((ULONG_PTR)8);  /* we don't want to include winuser.h */
3474
3475             TRACE("WineEndAddFontResourceEx failed on PE file %s - trying to load resources manually\n",
3476                 wine_dbgstr_w(str));
3477             if (EnumResourceNamesW(hModule, rt_font, load_enumed_resource, (LONG_PTR)&num_resources))
3478                 ret = num_resources;
3479             FreeLibrary(hModule);
3480         }
3481     }
3482     return ret;
3483 }
3484
3485 /***********************************************************************
3486  *           RemoveFontResourceA    (GDI32.@)
3487  */
3488 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
3489 {
3490     return RemoveFontResourceExA(str, 0, 0);
3491 }
3492
3493 /***********************************************************************
3494  *           RemoveFontResourceW    (GDI32.@)
3495  */
3496 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
3497 {
3498     return RemoveFontResourceExW(str, 0, 0);
3499 }
3500
3501 /***********************************************************************
3502  *           AddFontMemResourceEx    (GDI32.@)
3503  */
3504 HANDLE WINAPI AddFontMemResourceEx( PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
3505 {
3506     HANDLE ret;
3507     DWORD num_fonts;
3508
3509     if (!pbFont || !cbFont || !pcFonts)
3510     {
3511         SetLastError(ERROR_INVALID_PARAMETER);
3512         return NULL;
3513     }
3514
3515     ret = WineEngAddFontMemResourceEx(pbFont, cbFont, pdv, &num_fonts);
3516     if (ret)
3517     {
3518         __TRY
3519         {
3520             *pcFonts = num_fonts;
3521         }
3522         __EXCEPT_PAGE_FAULT
3523         {
3524             WARN("page fault while writing to *pcFonts (%p)\n", pcFonts);
3525             RemoveFontMemResourceEx(ret);
3526             ret = 0;
3527         }
3528         __ENDTRY
3529     }
3530     return ret;
3531 }
3532
3533 /***********************************************************************
3534  *           RemoveFontMemResourceEx    (GDI32.@)
3535  */
3536 BOOL WINAPI RemoveFontMemResourceEx( HANDLE fh )
3537 {
3538     FIXME("(%p) stub\n", fh);
3539     return TRUE;
3540 }
3541
3542 /***********************************************************************
3543  *           RemoveFontResourceExA    (GDI32.@)
3544  */
3545 BOOL WINAPI RemoveFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3546 {
3547     DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3548     LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3549     INT ret;
3550
3551     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3552     ret = RemoveFontResourceExW(strW, fl, pdv);
3553     HeapFree(GetProcessHeap(), 0, strW);
3554     return ret;
3555 }
3556
3557 /***********************************************************************
3558  *           RemoveFontResourceExW    (GDI32.@)
3559  */
3560 BOOL WINAPI RemoveFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3561 {
3562     return WineEngRemoveFontResourceEx(str, fl, pdv);
3563 }
3564
3565 /***********************************************************************
3566  *           GetTextCharset    (GDI32.@)
3567  */
3568 UINT WINAPI GetTextCharset(HDC hdc)
3569 {
3570     /* MSDN docs say this is equivalent */
3571     return GetTextCharsetInfo(hdc, NULL, 0);
3572 }
3573
3574 /***********************************************************************
3575  *           GetTextCharsetInfo    (GDI32.@)
3576  */
3577 UINT WINAPI GetTextCharsetInfo(HDC hdc, LPFONTSIGNATURE fs, DWORD flags)
3578 {
3579     UINT ret = DEFAULT_CHARSET;
3580     DC *dc = get_dc_ptr(hdc);
3581     PHYSDEV dev;
3582
3583     if (dc)
3584     {
3585         dev = GET_DC_PHYSDEV( dc, pGetTextCharsetInfo );
3586         ret = dev->funcs->pGetTextCharsetInfo( dev, fs, flags );
3587         release_dc_ptr( dc );
3588     }
3589
3590     if (ret == DEFAULT_CHARSET && fs)
3591         memset(fs, 0, sizeof(FONTSIGNATURE));
3592     return ret;
3593 }
3594
3595 /***********************************************************************
3596  *           GdiGetCharDimensions    (GDI32.@)
3597  *
3598  * Gets the average width of the characters in the English alphabet.
3599  *
3600  * PARAMS
3601  *  hdc    [I] Handle to the device context to measure on.
3602  *  lptm   [O] Pointer to memory to store the text metrics into.
3603  *  height [O] On exit, the maximum height of characters in the English alphabet.
3604  *
3605  * RETURNS
3606  *  The average width of characters in the English alphabet.
3607  *
3608  * NOTES
3609  *  This function is used by the dialog manager to get the size of a dialog
3610  *  unit. It should also be used by other pieces of code that need to know
3611  *  the size of a dialog unit in logical units without having access to the
3612  *  window handle of the dialog.
3613  *  Windows caches the font metrics from this function, but we don't and
3614  *  there doesn't appear to be an immediate advantage to do so.
3615  *
3616  * SEE ALSO
3617  *  GetTextExtentPointW, GetTextMetricsW, MapDialogRect.
3618  */
3619 LONG WINAPI GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height)
3620 {
3621     SIZE sz;
3622     static const WCHAR alphabet[] = {
3623         'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
3624         'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
3625         'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
3626
3627     if(lptm && !GetTextMetricsW(hdc, lptm)) return 0;
3628
3629     if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
3630
3631     if (height) *height = sz.cy;
3632     return (sz.cx / 26 + 1) / 2;
3633 }
3634
3635 BOOL WINAPI EnableEUDC(BOOL fEnableEUDC)
3636 {
3637     FIXME("(%d): stub\n", fEnableEUDC);
3638     return FALSE;
3639 }
3640
3641 /***********************************************************************
3642  *           GetCharWidthI    (GDI32.@)
3643  *
3644  * Retrieve widths of characters.
3645  *
3646  * PARAMS
3647  *  hdc    [I] Handle to a device context.
3648  *  first  [I] First glyph in range to query.
3649  *  count  [I] Number of glyph indices to query.
3650  *  glyphs [I] Array of glyphs to query.
3651  *  buffer [O] Buffer to receive character widths.
3652  *
3653  * NOTES
3654  *  Only works with TrueType fonts.
3655  *
3656  * RETURNS
3657  *  Success: TRUE
3658  *  Failure: FALSE
3659  */
3660 BOOL WINAPI GetCharWidthI(HDC hdc, UINT first, UINT count, LPWORD glyphs, LPINT buffer)
3661 {
3662     ABC *abc;
3663     unsigned int i;
3664
3665     TRACE("(%p, %d, %d, %p, %p)\n", hdc, first, count, glyphs, buffer);
3666
3667     if (!(abc = HeapAlloc(GetProcessHeap(), 0, count * sizeof(ABC))))
3668         return FALSE;
3669
3670     if (!GetCharABCWidthsI(hdc, first, count, glyphs, abc))
3671     {
3672         HeapFree(GetProcessHeap(), 0, abc);
3673         return FALSE;
3674     }
3675
3676     for (i = 0; i < count; i++)
3677         buffer[i] = abc->abcA + abc->abcB + abc->abcC;
3678
3679     HeapFree(GetProcessHeap(), 0, abc);
3680     return TRUE;
3681 }
3682
3683 /***********************************************************************
3684  *           GetFontUnicodeRanges    (GDI32.@)
3685  *
3686  *  Retrieve a list of supported Unicode characters in a font.
3687  *
3688  *  PARAMS
3689  *   hdc  [I] Handle to a device context.
3690  *   lpgs [O] GLYPHSET structure specifying supported character ranges.
3691  *
3692  *  RETURNS
3693  *   Success: Number of bytes written to the buffer pointed to by lpgs.
3694  *   Failure: 0
3695  *
3696  */
3697 DWORD WINAPI GetFontUnicodeRanges(HDC hdc, LPGLYPHSET lpgs)
3698 {
3699     DWORD ret;
3700     PHYSDEV dev;
3701     DC *dc = get_dc_ptr(hdc);
3702
3703     TRACE("(%p, %p)\n", hdc, lpgs);
3704
3705     if (!dc) return 0;
3706
3707     dev = GET_DC_PHYSDEV( dc, pGetFontUnicodeRanges );
3708     ret = dev->funcs->pGetFontUnicodeRanges( dev, lpgs );
3709     release_dc_ptr(dc);
3710     return ret;
3711 }
3712
3713
3714 /*************************************************************
3715  *           FontIsLinked    (GDI32.@)
3716  */
3717 BOOL WINAPI FontIsLinked(HDC hdc)
3718 {
3719     DC *dc = get_dc_ptr(hdc);
3720     PHYSDEV dev;
3721     BOOL ret;
3722
3723     if (!dc) return FALSE;
3724     dev = GET_DC_PHYSDEV( dc, pFontIsLinked );
3725     ret = dev->funcs->pFontIsLinked( dev );
3726     release_dc_ptr(dc);
3727     TRACE("returning %d\n", ret);
3728     return ret;
3729 }
3730
3731 /*************************************************************
3732  *           GdiRealizationInfo    (GDI32.@)
3733  *
3734  * Returns a structure that contains some font information.
3735  */
3736 BOOL WINAPI GdiRealizationInfo(HDC hdc, realization_info_t *info)
3737 {
3738     DC *dc = get_dc_ptr(hdc);
3739     PHYSDEV dev;
3740     BOOL ret;
3741
3742     if (!dc) return FALSE;
3743     dev = GET_DC_PHYSDEV( dc, pGdiRealizationInfo );
3744     ret = dev->funcs->pGdiRealizationInfo( dev, info );
3745     release_dc_ptr(dc);
3746     return ret;
3747 }